SE521600C2 - Lågbittaktskodek - Google Patents

Description

lO 15 20 25 30 35 = » ; . . , 521 690 2 signal redan har blivit, eller skulle ha blivit, levere- rad till mottagarsidan, t.ex. för uppspelning av en högtalare eller för visning på en bildskärm. Av detta skäl är ett paket som anländer för sent lika med ett förlorat paket.

Vid överföring av en realtidssignal som paket är huvudproblemet med förlorade eller fördröjda datapaket introduktionen av distortion i den rekonstruerade signalen. Distortionen är ett resultat av det faktum att signalsegment som transporteras av förlorade eller för- dröjda datapaket inte kan rekonstrueras.

Vid överföring av en signal är det oftast önskvärt att använda så lite bandbredd som möjligt. Det är väl känt att många signaler har mönster som innehåller redundanser. Lämpliga kodningsförfaranden kan undvika sändningen av den redundanta informationen varigenom en mer bandbreddseffektiv sändning av signalen möjliggörs.

Typiska kodningsförfaranden som drar fördel av sådana redundanser är prediktiva kodningsförfaranden. Ett prediktivt kodningsförfarande kodar ett signalmönster baserat på beroenden mellan mönstrets representationer.

Det kodar signalen för sändning med en fix bittakt och med en kompromiss mellan signalkvaliteten och sändningens bittakt. Exempel på prediktiva kodningsförfarande som används för tal är LPC (Linear Predictive Doding)- och CELP (Code Excited Linear Prediction)-förfaranden vilka båda kodningsförfaranden är väl kända för fackmannen.

I ett förfaringssätt för prediktiv kodning är ett kodningstillstånd beroende av tidigare kodade delar av signalen. Vid användning av prediktiv kodning i kombina- tion med packetering av den kodade signalen, kommer ett förlorat paket att leda till felpropagering eftersom information på vilken det prediktiva kodningstillståndet vid mottagaränden är beroende kommer att gå förlorad tillsammans med det förlorade paketet. Detta betyder att avkodning av efterföljande paket kommer att starta med ett felaktigt kodningstillstånd. Felet på grund av det lO 15 20 25 30 u; U'| .. Q., 5:21 600 =,,K .f n. '1*"ß!| 3 förlorade paketet kommer således att propagera under avkodning och rekonstruktion av signalen.

Ett sätt att lösa detta problem med felpropagering är att återställa kodningstillståndet i början av den kodade signaldelen som innefattas av ett paket. Ett sådant återställande av kodningstillståndet kommer emellertid att leda till en försämring av kvaliteten för den rekonstruerade signalen. Ett annat sätt att reducera effekten av ett förlorat paket är att använda olika förfaringssätt för att inkludera redundant information vid kodning av signalen. På detta sätt kan kodningstill- ståndet efter ett förlorat paket approximeras. Ett sådant förfaringssätt kräver emellertid inte bara mer bandbredd för överföring av den kodade signalen, det kommer även att endast reducera effekten av det förlorade paketet.

Eftersom effekten av ett förlorat paket inte helt kommer att elimieras, kommer felpropagering fortfarande att vara närvarande och resultera i en perceptuellt lägre kvalitet av den rekonstruerade signalen.

Ett annat problem med prediktiva kodare i den kända tekniken är kodningen, och efterföljande rekonstruktion, av plötsliga signalövergàngar från en relativt mycket låg till en mycket högre signalnivå, t.ex. under en rösttons inledning i en talsignal. Vid kodning av sådana över- gångar är det svårt att få kodningstillstånden att åter- spegla den plötsliga övergången, och än viktigare, inled- ningen av röstperioden som följer efter övergången. Detta kommer i sin tur att leda till en försämrad kvalitet av den rekonstruerade signalen på avkodningssidan.

Sammanfattning av uppfinningen En syfte med föreliggande uppfinning är att undan- röja åtminstone några av de ovannämnda problemen i sam- band med prediktiv kodning/avkodning av en signal som sänds i paket.

Ett annat syfte är att möjliggöra ett förbättrat utförande på avkodningssidan i samband med prediktiv 10 15 20 25 30 35 Q . - r « | - . § . v e 521 600 4 kodning/avkodning när ett paket med en kodad signaldel sänd från en kodningssida förloras innan det mottas pà avkodningssidan.

Ytterligare ett syfte är att förbättra den predik- tiva kodningen och avkodningen av en signal som uppvisar en plötslig ökning av sin signaleffekt.

Enligt föreliggande uppfinning uppnås dessa syften av förfaranden, anordningar och datorläsbara medier som har de särdrag som definieras i de bifogade patentkraven och som respresenterar olika aspekter på uppfinningen.

Enligt uppfinningen delas en signal upp i block för block för block.

Idén år att tillhandahålla prediktiv kodning/avkodning av att sedan kodas, och slutligen avkodas, ett block så att kodningen/avkodningen är oberoende av förekommande tidigare block, allt medan att fortfarande kunna tillhandahålla prediktiv kodning/avkodning av en inledande del av blocket på sådant sätt att en mot- svarande del av signalen kan reproduceras med samma kvalitetsnivå som andra delar av signalen. Detta uppnås genom att basera kodningen och avkodningen av ett block på ett kodat starttillstànd som återfinns någonstans Starttillståndet kodas/ avkodas med hjälp av något lämpligt kodningsförande. En andra blockdel och en tredje blockdel, om det fastställs mellan blockets ändgränser. att en sådan tredje del existerar, på respektive sidor om starttillståndet och mellan blockgränserna kodas/avkodas sedan med användning av något prediktivt kodningsför- farande. För att möjliggöra prediktiv kodning/avkodning av båda blockdelarna som omger starttillståndet, och eftersom kodning/avkodning av båda dessa delar kommer att baseras på samma starttillstànd, kodas/avkodas de två blockdelarna i motsatt riktning med hänsyn till varandra.

Till exempel kodas/avkodas blockdelen som är placerad i den avslutande delen av blocket längs signalmönstret såsom detta uppträder i tiden, medan den andra delen placerad i inledningen av blocket kodas/avkodas längs 10 15 20 25 30 35 . - f . . . « - f . 1 f 521 609 5 signalmönstret bakàt i tiden, från senare uppträdande signalmönster till tidigare uppträdande signalmönster.

Genom kodning av blocket i tre steg i enlighet med uppfinningen uppnàs kodningsoberoende mellan blocken och möjliggörs alltid korrekt prediktiv kodning/avkodning av den inledande delen av blocket. De tre kodningsstegen är: * Kodning av en första del av blocket, vilken kodade del representerar ett kodat starttillstànd.

* Kodning av en andra blockdel mellan det kodade starttillstàndet och en av blockets ändgränser med användning av ett prediktivt kodningsförfarande som gradvis kodar denna andra blockdel fràn starttillstàndet till ändgränsen.

* Fastställande huruvida en tredje blockdel existe- rar mellan det kodade starttillstàndet och den andra av de två blockändgränserna, och om så är fallet, kodning av denna tredje blockdel med användning av ett prediktivt kodningsförfarande som gradvis kodar denna tredje block- del från starttillstàndet till denna andra ändgräns. Med avseende pà en tidbas associerad med blocket, kodas den tredje blockdelen i motsatt riktning i jämförelse med kodningen av den andra blockdelen.

Pâ motsvarande sätt utförs avkodning av ett kodat block i tre steg vid reproduktion av ett motsvarande avkodat signalblock.

* Avkodning av det kodade starttillstàndet.

* Avkodning av en kodad andra del av blocket. Ett prediktivt kodningsförfarande baserat pà starttillstàndet används för reproducering av den andra delen av blocket placerad mellan starttillstàndet och en av de tvà änd- gränserna för blocket.

* Fastställande huruvida en kodad tredje blockdel existerar, och om så är fallet, avkodning av denna kodade tredje del hos blocket. Återigen används ett prediktivt avkodningsförfarande baserat pà starttillstàndet för reproduktion av blockets tredje del placerat mellan starttillstàndet och den andra av de tvà ändgränserna för lO 15 20 25 30 35 . . I . . - » « = 1 « n 5221 600 6 blocket. Med hänsyn till en tidbas associerad med det reproducerade blocket, reproduceras denna tredje del av blocket i motsatt riktning i jämförelse med reproduk- tionen av den andra delen av blocket.

Signalen som är föremål för kodning i enlighet med föreliggande uppfinning motsvarar antingen en digital signal eller en residualsignal av en analysfiltrerad digital signal. Signalen innefattar ett sekventiellt mönster som representerar ljud, såsom tal eller audio, eller något annat fenomen som kan representeras som ett sekventiellt mönster, t.ex. en video- eller en EKG-signal (ElectroCardioGram). Föreliggande uppfinning är således tillämpbar på ett valfritt sekventiellt mönster som kan kodas så att det beskrivs av konsekutiva tillstånd som är korrelerade med varandra.

Det är föredraget att kodningen/avkodningen av starttillstàndet utnyttjar ett kodningsförfarande som är oberoende av tidigare delar av signalen, varigenom blocket görs självständigt med avseende på information som definierar starttillståndet. När uppfinningen emellertid tillämpas i LPC-residualdomänen, används företrädesvis kodning/avkodning också för starttill- ståndet. Genom antagandet att kvantiseringsbruset i den avkodade signalen som föregår inledningen av starttill- stàndet kan försummas, kan en prediktiv kodares felvikt- ning eller felåterkopplingsfilter startas från ett noll- tillstànd. På detta sätt uppnås den självständiga kod- ningen av starttillståndet.

Det är föredraget att dela upp signalblocket i en uppsättning av konsekutiva intervall och att välja starttillstàndet till att motsvara en eller flera kon- sekutiva intervall av de intervall som har högst signalenergi. Detta betyder att kodningen/avkodningen av starttillstàndet kan optimeras mot en signaldel med relativt hög signalenergi. På detta sätt àstadkoms en kodning/avkodning av resten av blocket som är effektiv ur en perceptuell synvikel eftersom den kan baseras på ett .n u;- l0 15 20 25 30 35 m .fn m fw; 521 600 7 starttillstànd som är kodat/avkodat med en hög nog- grannhet.

En fördel med föreliggande uppfinning är att den möjliggör att prediktiv kodning kan utföras på sådant sätt att det kodade blocket blir självständigt med av- seende på information i exciteringsdomänen, d.v.s den kodade informationen kommer inte att vara korrelerad med information i något tidigare kodat block. Vid avkodning kommer följaktligen avkodningen av det kodade blocket att baseras på självständig information i det kodade blocket.

Detta betyder att om ett paket som bär ett kodat block förloras under sändning, kommer den prediktiva kodningen av efterföljande kodade block i efterföljande mottagna paket inte att påverkas av förlorad tillståndsinformation i det förlorade paketet.

Föreliggande uppfinning undviker således problement med felpropagering som konventionell prediktiv kodning/ avkodning konfronteras med under avkodning när ett paket som bär ett kodat block går förlorat innan mottagning på avkodningssidan. Följaktligen kommer en kodek som utnyttjar särdragen hos föreliggande uppfinning att bli mer robust mot paketförluster.

Det är föredraget att välja starttillståndet så att detta är placerat i den del av blocket som är associerad med den högsta signaleffekten. Detta betyder t.ex. att starttillståndet i en talsignal som består av tonande och icke tonande delar kommer att vara placerat väl inom den tonande delen i ett block som innefattar en icke tonande och en tonande del.

I en talsignal återfinns hög korrelation mellan signalsampel inom en tonande del och låg korrelation mellan signalsampel inom en icke tonande del. Korrela- tionen i övergångsregionen mellan en icke tonande del och är mindre och svår att en tonande del, och vice versa, utnyttja. Från en perceptuell synvinkel är det viktigare att uppnå en bra vågformsöverensstämmelse vid reproduk- tion av en tonande del av signalen, medan en vågforms- » « . . . a lO 15 20 25 30 35 « q . v « v . . > K f n 521 60Û 8 överensstämmelse för en icke tonande del är mindre viktig.

Konventionella prediktiva kodare arbetar på signal- representationer i samma ordning som den med vilken motsvarande signal produceras av signalkällan. Vilket kodningstillstànd som helst som representerar signalen vid en viss tidpunkt kommer således att vara korrelerad med tidigare kodningstillstànd som representerar tidigare delar av signalen. På grund av svårigheterna att utnyttja någon korrelering under en övergång från en icke tonande period till en tonande period, kommer kodningstillstànden för konventionella prediktiva kodare att under inled- ningen av en tonande period som följer efter en sådan övergång att innefatta information som ger en ganska dålig approximering av den ursprungliga signalen.

Följaktligen kommer regenereringen av talsignalen på avkodningssidan att tillhandahålla en perceptuellt försämrad signal för inledningen av den tonande regionen.

Genom placering av starttillståndet väl inom en tonande region i ett block, och sedan koda/avkoda blocket från starttillståndet mot ändgränserna, kan föreliggande uppfinning möjliggöra ett mera fullständigt utnyttjande av den höga korrelationen i den tonande regionen till förmån för perceptionen. Övergången från icke tonande till högt periodiskt tonande ljud tar ett antal tonhöjds- perioder. Vid placering av starttillståndet väl inom en tonande region i ett block kommer den höga bittakten för starttillstàndskodningen att appliceras i en tonhöjds- cykel där hög periodicitet har etablerats, i stället för i en av de allra första tonhöjdscyklerna i den tonande regionen.

Ovannämnda och ytterligare särdrag hos, och fördelar med, föreliggande uppfinning kommer att beskrivas mer detaljerat i den följande beskrivningen. . « . . l u 10 15 20 25 30 35 1 . , , 1 1 Kort beskrivning av ritningarna Fig. l visar en översikt över den sändande delen i ett system för överföring av ljud över ett paketförmedlat nät; Fig. 2 visar en översikt över den mottagande delen i ett system för överföring av ljud över ett paketförmedlat nät; Fig. 3 visar ett exempel pà ett residualsignalblock; Fig. 4 visar delblocksenheter och màl för starttillstàndet med högre upplösning vid kodning av residualen i Fig. 3; Fig. 5 visar ett funktionsblockschema över en kodare som kodar ett starttillstànd i enlighet med en utförings- form av uppfinningen; Fig. 6 visar ett funktionsblockschema över en avkodare som utför en avkodningsoperation som motsvarar kodaren i Fig. 5; Fig. 7 visar kodningen av en signal fràn starttill- stàndet mot blockändgränserna; och Fig. 8 visar ett funktionsblocksschema över en sökning i en adaptiv kodbok som fördelaktigt utnyttjas av en utföringsform av föreliggande uppfinning.

Detaljerad beskrivning av uppfinningen Funktionaliteten för kodningen och avkodningen enligt uppfinning innefattas typiskt av en kodek som har en kodningsdel och en avkodningsdel. Med hänvisning till Fig. 1 och 2 visas en utföringsform av uppfinningen i ett system som används för överföring av ljud över ett paket- förmedlat nät.

I Fig. 1 innefattas en kodare 130 som arbetar i enlighet med föreliggande uppfinning i ett sändande system. I detta system fångas ljudvàgen upp av en mikro- fon 110 och omvandlas till en analog elektrisk signal 115. Denna signal samplas och digitaliseras av en A/D- omvandlare 120 för att resultera i en samplad signal 125.

Den samplade signalen matas till en kodare 130. 10 15 20 25 30 b.) UI .I we» 5121 600 lO Utsignalen från kodaren består av datapaket 135. Varje datapaket innehåller komprimerad information om ett block med sampel. Datapaketen vidarebefordras via en styrenhet 140 till det paketförmedlade nätet.

I Fig. 2 innefattas en avkodare 270 som arbetar i enlighet med föreliggande uppfinning av ett mottagnade system. I detta system mottages datapaketen från det paketförmedlade nätet av en styrenhet 250 och lagras i en jitterbuffert 260. Från jitterbufferten görs datapaket 265 tillgängliga för avkodaren 270. Utsignalen från avkodaren är en samplad digital signal 275. Varje data- paket resulterar i ett block av signalsampel. Den samp- lade digitala signalen matas till en D/A-omvandlare 280 för att resultera i en analog elektrisk signal 285. Denna signal kan vidarebefordras till en ljudomvandlare 290 som innefattar en högtalare för att resultera i en reproduce- rad ljudvåg.

Det väsentliga för kodeken är linjär prediktiv kodning (LPC, Linear Predictive Coding) som är väl känd fràn adaptiv prediktiv kodning (APC, Adaptive Predictive Coding) och kodexciterad linjär prediktion (CELP, Code Excited Linear Prediction). En kodek enligt föreliggande uppfinning använder emellertid ett starttillstànd, d.v.s. en sekvens av sampel lokaliserade inom signalblocket, för att initiera kodningen av resterande delar av signal- blocket, Principen hos uppfinningen överensstämmer med ett tillvägagångssätt av typen analys-syntes med öppen slinga för nämnda LPC såväl som tillvägagàngssättet med analys-genom-syntes med sluten slinga, vilket är väl känt från nämnda CELP. En kodning av typen öppen slinga i en perceptuellt viktad domän tillhandahåller ett alternativ till analys-genom-syntes för att erhålla en perceptuell viktning av kodningsbruset. Vid jämförelse med analys- genom-syntes tillhandahåller detta förfarande en fördel- aktig kompromiss mellan talkvaliteten och beräknings- komplexiteten för det föreslagna tillvägagångssättet. 10 15 20 25 30 bd U1 ; | . v 1 u 521 600 ll Kodningen av typen öppen slinga i en perceptuellt viktad domän beskrivs senare i denna beskrivning.

Kodaren I utföringsformen i Fig. l är insignalen till kodaren den digitala signalen 125. Denna signal kan ta formen av en 16-bitars likformig PCM-signal (Pulse Code Modulation) samplad med 8 kHz och med borttagen lik- strömskomponent. Insignalen delas upp i block om t.ex. 240 sampel. Varje block delas i sin tur upp i t.ex. sex konsekutiva delblock med t.ex. 40 sampel vardera.

I princip kan vilket förfarande som helst användas för att extrahera en spektralkurva från signalblocket utan att frángà idén bakom uppfinningen. Ett förfarande som kan skisseras är det följande: För varje inmatat block utför kodaren ett antal, t.ex. tvà LPC (Linear Predicitve Coding)-analyser, var och en av en ordning om t.ex. 10. Det resulterande LPC-koefficienterna kodas, företrädesvis i form av linjespektralfrekvenser (LSF, Line Spectral Frequencies). Kodningen av nämnda LSF:er är väl känd för fackmannen. Denna kodning kan utnyttja korrelationen mellan uppsättningar av koefficienter, t.ex. genom användning av prediktiv kodning för några av dessa uppsättningar. LPC-analysten kan utnyttja olika och möjligen icke-symmetriska fönsterfunktioner för att uppnå en bra kompromiss mellan ytjämnhet och centrering av fönstren och look ahead-fördröjning introducerad i kod- ningen. De kvantiserade LPC-representationerna kan för- delaktigt interpoleras för att resultera i ett större antal ytjämna tidsvarierande uppsättningar av LSF- koefficienter. Därefter erhålls LPC-residualen med användning av de kvantiserade och ytutjämningsinterpolerade LSF-koefficienterna konverterade till koefficienter för ett analysfilter.

Ett exempel pà ett residualsignalblock 315 och dess 317, 318, 319, 320 och 321 visas i Fig. 3, varvid antalet delblock endast anges i uppdelning i delblock 316, å. »;.« lO 15 20 25 30 35 5121 600 12 illustrerande syfte. I denna figur indikerar varje inter- vall på tidsaxeln ett delblock. Identifieringen av ett mål för ett starttillstánd inom det exemplifierade residualblocket i Fig. 3 visas i Fig. 4. I en enkel implementering kan detta mål t.ex. identifieras som de två konsekutiva delblocken 317 och 318 hos den residual som uppvisar den maximala energin för två valfria konsekutiva delblock inom blocket. Målets längd kan dessutom ytterligare kortas ner och placeras med högre tidsupplösning genom identifiering av en uppsättning av konsekutiva sampel 325 med en möjlig fördefinierad längd inom intervallet för de två delblocken. Företrädesvis kan ett sådant subset väljas som ett avslutande eller efterföljande fördefinierat antal, t.ex. 58, med sampel inom intervallet för de två delblocken. Återigen kan valet mellan avslutande eller efterföljande subset baseras på ett kriterium vad gäller maximal energi.

Kodning av starttillstánd Utan att frångà andemeningen i uppfinningen kan starttillstàndet kodas med i princip vilket kodnings- förfarande som helst.

Enligt en utföringsform av uppfinningen används skalär kvanticering med prediktiv brusformning, såsom visas i Fig. 5. Enligt uppfinningen föregås den skalära kvantiseringen av en allpassfiltrering 520 konstruerad att sprida sampelenergin på alla sampel i starttill- stàndet. Det har visat sig att detta resulterar i en bra avvägning mellan överbelastning och kornigt brus hos en kvantiserare som arbetar med fasta skalärer och låg bit- takt. En enkel konstruktion av ett sådant allpassfilter erhålls genom applicering av LPC-syntesfiltret framåt i tiden och det motsvarande LPC-analysfiltret bakåt i tiden. Mer specifikt, när det kvantiserade LPC-analys- filtret är Aq(z), med koefficienterna 516, så ges all- passfiltret 520 av Aq(z^-1)/Aq(z). operationen av detta filter i avkodaren, För den inverterade skall kodade 10 15 20 25 30 u: U1 . ~ . . .a 521 600 13 LPC-koefficienter användas och filtreringen skall vara en cirkulär faltning av starttillstàndets längd. Den reste- rande delen av starttillstàndskodaren är väl känd för fackmannen inom området: Det filtrerade målet 525 norma- liseras för att uppvisa en tidigare definierad maximal amplitud med utnyttjande av normaliseringen 530, för att resultera i det normaliserade màlet 535 och ett index för kvantiserade normaliseringsfaktorn 536. Viktningen av kvantiseringsfelet delas upp i en filtrering 540 av det normaliserade målet 535 och en filtrering 560 av det kvantiserade målet 556, fràn vilket klingningen, eller noll-svaret, 545 för varje sampel subtraheras från det viktade målet 545 för att resultera i det kvantiserade målet 547, vilket matas till kvantiseraren 550. Resul- tatet blir en sekvens av index 555 för det kvantiserade starttillståndet.

Vilka viktningsfilter 540 och 560 som helst för att forma bruset kan användas i denna utföringsform. Före- trädesvis används samma brusformning vid kodning av starttillståndet som vid den efterföljande kodningen av det resterande signalblocket, vilket beskrivs senare. Som ett exempel kan brusformningen implementeras genom minimering av kvantiseringsfelet efter viktning av detta med ett vikningsfilter som är lika med A(z/Ll)/(Aq(z)*A(z/L2)), där A(z) är det icke-kvantisera- de LPC-analysfiltret efter en möjlig initial bandbredds- expansion, Aq(z) är det kvantiserade LPC-analysfiltret och Ll och L2 är bandbreddsexpansionskoefficienter, vilka fördelaktigt kan sättas till Ll=O,8 respektive L2=O,6.

Alla LPC- och viktningskoefficienter som krävs i denna filtrering är i Fig. 5 ihopsamlade i insignalerna 546 och 565. I ett alternativ med kortare impulssvar, användbart när den kvarvarande kodningen görs med det tredje alternativa förfarandet som beskrivs senare, sätts Ll=l,O och L2=Û,4.

Nedan följer ett exempel i c-kod av en implementering av en starttillstàndskodare 10 15 20 25 30 35 521 600 a§}w§§ÉL§§ï 14 void StateSearchw( /* kodning av ett tillstànd */ float float float flOat *residual, /* (i) målresidualvektor, d.v.s signal 515 i Fig. 5 */ *syntDenum, /* (i) lpc-koefficienter för signalerna 516, 546 och 565 i Fig. *weightNum, /* (i) viktningsfilterräknare för signalerna 546 och 565 i Fig. *weightDenum, /* (i) viktningsfilternedräknare för signalerna 546 och 565 i Fig. 5 */ int *idxForMax, /* (o) kvantiserarindex för maximal amplitud, d.v.s. signal 536 i Fig.5 */ int *idxVec, /* (o) vektor med kvantiseringsindex, d.v.s. signal 555 i Fig. 5 */ int len /* (i) längden av alla vektorer, t.ex. 58 */ ); void AbsQuantW(float *in, float *syntDenum, float *weightNum, float *weightDenum, *OUt, int len) { float *target, targetßuf[FILTERORDER+STATE_LEN], *SyntOut, syntOutBuf[FILTERORDER+STATE_LEN], 'weightOut, weightüutßuf[FILTERORDER+STATE_LEN], t0Q, Xqí int n; int index; memset(targetBuf, 0, FILTERORDER*sizeof(float)); memset(syntOutBuf, 0, FILTERORDER*sizeof(float)); memset(weightOutBuf, O, FILTERORDER*sizeof(float)); target = &targetBuf[FILTERORDER]; syntOut = &syntOutBuf[FILTERORDER]; weightOut = &weiQhtOutBuf[FILTERORDER]; for(n=0;n if( n==sTATE_LEN/2 ){ syntDenum += (FILTERORDER+1); weightNum += (FILTERORDER+1); weightDenum += (FILTERORDER+1); .-.~ .una 5*/ 5 */ int 10 15 20 25 30 35 521 ßuo :f:¿fäæ;ë?f@àÛ 15 AllPoleFilter ( &in[n], weightDenum, 1, FILTERORDER ); /* denna funktion gör en filtrering av alla poler för vektorn in, resultatet returneras i samma vektor */ /* detta är filtreringen 540 i Figur 5 */ syntOut[n] = 0.0; AllPoleFilter ( &syntOut[n], weightDenum, 1, FILTERORDER ); /* detta är filtreringen 560 i Figur 5 */ /* kvantiseraren */ toQ = in[n]-syntOut[n]; /* Detta år subtraktionen av signal 566 från signal 545 resulterande i signal 547 i Figur 5 */ sort_sq(&xq, &index, toQ, state_sq3, 8); /* denna funktion gör en skalär kvantiseríng */ /* detta är funktion 550 i Figur 5 */ out{n]=index; syntOut[n] = state_sq3[out[n]]; AllPoleFilter( &syntOut[n], weightDenum, 1, FILTERORDER ); /* detta uppdaterar viktningsfiltret 560 i Figur 5 för nästa sampel */ void StateSearchW(float *residual, float *syntDenum, float *weightNum, float *weightDenum, int *idxForMax, int *idxVec, int len){ float dtmp, maxval, tmpbuf[FILTERORDER+2*STATE_LEN], *tmp, numeratOr [l+FILTERORDER] , fOutbuf [FILTERORDER+2*STATE_LEN] , *fOut; int k,utmp; int index; memset(tmpbuf, 0, FILTERORDER*sizeof(float)); memset(foutbuf, 0, FILTERORDER*sizeof(float)); for (1<=o,- kwnfraaoanan; k++> { 10 15 20 25 30 35 521 600 §'jï?§§§“ 16 numerator[k]=syntDenum[FILTERORDER-k]; } numerator[FILTERORDER]=syntDenum[0]; tmp = &tmpbuf[FILTERORDER]; fOut = &fOutbuf[FILTERORDER]; /* härifrån */ memcpy(tmp, residual, len*sizeof(float)); memset(tmp+1en, 0, 1en*sizeof(float)); ZeroPoleFilter(tmp, numerator, syntDenum, 2*len, FILTERORDER,fout); /* denna funktion gör en filtrering m.a.p. nollpol av tmp och returnerar den filtrerade vektorn i font */ for(k=0;k fout[k] += fout[k+len]; } /* till hit är allpassfiltreringen 520 i Figur S */ maxval = fout[0]; for(k=1; k<1en; k++){ if(fout[k]*fout[k] > maxVal*maxVal){ maxval = fout[k]; } maxVal=(float)fabs(maxVal); if(maxVal < 10.0){ maxval = 10.0; } maxval = (float)log10(maxVal); sort_sq(&dtmp, &index, maxval, state_frgq, 64); /* denna funktion gör en sortering av kvadrerade värden */ maxVal=state_frgq[index]; utmp=index; *idxForMax=utmp; maxval (f1oat)pow(10,maxVal); II maxval (float)(4.5)/maxval; lO 15 20 25 30 35 5:21 600 17 for(k=O;k fout[k] = maxval; /* detta är normaliseringen 530 i Figur 5 */ } AbsQuantW(fout,syntDenum,weightNum,weightDenum,idxVec, len); Avkodning av starttillstànd Avkodningen av starttillstàndet följer naturligt fràn förfaringssättet som utnyttjas vid kodningen av starttillstàndet. Ett avkodningsförfarande som motsvarar kodningsförfarandet i Fig. 5 visas i Fig. 6. Först slås indexen 615 upp i en skalär kodbok 620 för att resultera i rekonstruktionen av det kvantiserade starttillstàndet 625. för de-normalisering 630 med utnyttjande av indexet för Det kvantiserade starttillstàndet blir sedan föremål den kvantiserade normaliseringsfaktorn 626. Detta pro- ducerar det de-normaliserade starttillstàndet 635, vilket matas in till det inverterade allpassfiltret 640, med koefficienterna 636, för att resultera i det avkodade starttillstàndet 645. Nedan följer ett exempel i c-kod av avkodningen av ett starttillstànd. void StateConstructW( /* avkodar ett tillstànd av talresidual */ int idxForMax, /* (i) 7-bitsindex för kvantiseringen av max amplitud, d.v.s. signal 626 i Fig. 6 */ int *idxVec, /* (i) vektor med kvantiserade index, d.v.s. signal 615 i Fig. 6 */ float *syntDenum, /* (i) syntesfilternedräknare, d.v.s. signal 636 i Fig. 6 */ float *out, /* (o) den avkodade tillstàndsvektorn, signal 645 i Fig. 6 */ d.v.s. int len /* (i) längden av en tillstàndsvektor, t.ex. 58 */ float maxval, tmpbuf[FILTERORDER+2*STATE_LEN], *tmp, numerator[FILTERORDER+l]; fløat fOutbuf [FILTERORDER+2*STATE_LEN] , *fOUt; int k,tmpi; 10 15 20 25 30 35 521 som ¿fÉïë¿.+ü}V 18 maxval = state_frgq{idxForMax]; maxval = (float)pow(10,maxVal)/(float)4.5; memset(tmpbuf, 0, FILTERORDER*sizeof(float)); memset(foutbuf, O, FILTERORDER*sizeof(float)); for (k=o,- k numerator[k]=syntDenum[FILTERORDER-k]; } numerator[FILTERORDER]=syntDenum[0]; rmp = sæmpbufII-“ILTERORDERL- fOut = Szfoutbuf IFILTERORDEIU; for(k=0; k tmpi = len-1-k; tmp[k] = maxVa1*state_sq3[idxVec[tmpi]]; /* Detta är operationerna 620 och 630 i Figur 6 */ } /* härifrån */ memset(tmp+len, 0, len*sizeof(float)); ZeroPoleFilter(tmp, numerator, syntDenum, 2*len, FILTERORDER, fout); for(k=O;k Out[k] = fout[len-1-k]+fout[2*len-1-k]; } /* till hit är operation 640 i Figur 6 */ Kodning fràn starttillstàndet mot blockgränserna Inom ramen för uppfinningen kan de kvarvarande samplena hos blocket kodas på ett flertal sätt som alla utnyttjar starttillstàndet som en initialisering av tillståndet för kodningsalgoritmen. Företrädesvis kan en linjär prediktiv algoritm användas för kodningen av de kvarvarande samplena. Speciellt möjliggör användandet av en adaptiv kodbok ett effektivt utnyttjande av starttill- stàndet under tonande talsegment. I detta fall används det kodade starttillständet för att fylla upp den adap- lO 15 20 25 30 L.) U1 , , 1 { .f 19 tiva kodboken. En initialisering av tillståndet för fel- viktningsfiltrerna görs också företrädesvis med utnytt- jande av starttillstàndet. Detaljerna för sådana initia- liseringar kan göras på ett flertal sätt som är väl kända för fackmannen inom området.

Kodningen från starttillstàndet mot blockgränserna exemplifieras av signalerna i Fig. 7.

I en utföringsform baserad på delblock för vilka starttillstàndet är identifierat som ett intervall med en tidigare bestämd längd i riktning mot en intervallände definierad av ett antal delblock, är det fördelaktigt att först applicera den adaptiva kodboksalgoritmen på det kvarvarande intervallet för att uppnå kodning av hela intervallet definierat av ett antal delblock. Till exempel utsträcks starttillstàndet 715, vilket är ett exempel på signalen 645 och vilket är en kodad repre- sentation av starttillståndsmålet 325, till ett start- tillstånd 725 med ett heltal delblockslängder. Därefter används dessa delblock som starttillstånd för kodningen av de kvarvarande delblocken inom blocket A-B (där antalet delblock endast är illustrativt).

Denna kodning kan börja med att antingen koda del- blocken senare tiden, eller med att koda delblocken tidigare i tiden. Även om båda valen är fullt möjliga inom ramen för uppfinningen, kommer endast detaljerade utföringsformer att beskrivas som startar med kodningen av delblocken senare tiden.

Kodning av delblock senare i tiden Om blocket innehåller delblock senare i tiden än de som kodats för starttillstándet, initieras en adaptiv kodbok och viktningsfilter från starttillstàndet för kodning av delblocken senare i tiden. Vart och ett av dessa delblock kodas därefter. Till exempel kan detta resultera i signalen 735 i Fig. 7. Om fler än ett del- block inom blocket är senare i tiden än starttillstàndet som består av ett helt antal delblock, uppdateras det lO 15 20 25 30 u) U1 . . 4 . » ; , « L ; i , ífi A3 ...à O\ _; CD 20 adaptiva kodboksminnet med den kodade LPC-exciteringen som förberedelse för kodningen av nästa delblock. Detta görs pà ett förfaringssätt som är väl känt för fackmannen inom området.

Kodning av delblock tidigare i tiden Om blocket innehåller delblock tidigare i tiden än de som kodats för starttillstándet, så appliceras en procedur som är lika med den som appliceras för delblock senare i tiden på de tidsreverserade blocken för kodning av dessa delblock. Skillnaden är, vid jämförelse med kodning av delblocken senare i tiden, att nu inte bara starttillstàndet men också LPC-exciteringen senare i tiden än starttillstàndet appliceras i initialiseringen av den adaptiva kodboken och det perceptuellt viktade filtret. Till exempel kommer detta att sträcka ut signalen 735 till en fullt avkodad representation 745 som är den resulterande avkodade representationen av LPC- residualen 315. Signalen 745 utgör LPC-exciteringen för avkodaren.

Kodningsstegen enligt föreliggande uppfinning har exemplifierats pà ett block med en LPC-residualsignal för 3 till 5. tillämpliga för andra signaler, t.ex. en icke-filtrerad tal i Fig. Dessa steg är emellertid också ljudsignal i tidsdomänen eller en medicinsk signal såsom EKG, utan att för den skull fràngà den generella idén bakom föreliggande uppfinning.

Exemplifierande c-kod för kodningen fràn starttillstàndet mot blockgränserna void iLBC_enc0de( /* kodningsfunktion */ float *speech, /* (i) vektor med taldata */ unsigned char *bytes, /* (o) kodade databitar */ float *block, /* (o) vektor med avkodat tal */ int mode, /* (i) 1 för vanlig kodning 2 för redundant kodning */ 10 15 20 25 30 U) U1 š21 600 ;ï:::}[aï ..- 21 float *decresidual, /* (0) avkodad residual innan förstärknings- anpassning (användbar för en redundant kodningsenhet) */ float *syntdenum, /* (o) avkodningssyntesfilter (användbara för en redundant kodningsenhet) */ float *weightnum, /* (o) viktningsupprâknare (användbar för en redundant kodningsenhet) */ float *weightdenum /* (o) viktningsnedräknare (användbar för en redundant kodningsenhet) */ float data[BLOCKL]; float residual[BLOCKL], reverseResidual[BLOCKL]; float weightnum[NSUB*(FILTERORDER+1)], weightdenum[NSUB*(FILTERORDER+1)]; int start, idxForMax, idxVec[STATE_LEN]; float reverseDecresidual[BLOCKL], mem[MEML]; int n, k, kk, meml_gotten, Nfor, Nback, i; int dummy=0; int gain_index[NSTAGES*NASUB], extra_gain_index[NSTAGES]; int cb_index[NSTAGES*NASUB], extra_cb_index[NSTAGES]; int 1sf_i[LsF_NsPLIT*LPc_N]; unsigned char *pbytes; int diff, start_pos, state_first; float enl, en2; int index, gc_index; int subcount, subframe; float weightState[FILTERORDER]; memcpy(data,block,BLOCKL*sizeof(float)); /* LPC för ingàngsdata */ LPCencode(syntdenum, weightnum, weightdenum, lsf_i, data); /* Denna funktion utför LPC-analys och kvantisering och jämn interpolering av LPC-koefficienterna */ /* Inversfilter för erhållande av residual */ for (n=O; n \..... 10 15 20 25 30 35 521 600 ïríyšíïï B 22 anaFilter(&data[n*SUBL], &syntdenum[n*(FILTERORDER+l)], SUBL, &residual[n*SUBL]); } /* Denna funktion utför en LPC-analysfiltrering med utnyttjande av kvantiserade och interpolerade LPC-koefficienter */ /* I detta skede är residualen den signal vilken signal 315 i Figur 3 är ett exempel på */ /* hitta tillstàndsplacering */ start = FrameClassify(residual); /* Denna funktion lokaliserar starttillstàndet med en upplösning på hela delramar */ /* Den variabla starten indikerar början av signalen 317,318 (Figur 4) med ett helt antal delblock */ /* Kontrollera om tillstànd ska vara i första eller sista delen av de två delramarna */ diff = STATE_LEN - STATE_SHORT__LEN; enl = 0; index = (start-l)*SUBL; fOI' (i=0; i < STATE__SHORT_LEN; i++) enl += residual[index+i]*residual[index+i]; 8112 = O; index = (start-l)*SUBL+diff; for (i = O; i < STATE_SHORT_LEN; i++) en2 += residual[index+i]*residual[index+i]; if (enl > en2) { state_first = 1; start_pos = (start-l)*SUBL; } else { state_first = 0; start_pos = (start-1)*SUBL + diff; } /* Den variabla start_pos indikerar nu början av signalen 325 (Figur 4) med helt antal sampel */ ett 10 15 20 25 30 35 [(11 - ¿-.@.. Hwz, _ R _ .¿ . . . . w: 600 -K == * '> n . 23 /* skalär kvantisering av tillstànd */ StateSearchw(&residual[start_pos], &syntdenum[(start-1)*(FILTERORDER+1)], &weightnum[(start-1)*(FILTERORDER+1)], &weightdenum[(start-1)*(FILTERORDER+1)], &idxForMax, idxvec, sTATE_sHoRT_LEN); /* Denna funktion koder starttillstàndet (specificerat tidigare i denna beskrivning */ StateConstructW(idxForMax, idxvec, &syntdenum[(start-1)*(FILTERORDER+l)], &decresidual[start_pos], STATE_SHORT_LEN); /* Denna funktion avkodar starttillstàndet */ /* I detta skede innehåller decresidual den signal vilken signal 715 i figur 7 är ett exempel på */ /* prediktiv kvantisering i tillstånd */ if (state_first) { /* lägg adaptiv del i slutet */ /* Minnesinställning */ memset(mem, 0, (MEML-STATE_SHORT_LEN)*sizeof(float)); memcpy(mem+MEML-STATE_SHORT_LEN, decresidual+start_pos, STATE_SHORT_LEN*sizeof(float)); memset(weightState, 0, FILTERORDER*sizeof(float)); /* Koda delramar */ iCBSearch(extra_cb_index, extra_gain_index, àresidual[start_pos+STATE_SHORT_LEN], mem+MEML-stMemL, stMemL, diff, NSTAGES, &syntdenum[(start-1)*(FILTERORDER+1)], &weightnum[(start-1)*(FILTERORDER+l)], &weightdenum[(start-1)*(FILTERORDER+1)], weightstate ); /* Denna funktion utför en viktad flerstegssökning av form och förstärkningsindex */ /* skapa avkodningsvektor */ iCBConstruct(&decresidual[start_pos+STATE_SHORT_LEN], extra_cb_index, extra_gain_index,mem+MEML-stMemL, ....-.. 1.0 1.5 2() 255 3C 35 521 600 ?fffiå:¿ïWë§ 24 StMemL, diff, NSTAGES); /* Denna funktion avkodar flerstegskodningen */ else {/* lägg adaptiv del i början */ /* skapa reverserade vektorer för prediktering */ for(k=0; k reverseResidual[k] = residua1[(start+1)*SUBL -1- (k+sTATE_sHoRT_LEN)}; reverseDecresidual[k] = decresidual[(start+l)*SUBL -l- (k+sTATE_sHoRT_LEN)]; /* minnesinställning */ meml_gotten = STATE_SHORT_LEN; for( k=O; k decresidua1[start_pos + k]; } memset(mem, 0, (MEML-k)*sizeof(float)); memset(weightState, 0, FILTERORDER*sizeof(float)); /* Koda delramar */ iCBSearch(extra_cb_index, extra_gain_index, reverseResidual, mem+MEML-stMemL, stMemL, diff, NSTAGES, &syntdenum[(start-1)*(FILTERORDER+1)], &weightnufi[(Start-1)*(FILTERORDER+l)], &weightdenum[(start-1)*(FILTERORDER+l)], weightState ); /* skapa avkodningsvektor */ iCBConstruct(reverseDecresidual, extra_cb_index, extra_gain_index, mem+MEML-stMemL, stMemL, diff, NSTAGES); /* hämta avkodad residual från reverserad vektor */ for( k=0; k decresidual[start_pos-1-k] = reverseDecresidual[k]; »~ø».~ lO l5 20 25 30 521 ßgg sz 25 /* I detta skede innehåller decresidual den signal vilken signal 725 i Figur 7 är ett exempel pà */ /* räknare för predikterade delramar */ subcount=0; /* framåtprediktering av delramar */ Nfor = NSUB-start-1; if( Nfor > 0 ){ /* minnesinstâllning */ memset(mem, 0, (MEML-STATE_LEN)*sizeof(float)); memCpy(mem+MEML-STATE_LEN, decresidual+(start-1)*SUBL, STATE_LEN*sizeof(float)); memset(weightStace, 0, FILTERORDBR*sizeof(float)); /* Slinga över delramar att koda */ for (subframe=0; subframe /* Koda delramar */ iCBSearch(cb_index+subcount*NSTAGES, gain_index+subcount*NSTAGES, &residual[(start+l+subframe)*SUBL], mem+MEML-memLf[subcount], memLf[subcount], SUBL, NSTÅGES, &syntdenum[(start+l+subframe)*(FILTERORDER+1)], &weightnum[(start+l+subframe)*(FILTERORDER+l)], &weightdenum[(start+l+subframe)*(FILTERORDER+1)], weightState); /* skapa avkodningsvekcor */ iCBConstruct(&decresidual[(start+1+subframe)*SUBL], cb_index+subcount*NSTAGES, gain_index+subcount*NSTAGES, mem+MEML-memLf[subcount}, memLf[subcount], SUBL, NSTAGES); H.-». 10 15 20 25 30 35 (TI :O ...i (§\ CT: 26 /* Uppdatera minne */ memcpy(mem, mem+SUBL, (MEML-SUEL)*sizeof(float)); memcpy(mem+MEML-SUBL, &decresidual[(start+1+subframe)*SUBL], SUBL*sizeof(float)); memset(weightState, O, FILTERORDER*sizeof(float)); subcount++; /* I detta skede innehåller decresidual den signal vilken signal 735 i Figur 7 är ett exempel på */ /* bakàtprediktering av delramar */ Nback = start-1; if( Nback > 0 ){ /* Skapa vektorer med reverserad ordning */ for( n=0; n for( k=0; k reversekesidual[n*SUBL+k] = residual[(start-1)*SUBL-l-n*SUBL-k]; reverseDecresidual[n*SUBL+k] = decresidual[(start-1)*SUBL-1-n*SUBL-k]; /* minnesinstâllning */ meml_gotten = SUBL*(NSUB+1-start); if( meml_gotten > MEML ){ meml_gotten=MEML; } for( k=0; k decresidual[(start-l)*SUBL + k]; } memset(mem, 0, (MEML-k)*sizeof(f1oat)); memset(weightState, 0, FILTERORDER*sizeof(float)); /* Slinga över delramar att koda */ for (subframe=0; subframe /* Koda delram */ lO 15 20 25 30 35 521 eøo N?üfï1ï;;;eïf;g 27 iCBSearch(cb_index+subcount*NSTAGES, gain_index+subcount*NSTAGES, &reverseResidual[subframe*SUBL], mem+MEML-memLf[subcount], memLf[subcount], SUBL, NSTAGES, &syntdenum[(start-1-subframe)*(FILTERORDER+l)], &weightnum[(start-1-subframe)*(FILTERORDER+1)], &weightdenum[(start-1-subframe)*(FILTERORDER+l)1, weightState); /* skapa avkodningsvektor */ iCBConstruct(&reverseDecresidual[subframe*SUBL], cb_index+subcount*NSTAGES, gain_index+subcount*NSTAGES, mem+MEML-memLf[subcount], memLf[subcount], SUBL, NSTAGES); /* Uppdatera minne */ memcpy(mem, mem+SUBL, {MEML-SUBL)*sizeof(float)); memcpy(mem+MEML-SUBL, &reverseDecresidual[subframe*SUBL], SUBL*sizeof(float)); memset(weightState, 0, FILTERORDER*sizeof(float)); subcount++; /* hämta avkodad residual från reverserad vektor */ for (i = O; i < SUBL*Nback; i++) decresidual[SUBL*Nback - i - 1] = reverseDecresidual[i]; } /* I detta skede innehåller decresidual den signal vilken signal 745 i Figur 7 är ett exempel på */ paketering av information i bytes 10 15 20 25 30 (JU UI .Q 4... 5121 600 28 Sökning i viktad adaptiv kodbok I de beskrivna framàt- och bakåtkodningsprocedurerna kan sökningen i den adaptiva kodboken göras i en oviktad residualdomän, alternativt kan en tradionell viktning som utnyttjar analys genom syntes utnyttjas. Vi beskriver här i detalj ett tredje förfaringssätt tillämpligt pà adap- tiva kodböcker. Detta förfaringssätt ger ett alternativ till analys genom syntes och ger en bra kompromiss mellan prestanda och beräkningskomplexitet. Förfaringssättet består av en förviktning av det adaptiva kodboksminnet och màlsignalen innan den adaptiva kodboken skapas och med efterföljande sökning efter det bästa kodboksindexet.

Fördelen med detta förfaringssätt, i jämförelse med analys genom syntes, är att viktningsfiltreringen av kod- boksminnet leder till färre beräkningar än vad som krävs vid nolltillstàndsfilterrekursion vid kodning som ut- nyttjar analys genom syntes för adaptiva kodböcker. Nack- delen med detta förfaringssätt är att de viktade kodboks- vektorerna kommer att ha en nollingàngskomponent som resulterar från tidigare sampel i kodboksminnet och inte fràn tidigare sampel hos den avkodade signalen sàsom i analys genom syntes. Denna negativa effekt kan mildras genom konstruktion av viktningsfiltret så att detta har làg energi för nollingàngskomponenten relativt noll- tillstândskomponenten över en kodboksvektors längd.

Fördelaktiga parametrar för ett viktningsfilter av formeln A(z/Ll)/(Aq(z)*A(z/L2)), är att sätta Ll=1,0 och L2=o,4.

En realisering av detta tredje förfaringssätt visas schematiskt i Fig. 8. kodboksminnet 815 och det kvanticerade målet 816 i tiden 820 för att resultera i en buffert 825. Denna buffert Först konkatineras det adaptiva viktningsfiltreras 830 sedan med utnyttjande av de viktade LPC-koefficienterna 836. Den viktade bufferten 835 separeras 840 sedan i tidssampel som motsvarar minnet och de som motsvarar målet. Det viktade minnet 845 används sedan för att bygga upp den adaptiva kodboken 10 15 20 25 30 35 få Ei 1 (5 Kg C) Å: Éjšgë E ;qš..!:-j-x ~:! 29 850. Såsom är väl känt för fackmannen inom området behöver den adaptiva kodboken 855 inte àtskiljas vad gäller fysisk minnesplacering från det viktade minnet 845 eftersom tidskiftade kodboksvektorer kan adresseras pà samma sätt som tidskiftade sampel i minnesbufferten.

Nedan följer ett exempel i c-kod pà implementering av detta tredje förfaringssätt för sökning i en viktad kodbok. void iCBSearch( /* sökning i adaptiv kodbok */ int *index, /* (o) vektorindex. Detta är signal 865 i Fig. 8 */ int *gain_index, /* (0) vektorförstärkningsindex.

Detta är signal 866 i Fig. 8 */ float *target, /* (i) kvantiseringsmàl.

Detta är signal 816 i Fig. B */ float *mem, /* (i) minne för adaptiv kodbok.

Detta är signal B15 i Fig. 8 */ int lMem, /* (i) minneslângd */ int lTarget, /* (i) màlvektorns längd */ int nstages, /* (i) antal kvantiseringssteg */ float *weightDenum, /* (i) nedräkningskoefficienter för viktningsfilter Detta är signal 836 i Fig. 8 */ float *weightstate /* (i) viktningsfiltrets tillstànd för målfiltreringen. Detta är tillstànd för filtreringen 830 i Fig. 8 */ int i, j, icount, stage, best_index; float max_measure, gain, measure, crossDot, invDot; float gains[NSTAGES]; float Cb[(MEML+SUBL+l)*CBEXPAND*SUBL]I int base_index, sInd, eInd, base_size; /* för viktningen */ fløat buf[MEML+SUBL+2*FILTERORDER]; base_size=lMem-lTarget+l; 10 15 20 25 30 if 521 aan Sf¿f:¿l:ß 30 (lTarget==SUBL) base_size=lMem-lTarget+1+lTarget/2; memcpy(buf,weightState,sizeof(float)*FILTERORDER); memcpy(&buf[FILTERORDER],mem,lMem*sizeof(float)); memcpy(&buf[FILTERORDER+lMem],target,lTarget*sizeof(float)); /* At this point buf is the signal 825 on Fig. 8 */ AllPoleFilter(&buf[FILTERORDER], weightDenum, lMem+lTarget, FILTERORDER); /* Denna funktion utför en filtrering av alla poler i buf. Resultatet returneras i buf. Detta är funktion 830 i Pig. 8 */ /* I detta skede är buf signalen 835 i Fig. 8 */ /* Skapa det CB och màl som behövs */ createCB(&buf[FILTERORDER], cb, lMem, lTarget); memcpy(target,&buf[FILTERORDER+lMem], lTarget*sizeof(float)); /* I detta skede är målet signalen 846 i Fig. 8 och cb är signalen 855 i Fig. 8 */ /* Huvudslinga över steg */ /* Detta slinga utför funktionen 860 i Fig. 8 */ for (stage=O;stage max_measure = (float)-10000000 O; best_index = 0; for (icount = 0; icount crossDot=0.0; invDot=0.0; for (j=0;j crossDot += target[j]*cb[icount*lTarget+j]; invDot += cb[icount*lTarget+j]*cb[icount*lTarget+j]; } invDot = (float)1.0/(invDot+EPS); if (stage==0) { measure=(float)-lOO00000.0; if (crossDot > 0.0) measure = crossDot*crossDot*invDot; else { 10 15 20 25 30 b.) UI S1 fx:- _; Cm CZ CLJ 31 measure = crossDot*crossDot*invDot; if(measure>max_measure){ best_index = icount; max_measure = measure; gain = crossDot*invDot; } base_index=best_index; if (RESRANGE == -1) { /* sökning utan restriktion */ SInd=0; eInd=base_size-1; else { slnd=base_index-RESRANGE/2; if (sïnd < 0) sInd=0; eInd = sInd+RESRANGE; if (eInd>=base_size) { eInd=base_size-1; sInd=eInd-RESRANGE; } for (i=1,- RCBEXPAND; i++) { sInd += base_size; eInd += base_size; for (icount=sInd; icount<=eInd; icount++) { crossDot=0.0; inVDOt=0.0; for (j=0;j<1Target;j++) { crossDot += target[j]*cb[icount*lTarget+j]; invDot += cb[icount*lTarget+j]*cb[icount*lTarget+j]; } invDot = (float)1.0/(invDot+EPS); if (stage==O) { measure=(float)-lO0000O0.0; 10 15 20 25 30 35 5121 600 32 if (crossDot > 0.0) meaSLlre = CIO$SDOt*CI'O5SDOt*iI1VDOt; else { measure = crossDot*crossDot*invDot; if(measure>max_measure){ best_index = icount; max_measure = measure; gain = crossDot*invDot; } indexlstage] = best_index; /* index är signal B65 i Pig. 8 */ /* förstårkningskvantisering */ if(stage==0){ if (gaín<0.0) gain = 0.0; if (gain>1.0) gain = 1.0; gain = gainquant(gain, 1.0, 16, &gain_index[stage]); /* Denna funktion söker efter bästa index för förstärkningskvantiseringarna */ /* gain_index är signal 866 i Fig. 8 */ else { if(fabs(gain) > fabs(gains[stage-1])){ gain = gain * (float)fabs( gains[stage-1])/(float)fabs(gain); gain = gainquant(gain, (float)fabs(gains[stage-1]), 8, &gain_index[stage]); /* Denna funktion söker efter bästa index för förstärkningskvantiseringarna */ /* gain_index år signal 866 i Pig. 8 */ n... lO 15 20 25 30 35 33 /* Uppdatera mål */ for(j=0;j gains[stage]=gain; }/* slut på huvudslinga. för (stage=0;... */ Avkodare Avkodaren som täcks av föreliggande uppfinning är vilken avkodare som helst som samverkar med en kodare av det slag som tidigare beskrivits. En sådan avkodare kommer att från kodad data extrahera en plats för starttillstàndet. Den kommer att avkoda starttillstàndet och använda detta som en initialisering av ett minne för avkodning av den resterande signalramen. Om ett datapaket inte mottages kan ett döljande av paketförlust vara fördelaktigt.

Nedan följer ett exempel i c-kod pà implementering av en avkodare. void iLBC_decode( /* avkodningsfunktion */ float *decblock, /* (o) avkodat signalblock */ unsigned char *bytes, /* (i) kodade signalbitar */ int bytes_are_good /* (i) 1 om bytes är bra data 0 annars */ float reversebecresidual[BLOCKL], mem[MEML]; int n, k, meml_gotten, Nfor, Nback, i; int diff, start_pos; int subcount, subframe; float factor; float std_decresidual, one_minus_factor_scaled; int gaussstart; diff = STATE_LEN - STATE_SHORT_LEN; if(state_first == ) start_pos = (start-1)*SUBL; -»-»-. 10 15 20 25 30 bJ UH 34 else start_pos = (start-l)*SUBL + diff; StateConstructW(idxForMax, idxvec, &syntdenum[(start-1)*(FILTERORDER+l)], &decresidua1[start_pos}, STATE_SHORT_LEN); /* Denna funktion avkodar starttillstàndet */ if (state_first) ( /* Lägg adaptiv del i slutet */ /* minnesinställning */ memset(mem, 0, (MEML-STATE_SHORT_LEN)*sizeof(float)); memcpy(mem+MEML-STATE_SHORT_LEN, decresidual+start_pos, STATE_SHORT_LEN*sizeof(float)); /* skapa avkodningsvektor */ iCBConstruct(&decresidual[start_pos+STATE_SHORT_LEN], extra_cb_index, extra_gain_index, mem+MEML-stMemL, stMemL, diff, NSTAGES); /* Denna funktion avkodar en residualram */ } else {/* Lägg adaptiv del i början */ /* skapa reverserade vektorer för prediktering */ for(k=0; k reverseDecresidual[k] = decresidual[(start+l)*SUBL -1- (k+STATE_SHORT_LEN)]; /* minnesinställning */ mem1_gotten = STATE_SHORT_LEN; for( k=O; k memset(mem, 0, (MEML-k)*sizeof(float)); /* skapa avkodningsvektor */ iCBConstruct(reverseDecresidual, extra_cb_index, extra_gain_index, mem+MEML-stMemL, scMemL, diff, NSTAGES); k]; } 10 15 20 25 30 35 521 emo g fiï“àä«7ä° 35 /* hämta avkodad residual från reverserad vektor */ for( k=0; k decresidual[start_pos-1-k] = reverseDecresidual[k]; /* räknare för predíkterade delramar */ subcount=0; /* framåtprediktering av delramar */ Nfor = NSUB-start-1; if( Nfor > 0 ){ /* minnesinställning */ memset(mem, 0, (MEML-STATE_LEN)*sizeof(float)); memcpy(mem+MEML-STATE_LEN, decresidual+(start-1)*SUBL, STATE_LEN*sizeof(float)); /* slinga över delramar att koda */ for (subframe=0; subframe /* skapa avkodningsvektor */ iCBConstruct(&decresidual[(start+l+subframe)*SUBL], cb_index+subcount*NSTAGES, gain_index+subcount*NSTAGES, mem+MEML-memLf[subcount], memLf[subcount], SUBL, NSTAGES); /* Uppdatera minne */ memcpy(mem, mem+SUBL, (MEML-SUBL)*sizeof(f1oat)); memcpy(mem+MEML-SUBL, &decresidual[(start+l+subframe)*SUBL], SUBL*sizeof(float)); subcount++; /* bakàtprediktering av delramar */ Nback = scart-1; -au». 10 15 20 25 30 521 600 §ff;aïr1,§ 36 if< Nback > o ){ /* skapa vektorer med reverserad ordning */ for( n=0; n fOI( k=O; k reverseDecresidual[n*SUBL+k] = decresidual[(start- 1)*SUBL-1-n*SUBL-k]; /* minnesinstâllning */ meml_gotten = SUBL*(NSUB+l-start); if( meml_gotten > MEML ){ meml_gotten=MEML; } for( k=0; k l)*SUBL + k]; } memset(mem, 0, (MEML-k)*sizeof(float)); /* Slinga över delramar att avkoda */ for (subframe=0; subframe /* Skapa avkodningsvektor */ iCBConstruct(&reverseDecresidua1[subframe*SUBL], cb_index+subcount*NSTAGES, gain_index+subcount*NSTAGES mem+MEML-memLf[subcount], memLf[subcount], SUBL, NSTAGES); /* Uppdatera minne */ memCPY(mem, mem+SUBL, (MEML-SUBL)*sizeof(float)); memcpy(mem+MEML-SUBL, &reverseDecresidua1[subframe*SUBL], SUBL*sizeof(f1oat)); subcount++; /* hämta avkodad residual från reverserad vektor */ for (i = 0; i < SUBL*Nback; í++) 10 15 20 25 30 35 '-1 TJ- :à- m CI) C) 37 decresidual[SUBL*Nback - i - 1] = reverseDecresidual[i]; factor=(float)(gc_index+1)/(float)16.0; for(i=0;i factor *= 1.5; if (factor < l.0){ std_decresidual = 0.0; for(i=0;i std_decresidual /= BLOCKL; std_decresidual = (float)sqrt(std_decresidua1); one_minus_factor_scaled = (float)sqrt(1-factor*factor)*std_decresidual; gaussstart = (int)cei1(decresidual[0]) % (GAUSS_NOISE_L-BLOCKL); for(i=0;i one_minus_factor_scaled*gaussnoise[gaussstart+i]; void iLBC_decode(float *decblock, unsigned char *bytes, int bytes_are_good) { static float old_syntdenum[(FILTERORDER + 1)*NSUB] = {l,0,0,0,0,0,0,0,0,0,0, l,0,0,0,0,0,0,0,0,0,0, l,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0, l,0,0,0,0,0,0,0,0,0,0, 1,o,o,o,o,o,o,o,o,o,o},- static int last_lag = 20; float data[BLOCKL]; float lsfunq[FILTERORDER*LPC_N]; float PLCreSidual[BLOCKL], PLClpC[FILTERORDER + l]; float zeros[BLOCKL], one[FILTERORDER + 1]; int k, kk, i, start, idxForMax; 10 15 20 25 30 u) UI 521 som äëfwêgïai” 38 int idxVec[STATE_LEN]; int dummy=0,check; int gain_índex[NASUB*NSTAGES], extra_gain_index[NSTAGES]; int cb_index[NSTAGES*NASUB], extra_cb_index[NSTAGES]; int 1sf_i{LsF_NsPLIT*LPc_N}; int state_first, gc_index; unsigned char *pbytes; float weightnum[(FILTERORDER + l)*NSUB],weightdenum[(FILTERORDER + 1)*NSUBI; int order_plus_one; if (bytes_are_good) { ...extrahering av parametrar från bytes SimplelsfUNQ(lsfunq, lsf_i); /* Denna funktion avkodar LPC-koefficienterna i LSF-domänen */ check=LSF_check(lsfunq, FILTERORDER, LPC_N); /* Denna funktion kontrollerar stabiliteten i LPC-filtret */ DecoderInterpolateLSF(syntdenum, lsfunq, FILTERORDER); /* Denna funktion interpolerar LPC-filtret över blocket */ Decode(decresidual, start, idxForMax, idxvec, syntdenum, cb_index, gain_index, extra_cb_index, extra_gain_index, state_first,gc_index); /* Denna funktion innefattas ovan */ /* Förbereda plczn för framtida förlust */ doThePLC(PLCresidual, PLClpc, 0, decresidual, syntdenum + (FILTERORDER + l)*(NSUB - 1), NSUB, SUBL, last_lag, start); /* Denan funktion hanterar döljning av paketförlust */ memcpy(decresidual, PLCresidual, BLOCKL*sizeof(float)); ) else { /* dölj paketförlust */ memset(zeros, 0, BLOCKL*sizeof(f1oat)); one[0] = 1; memset(one+l, 0, FILTERORDER*sizeof(float)); start=O; doThePLC(PLCresidual, PLClpc, 1, zeros, one, NSUB, SUBL, last_lag, start); lO 15 20 25 5:21 600 39 memcpy(decresidual, PLCresidual, BLOCKL*sizeof(float)); order_plus_one = FILTERORDER + 1; fOI' (i = O; i < NSUB; i++) memCPY(syntdenum+(i*order_p1us_one)+1, PLC1pc+1, FILTERORDER*sizeof(float)); efterfiltrering av den avkodade residualen for (i=0; i < NSUB; i++) syntFilter(decresidual + i*SUBL, syntdenum + i*(FILTERORDER+1), SUBL); /* Denna funktion utför en syntesfiltrering av den avkodade residualen */ memcpy(decblock,decresidual,BLOCKL*sizeof(float)); memcpy(old_syntdenum, syntdenum, NSUB*(FILTERORDER+1)*sizeof(float)) f

Claims (34)

10 15 20 25 30 . « V . v , 600 40 PATENTKRAV

1. l. Förfarande för kodning av en signal som är upp- delad i konsekutiva block, varvid förfarandet innefattar följande steg applicerade pà ett block: att koda en första del av blocket, vilken första del är placerad någonstans mellan de tvà ändgränserna för blocket, varigenom ett kodat starttillstánd för blocket erhålls; att koda en andra del av blocket med utnyttjande av ett prediktivt kodningsförfarande som baseras pà nämnda kodade starttillstánd och som gradvis kodar nämnda andra del i riktning mot en av nämnda tvà ändgränser; och att fastställa om det finns några signalsampel placerade mellan nämnda starttillstánd och den andra av att koda en tredje del av blocket innefattande dessa sampel med nämnda tvä ändgränser, och om så är fallet, utnyttjande av ett prediktivt kodningsförfarande som är baserat pà nämnda kodade starttillstánd och som gradvis kodar nämnda tredje del i riktning mot nämnda andra gräns av nämnda tvà ändgränser, varigenom nämnda tredje del, med hänsyn till en tidbas associerad med blocket, kodas i en motsatt riktning i jämförelse med kodningen av nämnda andra del.

2. Förfarandet enligt krav 1, varvid kodningen av nämnda tredje del baseras pà, förutom nämnda kodade starttillstánd, åtminstone en del av den kodade andra delen av blocket.

3. Förfarandet enligt krav 1 eller 2, varvid nämnda andra del kodas i en riktning längs nämnda tidbas mot den av nämnda tvá ändgränser som är placerad i slutet av blocket.

4. Förfarandet enligt krav l eller 2, varvid nämnda andra del kodas i en riktning som är motsatt till nämnda lO 15 20 25 30 35 . -;=. 600 41 tidbas och mot den av nämnda två ändgränser som är placerad i början av blocket.

5. Förfarandet enligt något av kraven 1-4, varvid kodningen av starttillstàndet är baserat på något kod- ningsförfarande i vilket kodningen är oberoende av, eller görs oberoende av, någon tidigare kodad del av signalen.

6. Förfarandet enligt något av kraven l-5, varvid den prediktiva kodningen av nämnda andra och tredje delar innefattar ett ytterligare steg med syntesfiltrering från exciteringsdomänen till domänen med den kodade signalen.

7. Förfarandet enligt något av kraven 1-5, varvid nämnda signal är en residualsignal av en analysfiltrerad digital signal.

8. Förfarandet enligt krav 7, varvid kodningen av starttillstàndet är baserat på prediktiv kodning med brusformning, vilken prediktiva kodning görs oberoende av någon kodad del av residualsignalen som föregår residual- signaldelen som motsvarar nämnda första del av blocket.

9. Förfarandet enligt något av kraven l-8, varvid starttillstàndet allpassfiltreras innan kodning för att distribuera energin mer jämnt bland starttillståndets sampel.

10. Förfarandet enligt något av kraven l-9, varvid förfarandet använder rekursiv kodning genom att koda ett delblock bestående av nämnda första del av blocket på ett sådant sätt att samma steg som appliceras på blocket också appliceras på delblocket.

11. ll. fattande att dela upp blocket i en uppsättning av kon- Förfarandet enligt något av kraven l-10, inne- sekutiva intervall, varvid kodningen av nämnda första del 10 15 20 25 30 35 th \J _) G\ CD CD 42 av blocket innefattar kodning av en eller flera konseku- tiva intervall mellan de tvà ändgränserna, för att erhålla nämnda kodade starttillstànd.

12. Förfarandet enligt krav 11, varvid nämnda ett eller flera konsekutiva intervall väljs bland de inter- vall som har den högsta signalenergin.

13. Förfarandet enligt något av kraven 1-12, varvid kodningen av den andra och tredje delen baseras pà något av följande kodningsförfaranden: LPC-kodning (Linear Prediction Coding); CELP-kodning (Code Excited Linear Prediction); CELP-kodning med en eller flera adaptiva kodbokssteg; SELP-kodning Prediction); eller MP-LPC-kodning (Self Excited Linear (Multi-Pulse Linear Prediction Coding).

14. Förfarandet enligt något av kraven 1-13, varvid kodningen av den andra och tredje delen baseras på för- viktning av ett adaptivt kodboksminne och av màlsignalen innan den adaptiva kodboken byggs upp.

15. Förfarandet enligt nàgot av kraven 1-14, varvid nämnda signal är en talsignal.

16. Förfarandet enligt något av kraven 1-14, varvid nämnda signal är en audiosignal.

17. Anordning för prediktiv kodning av en signal som är uppdelad i konsekutiva block, varvid anordningen inne- fattar organ för att utföra stegen enligt förfarandet i nàgot av kraven 1-16 pà vart och ett av nämnda block.

18. Ett datorläsbart medium som lagrar komponenter exekverbara av en dator för prediktiv kodning av en signal som är uppdelad i konsekutiva block, varvid de av datorn exekverbara komponenterna utför stegen för för- 10 15 20 25 30 35 » u » | , | » | « . 1. 43 farandet enligt något av kraven 1-16 pà vart och ett av nämnda block.

19. Förfarande för avkodning av en kodad signal, vilken signal i kodningsänden delades upp i konsekutiva block innan kodning av varje block, varvid förfarandet innefattar följande steg applicerade pà ett kodat block för reproducering av ett motsvarande avkodat block: att avkoda ett kodat starttillstànd för reproduce- ring av ett starttillstànd placerat någonstans mellan de tvà ändgränserna för blocket som skall reproduceras; att avkoda en kodad andra del av blocket med ut- nyttjande av ett prediktivt avkodningsförfarande baserat pà nämnda starttillstànd för gradvis reproducering av nämnda andra del i riktning mot en av nämnda tvà änd- gränser; och att fastställa om det kodade blocket innefattar en kodad tredje del, kodade tredje delen hos blocket med utnyttjande av ett och om så är fallet, att avkoda den prediktivt avkodningsförfarande baserat pà nämnda starttillstànd för gradvis reproducering av nämnda tredje del i riktning mot den andra av nämnda tvà ändgränser, varigenom nämnda tredjedel, med hänsyn till en tidbas associerad med blocket, reproduceras i en motsatt rikt- ning i jämförelse med reproduktionen av nämnda andra del.

20. Förfarandet enligt krav 19, varvid avkodningen av nämnda tredjedel baseras pà, utöver nämnda starttill- stànd, åtminstone en del av den avkodade andra delen av blocket.

21. Förfarandet enligt krav 19 eller 20, varvid nämnda andra del reproduceras i en riktning längs nämnda tidbas mot den av nämnda två ändgränser som är placerad i slutet av blocket. » , \ . 'y lO 15 20 25 30 35 521 609 44

22. Förfarandet enligt krav 19 eller 20, varvid nämnda andra del reproduceras i en riktning som är mot- satt mot nämnda tidbas och mot den av nämnda två änd- gränser som är placerad i början av blocket.

23. Förfarandet enligt något av kraven 19-22, varvid avkodningen av starttillstàndet baseras på något avkod- ningsförfarande som reproducerar starttillstàndet oberoende av någon tidigare reproducerad del av signalen.

24. Förfarandet enligt något av kraven 19-23, varvid avkodningen av nämnda andra och tredje delar innefattar ett ytterligare steg med syntesfiltrering från excite- ringsdomänen till domänen för den avkodade signalen, vilken syntesfiltrering av de andra och tredje delarna utförs i samma ordning som reproduktionen av de andra och tredje delarna av blocket.

25. Förfarandet enligt något av kraven 19-23, varvid nämnda signal är en residualsignal av en analysfiltrerad digital signal.

26. Förfarandet enligt något av kraven 19-25, varvid avkodningen av nämnda första, andra och tredje delar följs av ett ytterligare steg med syntesfiltrering från exciteringsdomänen till domänen för den avkodade signalen, varvid syntesfiltreringen för blocket utförs i sekventiell ordning från den av nämnda två ändgränser som uppträder först i tiden till den andra gränsen som upp- träder senare i tiden.

27. Förfarandet enligt krav 25 eller 26, varvid avkodningen av den första delen baseras på prediktiv avkodning med brusformning, vilken avkodning reproducerar starttillstàndet oberoende av någon tidigare reproducerad del av residualsignalen som föregår den del av residual- signalen som motsvarar nämnda starttillstånd. 10 15 20 25 30 35 . , , . ., 5221 600 45

28. Förfarandet enligt något av kraven 19-27, varvid starttillståndet allpassfiltreras efter nämnda avkodning av nämnda första del för att ytterligre koncentrera energin.

29. Förfarandet enligt något av kraven 19-28, varvid förfarandet utnyttjar rekursiv avkodning genom avkodning av ett delblock bestående av nämnda kodade starttillstånd pà sådant sätt att samma steg som appliceras på blocket också appliceras pà delblocket.

30. Förfarandet enligt något av kraven 19-29, varvid avkodningen av den andra och tredje delen baseras på något av följande avkodningsförfaranden:LPC-kodning (Linear Prediction Coding); CELP-kodning (Code Excited Linear Prediction; CELP-kodning med en eller flera adaptiva kodböcker; SELP-kodning (Self Excited Linear Prediction) eller MP-LPC-kodning ( Multi-Pulse Linear Prediction Coding.

31. Förfarandet enligt något av kraven 19-30, varvid nämnda signal är en talsignal.

32. Förfarandet enligt något av kraven 19-30, varvid nämnda signal är en audiosignal.

33. Anordning för prediktiv avkodning av en kodad signal, vilken signal i kodningsänden har delats upp i konsekutiva block innan kodning av varje block, varvid anordningen innefattar organ för utförande av stegen i förfarandet enligt något av kraven 19-32 på varje kodat block för reproducering av ett motsvarande avkodat block.

34. Datorläsbart medium som lagrar komponenter exekverbara av en dator för prediktiv avkodning av en kodad signal, vilken signal vid kodningsänden har delats 5:21 em g 46 upp i konsekutiva block innan kodning av varje block, varvid de av datorn exekverbara komponenterna utför stegen i förfarandet enligt något av kraven 19-32 pà varje kodat block för reproducering av ett motsvarande avkodat block.