EP2176861B1

EP2176861B1 - Codage hierarchique de signaux audionumeriques

Info

Publication number: EP2176861B1
Application number: EP08806166A
Authority: EP
Inventors: Balazs Kovesi; Stéphane RAGOT
Original assignee: France Telecom SA
Current assignee: Orange SA
Priority date: 2007-07-06
Filing date: 2008-07-04
Publication date: 2013-03-27
Anticipated expiration: 2028-07-04
Also published as: KR20100049579A; CN101796579A; US8577687B2; WO2009010674A1; KR101476699B1; CN101796579B; EP2176861A1; JP2010532876A; US20100191538A1; JP5264901B2; ES2416056T3

Description

La présente invention concerne un procédé de codage hiérarchique de données sonores plus particulièrement pour un codage par quantification scalaire.
Ce codage est adapté notamment pour la transmission et/ou au stockage de signaux numériques tels que des signaux audiofréquences (parole, musique ou autres).
La présente invention se rapporte plus particulièrement au codage de formes d'onde tel que le codage MIC (pour "Modulation par Impulsions Codées") dit PCM (pour "Pulse Code Modulation") en anglais où chaque échantillon d'entrée est codé individuellement, sans prédiction.
Le principe général du codage/décodage MIC spécifié par la recommandation UIT-T G.711 1 est tel que décrit en référence à la figure 1. Le signal d'entrée est supposé défini avec une largeur de bande minimale de [300-3400 Hz] et échantillonné à 8 kHz, avec une résolution de 16 bits par échantillon (en format dit "MIC linéaire").
Le codeur MIC 13 comporte un module de quantification Q_MIC 10 qui reçoit en entrée le signal d'entrée S. L'indice de quantification I_MIC en sortie du module de quantification 10 est transmis via le canal de transmission 11 au décodeur 14.
Le décodeur MIC 14 reçoit en entrée les indices I'_MIC issu du canal de transmission, version éventuellement perturbée par des erreurs binaires de I_MIC, et réalise une quantification inverse par le module de quantification inverse Q^-1 _MIC 12 pour obtenir le signal codé S'_Mic.
Le codage MIC normalisé UIT-T G.711 (ci-après nommé G.711) réalise une compression de l'amplitude des signaux par une courbe logarithmique avant quantification scalaire uniforme, ce qui permet d'obtenir un rapport signal à bruit à peu près constant pour une large dynamique de signaux. Le pas de quantification dans le domaine du signal original est donc proportionnel à l'amplitude des signaux.
Les échantillons successifs du signal compressé sont quantifiés sur 8 bits, soit 256 niveaux. Dans le réseau téléphonique commuté (RTC) dit Public Switched Telephone Network (PSTN) en anglais, ces 8 bits sont transmis à une fréquence de 8 kHz pour donner un débit de 64 kbits/s.
Une trame de signal quantifié selon la norme G.711 est constituée d'indices de quantification codés sur 8 bits. Ainsi, si la quantification inverse est implantée par table, elle consiste simplement à un pointage par l'indice de l'une des 256 valeurs décodées possibles.
Pour des raisons de complexité de mise en oeuvre, la compression MIC a été approximée par une courbe linéaire par segments.
Deux lois de codages sont définies dans la norme G.711, la loi A utilisée principalement en Europe et la loi mu (µ) utilisée en Amérique du Nord et au Japon.
Ces lois de codage permettent d'effectuer sur le signal une compression de l'amplitude (ou encore "companding" en anglais). L'amplitude du signal est ainsi "compressée" par une fonction non-linéaire au niveau du codeur, envoyée sur un canal de transmission et "décompressée" par la fonction inverse au niveau du décodeur. L'intérêt de la compression d'amplitude est qu'elle permet de transformer la distribution de probabilité de l'amplitude du signal audio d'entrée en une loi de probabilité quasi-uniforme, sur laquelle on peut appliquer une quantification scalaire uniforme.
Les lois de compression d'amplitude sont en général des lois de type logarithmique qui permettent donc de coder un signal échantillonné avec une résolution de 16 bits (en format "PCM linéaire") sur 8 bits (en format "PCM" de type loi A ou mu).
Les 8 bits par échantillon dans G.711 sont répartis de la façon suivante telle que représenté en 15 à la figure 1:

1 bit de signe S (0 pour une valeur négative, 1 sinon), portant la référence sgn sur la figure 1,
3 bits pour indiquer le segment (référence ID-SEG sur la figure 1), l'extrémité de chaque segment étant donnée par 256*2n pour la loi A et 256*2n-132 pour la loi mu où n = 0,1,...,7. Le pas de quantification est donc multiplié par 2 quand on passe sur le segment supérieur (à partir du 2ème segment pour la loi A).
4 bits pour indiquer l'emplacement sur le segment, portant la référence ID-POS sur la figure 1.

Les derniers 7 bits constituent donc la valeur absolue codée. Dans la suite nous étudierons d'abord le cas de loi A, puis nous généralisons les résultats pour la loi mu. Selon la norme G.711 loi A, l'indice final est obtenu en inversant chaque deuxième bit à partir de bit de poids le plus faible (Least Significant Bit LSB en anglais). Cette loi de codage permet d'avoir une précision de quantification scalaire de 12 bits (donc un pas de quantification de 16) quand on est sur les deux premiers segments, puis la précision diminue de 1 bit quand le numéro de segment augmente de 1.

On peut noter qu'il est possible de réaliser la quantification MIC G.711 à partir d'un signal numérique représenté sur 16 bits en effectuant de simples comparaisons entre l'amplitude de l'échantillon à coder et les seuils de décision du quantificateur. L'utilisation d'une dichotomie accélère de façon significative ces comparaisons. Cette solution nécessite le stockage d'un tableau de 256 entrées, le Tableau 1 ci-après donne un extrait d'un tel tableau pour la loi A G.711.

Tableau 1 Seuils pour la recherche par dichotomie

N° de l'intervalle	Seuil inférieur	Seuil supérieur	Signe	Valeur absolue codé	Indice final	Valeur quantifiée
0	-32768	-31745	0	127	0x2a	-32256
1	-31744	-30721	0	126	0x2b	-31232
...	...	...			...	...
122	-96	-81	0	5	0x50	-88
123	-80	-65	0	4	0x51	-72
124	-64	-49	0	3	0x56	-56
125	-48	-33	0	2	0x57	-40
126	-32	-17	0	1	0x54	-24
127	-16	-1	0	0	0x55	-8
128	0	15	1	0	0xd5	8
129	16	31	1	1	0xd4	24
130	32	47	1	2	0xd7	40
131	48	63	1	3	0xd6	56
132	64	79	1	4	0xd1	72
133	80	95	1	5	0xd0	88
...	...	...			...	...
254	30720	31743	1	126	0xab	31232
255	31744	32767	1	127	0xaa	32256

Par exemple, un échantillon d'origine du signal S à coder a une amplitude égale à -75. Par conséquent, cette amplitude est comprise dans l'intervalle [-80, -65] de la ligne 123 (ou « niveau » 123) du tableau. Le codage de cette information consiste à délivrer un indice final codé, référencé I'_Mic sur la figure 1 et sur le tableau 1, qui est égal à 0x51. Au décodage, l'opération de quantification inverse consiste donc à récupérer l'indice I'_Mic = 0x51 et à lui faire correspondre une valeur quantifiée VQ, telle que VQ = -72. Par conséquent, le décodage affecte à l'amplitude de l'échantillon correspondant, du signal décodé S'_Mic , cette valeur -72. On relèvera que l'on affecterait cette même valeur VQ = -72 à tous les échantillons à décoder et dont l'amplitude initiale avait une valeur dans l'intervalle [-80, -65], soit en tout 16 valeurs possibles dans l'intervalle, ce qui correspond au pas de quantification ici de 16. En revanche, on relèvera que l'on affecterait la même valeur VQ = 32256 à tous les échantillons dont l'amplitude initiale était dans l'intervalle [31744, 32767], soit en tout 1024 valeurs possibles, ce qui correspond à un pas de quantification de 1024.
Le rapport signal à bruit (RSB) obtenu par le codage MIC est à peu près constant (~38 dB) pour une large dynamique de signaux. Le pas de quantification dans le domaine du signal original est proportionnel à l'amplitude des signaux. Ce rapport signal à bruit n'est pas suffisant pour rendre le bruit de quantification inaudible sur toute la bande de fréquences 0-4000 Hz. De plus, pour les signaux de faibles niveaux (qui sont codés avec le premier segment) le RSB est très mauvais.
La norme G.711 est généralement considérée comme étant de bonne qualité pour les applications de téléphonie en bande étroite avec des terminaux limitant la bande à [300-3400 Hz]. Cependant, la qualité n'est pas satisfaisante quand on utilise G.711 pour d'autres applications comme par exemple pour des terminaux de bonne fidélité dans la bande [50,4000 Hz] ou pour l'extension hiérarchique en bande élargie du codage G.711.
DAVIS A G, TURNBULL R S: "A Scaleable Audio Codec", EXTERNAL RESEARCH WEB SITE OF BRITISH TELECOM, 1998, divulgue une méthode pour rendre sclable un flux de données codé par une quantification scalaire effectuée échantillon par échantillon.
Il existe en effet des méthodes de codage hiérarchique consistant à apporter une couche d'amélioration déterminée à partir du bruit de codage du codeur G.711. Ce bruit de codage est alors codé par une technique différente de G.711, lequel constitue la couche dite de base (ou couche coeur). Une telle méthode de codage hiérarchique est par exemple décrite dans le document Y. Hiwasaki, H. Ohmuro, T. Mori, S. Kurihara and A Kataoka. "A G.711 embedded wideband speech coding for VoIP conferences", IEICE Trans. Inf. & Syst, Vol. E89-D,n°9, September 2006. Ce type de méthode a l'inconvénient d'augmenter de façon très significative de la complexité au codeur alors que le codage de type MIC est réputée être de faible complexité. De plus, le bruit de codage MIC étant un bruit blanc, donc non corrélé, le codage de ce type de bruit est difficile à mettre en oeuvre puisque les techniques de compression reposent essentiellement sur des propriétés d'extraction de la corrélation du signal à coder.
La présente invention offre une solution qui améliore la situation.
A cet effet, l'invention propose un procédé de codage comme éconcé dans la revendication 1.
Ainsi, un flux d'amélioration est transmis en même temps que le la trame binaire d'indices de quantification.
Ce flux d'extension est déterminé en tirant profit des bits de poids faible qui ne sont pas utilisé lors du codage. Cette méthode a donc l'avantage de ne pas ajouter de complexité au codeur et d'apporter l'amélioration de qualité souhaitée en apportant au décodeur la possibilité d'obtenir une meilleure précision de décodage.
Dans un mode de réalisation, les bits mémorisés sont les bits de poids le plus fort parmi les bits qui ne sont pas pris en compte dans la trame binaire d'indices de quantification.
Tous les bits laissés de coté lors de l'application de la loi de codage logarithmique ne sont pas forcément repris dans le flux d'extension. Il est ainsi possible de déterminer un flux d'extension en fonction des besoins en qualité et disponibilité en termes de débit.
Dans une variante de réalisation, le nombre de bits pris en compte pour déterminer le flux d'amélioration est fonction du débit disponible au cours d'une transmission vers un décodeur.
Ainsi, le flux d'extension est modulable au cours de la transmission en fonction du débit disponible.
L'invention est particulièrement adaptée au cas où l'étape de quantification scalaire est une quantification de type MIC selon une loi de codage logarithmique de compression d'amplitude de type A ou de type mu conforme à la norme ITU-T G.711.
L'invention s'applique également à un procédé de décodage comme éconcé dans la revendication 5..
Le décodeur qui reçoit des bits d'extension, améliore ainsi la précision de son expansion ou "décompression" en concaténant les bits d'extension reçus à ceux présents dans la trame d'indices de quantification reçu du flux de base.
Dans un mode préféré de réalisation, le procédé comporte en outre une étape d'adaptation d'une valeur d'arrondi en fonction du nombre de bits d'extension reçu pour obtenir le signal audio décodé.
La détection du signal audio codé est ainsi adaptée en fonction du nombre de bits du flux d'extension.
L'invention se rapporte également à un codeur audio comme éconcé dans la revendication 7.
L'invention se rapporte à un décodeur audio comme éconcé dans la revendication 8.
L'invention vise enfin à un programme informatique comme éconcé dans la revendication 9.
De même, l'invention vise à un programme informatique comme éconcé dans la revendication 10.
D'autres caractéristiques et avantages de l'invention apparaîtront plus clairement à la lecture de la description suivante, donnée uniquement à titre d'exemple non limitatif, et faite en référence aux dessins annexés, sur lesquels:

la figure 1 illustre un système de codage/décodage MIC G.711 classique de l'état de l'art;
la figure 2 illustre un système de codage/décodage selon l'invention ainsi que les procédés selon l'invention, mis en oeuvre par les éléments de ce système;
les figures 3a et 3b représentent les valeurs quantifiées par rapport aux valeurs d'entrée après application des lois de codage respectives A et mu selon la norme G.711;
les figures 4 et 5 représentent une comparaison avec et sans mise en oeuvre de l'invention des valeurs quantifiées par rapport aux valeurs d'entrée après application des lois de codage A et mu respectivement.

La figure 2 illustre un système de codage /décodage selon l'invention.
Un codeur 23 comprend un quantificateur Q_MIC 20 apte à quantifier le signal d'entrée S pour obtenir une trame d'indices de quantification I_MIC qui est transmis sur le canal de transmission 21 vers un décodeur 24.
Dans un mode particulier de réalisation, ce codeur est du type codeur MIC et met en oeuvre une loi de codage de type A ou mu tel que décrit dans la norme G.711.
La trame d'indices de quantification obtenue est donc représentée en 15 et est conforme à la trame de type G.711 loi A ou mu.
Des méthodes d'implémentation des lois de codage A et mu sont proposées dans la norme G.711. Elles consistent à déterminer l'indice final de quantification par des opérations simples de basse complexité qui évitent le stockage d'importants tableaux de valeurs.
Ainsi, le pseudo code représenté dans l'annexe A-10 donne un exemple de mise en oeuvre de la loi A tel que décrit dans la norme G.711 (avec une approximation linéaire par morceaux de loi de compression d'amplitude). Une implémentation concrète de ce pseudo code est également donnée à titre d'exemple dans l'annexe A-10. Cette implémentation est conforme à la recommandation ITU-T G.191 Sofware Tool Library (STL-2005), chapitre 13 « ITU-T Basic Operators ». Cette recommandation est accessible sur le site Internet de l'ITU :

http://www.itu.int/rec/T-REC-G.191-200508-I/en

On voit dans ce pseudo-code que l'indice de quantification sur 8 bits comprend le bit signe (signe), l'indice du segment (exp) et la position sur le segment (mant).
Dans une première partie de ce codage, on détermine le bit de signe que l'on met à la position 0 comme indiqué en 15 sur la figure 1. Ensuite, on cherche la position du bit de poids le plus fort "pos" et on calcule le numéro de segment que l'on code sur 3 bits que l'on met à la position 1, 2 et 3 comme représenté en 15 à la figure 1.
Les 4 bits constituant la position sur le segment sont mis aux positions 4, 5, 6 et 7 comme représenté en 15.
Il y a toujours un décalage de bits à droite d'au moins 4 bits (x = shift_rignt (x, pos - 4)) et donc 4 bits perdus;
On n'utilise donc que les bits de poids le plus fort (Most Significant Bit MSB en anglais) pour constituer la trame d'indices de quantification. La variable minimum de la variable "pos" pour le codage selon la loi A est de 8. Il y a donc pour tous les segments au moins 4 bits de poids plus faible qui sont perdus. La compression du processus de compression d'amplitude est ainsi effectuée.

Pour un signal d'entrée d'une résolution de 16 bits par échantillon (en format "PCM linéaire"), le plus petit pas de quantification est 16, les 4 bits de poids plus faible étant perdus. Le tableau 2 ci-après donne les seuils et pas de quantification en fonction de chaque segment pour la G.711 loi A.

Tableau 2 Pas de quantification G.711 loi A

Segment	Seuil inférieur	Seuil supérieur	Pas de quantification
0	0	255	16
1	256	511	16
2	512	1023	32
3	1024	2047	64
4	2048	4095	128
5	4096	8191	256
6	8192	16383	512
7	16384	32767	1024

De la même façon, le décodage peut être mis en oeuvre par des opérations simples comme l'illustre le pseudo-code et l'implémentation ITU-T STL-2005 représentés dans l'annexe A-11.
On peut voir dans ce pseudo code que le signe (signe), le segment (exp) et la valeur dans le segment (val) sont retrouvés à partir de l'indice de 8 bits (indice). Une valeur d'arrondi égale à 8 et correspondant à la moitié du pas de quantification utilisé pour un segment est appliqué pour obtenir la valeur du milieu de l'intervalle de quantification. Ainsi, l'inversion du processus de compression d'amplitude est effectuée. Les bits les moins significatifs qui ont été rejetés au codage sont retrouvés ici après approximation.

La version loi mu de G.711 est similaire à la loi A. La différence principale est qu'on additionne 128 aux valeurs pour assurer que dans le premier segment le bit 7 est toujours égal à 1 ce qui rend inutile la transmission de ce bit et donc augmente la précision du premier segment (pas de quantification 8 dans le premier segment contre 16 dans la loi A). Cela permet également un traitement identique de tous les segments. De plus on additionne 4 (donc 128+4 = 132 au total) pour l'arrondi pour avoir le niveau 0 parmi les valeurs quantifiées (la loi A n'a pas de niveau 0, les plus petites valeurs sont 8 ou -8). Le prix de cette meilleure résolution dans le premier segment est le décalage de tous les segments par 132. Le Tableau 3 ci-après donne les seuils et le pas de quantification en fonction de chaque segment pour la G.711 loi mu.

Tableau 3 Pas de quantification G.711 loi mu

Segment	Seuil inférieur	Seuil supérieur	Pas de quantification
0	0	123	8
1	124	379	16
2	380	891	32
3	892	1915	64
4	1916	3963	128
5	3964	8059	256
6	8060	16251	512
7	16252	32635	1024

Les figures 3a et 3b permettent de comparer la résolution de ces deux lois pour les 512 premières valeurs.
De la même façon que pour la loi A, une méthode de mise en oeuvre sans stockage de tableaux de valeurs est donnée par un exemple de pseudo-code d'encodage selon la norme G.711 loi mu représenté dans l'annexe A-12.
De la même façon que pour la loi A, on voit dans ce pseudo-code qu'il y a toujours un décalage de bits à droite d'au moins 3 bits (x = shift-right (x, pos - 4)), la valeur minimale de « pos » étant 7 pour la loi mu.
On n'utilise donc que les bits de poids le plus fort (MSB) pour constituer la trame d'indices de quantification et ainsi effectuer l'étape de compression d'amplitude.
La valeur minimale de la variable "pos" pour le codage selon la loi mu est de 7 puisque comme mentionné précédemment dans le cas de la loi mu le premier segment est traité de même façon que les autres segments. Il y a donc pour tous les segments au moins 3 bits de poids plus faible qui sont perdus.
Comme pour la loi A, le décodage peut s'effectuer simplement par un algorithme simple, un exemple est donné en annexe A-13.
Le codeur 23 selon l'invention tire partie de la méthode de codage selon les lois A ou mu en mémorisant dans un espace mémoire représenté en 27, une partie des bits de poids faible qui n'ont pas été pris en compte pour le codage de la trame binaire d'indices de quantification I_MIC.
Ainsi, comme mentionné précédemment pour le codage logarithmique selon les lois A ou mu, au moins 3 bits pour tous les segments peuvent être mémorisées.
Le nombre de bits perdus par les méthodes de codage selon la loi A ou mu, augmente avec le numéro du segment, jusqu'à 10 bits pour le dernier segment.
Le procédé selon l'invention permet de récupérer au moins les bits de poids le plus fort parmi ces bits perdus.
Pour déterminer un flux d'amélioration d'un débit de 16 kbit/s, donc de 2 bits par échantillon, le procédé selon l'invention mémorisera en mémoire 27, les deux bits de poids forts des bits qui ne sont pas pris en compte dans l'opération de compression pour déterminer la trame d'indices de quantification.
Ces bits sont récupérés pour déterminer en 28 par des moyens de détermination du flux d'extension, le flux d'amélioration I_EXT. Ce flux d'amélioration est ensuite transmis via un autre canal de transmission 25 vers un décodeur 24.
Ainsi, le décodeur 24 comportant un quantificateur inverse, ici un quantificateur MIC inverse Q^-1 _MIC 22, reçoit en parallèle le flux de base I'_MIC et le flux d'amélioration I'_EXT.
Ces flux I'_MIC et I'_EXT sont des versions éventuellement perturbées par des erreurs binaires de I_MIC et de I_EXT respectivement.
En cas de réception de ce flux d'amélioration par les moyens de réception 29 du décodeur 24, le décodeur aura alors une plus grande précision sur l'emplacement de l'échantillon décodé dans le segment. Pour cela, il concatène les bits d'extension aux bits reçus dans le flux de base I'_MIC par des moyens 30 de concaténation de bits, pour ensuite effectuer une quantification inverse en 22.
En effet, l'apport d'un bit supplémentaire permet de multiplier par deux le nombre de niveaux des segments. Le fait de doubler le nombre de niveaux, augmente aussi le rapport signal à bruit de 6 dB. Ainsi, pour chaque bit ajouté dans le flux d'amélioration et reçu au décodeur, le rapport signal à bruit sera augmenté de 6 dB, ce qui augmente ainsi la qualité du signal décodé sans pour autant augmenter considérablement la complexité au codeur.
Dans l'exemple illustré à la figure 2, le flux d'amélioration I_EXT est constitué de deux bits d'extension par échantillon, soit un débit de 16kbit/s. Ces bits d'extension peuvent être obtenus en faisant un décalage de bits en deux opérations comme le montre le pseudo code représenté en annexe A-14.
On peut voir qu'au lieu de décaler en un seul coup les bits par "pos-4" position pour ne garder que les 5 bits de poids le plus fort, comme c'est le cas dans le codage selon la loi A, on décale dans un premier temps 2 positions de moins (donc "pos-6" positions) pour garder les 7 bits de poids le plus fort et on mémorise en 27 les deux derniers bits. Puis dans une autre étape, on décale encore de deux bits pour obtenir les 5 bits de poids fort dont le premier bit toujours à 1 est non transmis. Les 4 autres sont utilisés pour le flux de base.
Les deux bits mémorisés sont envoyés dans le flux d'extension.
Comme représenté sur la figure 2, on peut considérer que ces deux bits d'extension sont le 8^ième et le 9^ième bit du signal compressé.
Le pseudo code permettant de faire l'ensemble des opérations au codeur pour la loi A est donné en annexe A-15.
On voit que les différences par rapport au codage G.711 classique (passages soulignés et en gras dans l'annexe) sont les étapes de décalage en deux temps comme explicité précédemment et la prise en compte de ces deux bits mémorisés pour déterminer le flux d'amélioration "ext" et le transmettre.
De même pour l'implémentation de la loi mu, le pseudo code correspondant pour le codage est représenté dans l'annexe A-16.
On remarque les mêmes différences avec le codage classique que pour le codage selon la loi A.
La figure 4 montre une comparaison des valeurs quantifiées par rapport aux valeurs d'entrée entre la loi A classique (en pointillé) et la loi A avec extension de deux bits par échantillon (trait continu), pour les 128 premières valeurs.
De même, la figure 5 montre une comparaison des valeurs quantifiées par rapport aux valeurs d'entrée entre la loi mu classique (en pointillé) et la loi mu avec extension de deux bits par échantillon (trait continu), pour les 128 premières valeurs.
A la réception du flux d'amélioration I'_EXT, le décodeur concatène en 30 les bits d'extension ainsi reçus derrière des bits de position du flux de base I'_MIC pour effectuer la décompression d'amplitude - ou expansion - qui est l'opération inverse du processus de compression d'amplitude.
La prise en compte de ces bits supplémentaires permet ainsi d'obtenir une plus grande précision de l'emplacement de l'échantillon décodé dans le segment.
En effet, pour un bit supplémentaire, le segment est divisé en deux. La précision sur l'emplacement dans le segment de la valeur décodée est alors plus importante.
La valeur d'arrondi « roundval » qui permet de trouver la valeur du milieu du segment est aussi adaptée en fonction de nombre bits d'extension reçus.
L'information du nombre de bits d'extension reçus est par exemple donnée par l'intermédiaire d'une signalisation externe comme représenté par la flèche 26 sur la figure 2.
Cette information pourrait également être déduite directement par l'analyse du flux d'extension.
Un exemple de décodage prenant en compte ces bits d'extension est donné en annexe A-17 par les pseudos codes pour la loi A et la loi mu respectivement:

Les différences entre le décodage classique et celui de l'invention (passages soulignés et en gras dans l'annexe) représentent la prise en compte des bits du flux d'extension et l'application d'une valeur d'arrondi "roundval".

Le codeur tel que représenté en figure 2 comporte un processeur de type DSP (pour "Digital Signal Processor"), non représenté ici, un espace mémoire 27 pour mémoriser au moins les bits qui serviront à déterminer le flux d'extension.
Cet espace mémoire 27 peut faire partie d'un bloc mémoire qui comporte en outre une mémoire de stockage et/ou une mémoire de travail.
Le moyen de stockage peut comporter un programme informatique comportant des instructions de code pour la mise en oeuvre des étapes du procédé de codage selon l'invention lorsqu'elles sont exécutées par le processeur du codeur.
Le programme informatique peut être également stocké sur un support mémoire lisible par un lecteur du codeur ou téléchargeable dans l'espace mémoire du codeur.
Ce codeur met ainsi en oeuvre le procédé selon l'invention comme éconcé dans la revendication 1.
De même, le décodeur selon l'invention comporte un processeur de type DSP non représenté ici et est apte à mettre en oeuvre le procédé comme éconcé dans la revendication 5.
Ce décodeur comporte en outre un moyen de stockage (non représenté), apte à stocker un programme informatique comportant des instructions de code pour la mise en oeuvre des étapes du procédé de décodage selon l'invention lorsqu'elles sont exécutées par le processeur du décodeur.
Le programme informatique peut être également stocké sur un support mémoire lisible par un lecteur du décodeur ou téléchargeable dans l'espace mémoire du décodeur.
L'exemple représenté et expliqué en référence à la figure 2 est donné pour une couche d'extension de 2 bits par échantillon. Ce procédé est bien évidemment généralisable pour un autre nombre de bits, par exemple 1, 2, 3 bits ou plus. Le pseudo code correspondant serait alors comme représenté en annexe A-18.
Les « ext_bits » LSB de la variable « ext » sont envoyés dans le flux d'amélioration.
A noter que le terme "pos-4-ext"_bits peut être négatif pour ext_bits > 3 dans les premiers segments et selon la loi utilisé (A ou mu). Même dans ces conditions le pseudo code donné fonctionnerait correctement car shift_right(x, -v) = shift_left(x, v). En d'autres termes, dans le cas où le nombre de bits de poids faible qui ne sont pas pris en compte dans la trame d'indices de quantification est inférieur au nombre de bits du flux d'extension, en particulier dans les premiers segments, il suffit de compléter dans le flux d'extension les bits manquants par des zéros. Ainsi, les bits de poids le plus fort du flux d'extension seront les bits mémorisés et récupérés selon l'invention, les bits de poids le plus faible seront mis à 0.
Pour les segments suivants, le nombre de bits mémorisés augmentant, il ne sera plus nécessaire de compléter par des zéros.
De même, l'invention s'applique également dans le cas où au cours de transmission le débit doit être réduit. Dans le cas où le flux d'extension comporte deux bits, le bit de poids faible de ce flux d'extension n'est alors plus transmis.
Le décodeur ne reçoit alors qu'un bit d'extension par échantillon. Le décodeur tel qu' il est décrit dans le pseudo-code à titre d'exemple fonctionnera correctement avec cette couche d'extension réduite à un bit par échantillon à condition que le bit d'extension reçu soit mis dans la variable « ext » à la position 1, le bit de position 0 de la variable « ext » est alors mis à 0 et la valeur de "roundval" est adaptée en conséquence.
La valeur de la variable "roundval" telle qu'utilisé dans les exemples donnés est donc en fonction du nombre de bits reçus par l'encodeur et de la loi utilisée (A ou mu). Le tableau 4 ci-après donne la valeur de la variable "roundval" dans les différentes situations. Tableau 4 La valeur de la variable "round val" dans différentes configurations

bits d'amélioration reçus par l'encodeur 0 1 2 3

Loi A 8 4 2 1

Loi mu 4 2 1 0
Cet exemple montre donc un autre avantage de la solution présentée qui est que le train binaire de la couche d'extension est hiérarchique. Il est donc possible de diminuer son débit au cours de la transmission.
Ainsi, si les deux bits sont reçus par le décodeur, l'augmentation du RSB est de 12 dB, si un bit est reçu, l'augmentation du RSB est de 6 dB.
Bien sur cet exemple est également généralisable, par exemple l'encodeur peut envoyer 4 bits par échantillon dans la couche d'extension et le décodeur peut recevoir 4, 3, 2, 1 ou 0 de ces bits, la qualité du signal décodé sera proportionnelle avec le nombre de bits d'extension reçus.
On peut observer dans les pseudo-codes donnés que la complexité additionnelle du décodage de la couche d'extension est seulement de deux opérations par échantillons à l'encodeur et 4 opérations par échantillons au décodeur soit ∼0.05 million d'opérations pondérées par seconde, ou "Weighted Million Operations per Second" (WMOPS) en anglais, ce qui est négligeable. Cette faible complexité peut être exploitée dans le cas d'un codage hiérarchique étendant G.711 tout en permettant par exemple dans des applications de conférence audio de réaliser un mixage "conventionnel" de faible complexité de flux G.711 ou G.711 étendu selon l'invention, alors que dans l'article de Hiwasaki un mixage dit "partiel", impliquant une dégradation de qualité par rapport au mixage conventionnel, est mis en oeuvre pour limiter la complexité du mixage avec codage G.711 scalable.
Dans un mode de réalisation alternatif, l'invention sera mise en oeuvre non pas suivant les algorithmes spécifiés précédemment par pseudo-code mais en pré-calculant et stockant dans des tables au codeur et/ou au décodeur les niveaux permettant d'obtenir les bits d'extension. Cette solution a cependant l'inconvénient de nécessiter de plus grande capacité en mémoire à la fois au codeur et au décodeur pour un gain en complexité faible.

ANNEXES:

A-10:

  function lin_to_Alaw(input_16bit)
    x = input_16bit
    signe = 0x80 /*supposing + */
    if x < 0
      x = ∼x /*abs(x) - 1*/
      signe = 0
    end
    if x > 255 /* 1st bit 1 + 4 saved bits */
     pos = cherche_position_bit_1_poids_fort(x) /* 14 >= pos
     >= 8 */
      exp = shift_left(pos - 7, 4)
      x = shift_right(x, pos - 4)
      mant = x - 16 /* remove leading 1 */
    else
      exp = 0
      mant = shift_right(x, 4)
    end
    ind_tmp = signe + exp + mant
    indice = xor(ind_tmp, 0x0055) /* toggle odd bits */
  return indice /* only 8LSB bits are used */

Version ITU-T STL-2005 :

  short lin_to_Alaw(short input_16bit) {
    short x, signe, pos, exp, mant, ind_tmp, indice;
    x = input_16bit;
    signe = 0x80; /*supposing + */
    IF(x < 0)
    {
      x = s_xor(x, (short)0xFFFF); /*abs(x) - 1*/
      signe = 0;
    }
    IF (sub(x, 255) > 0) /* 1st bit 1 + 4 saved bits */
    {
      pos = sub(14, norm_s(x)); /* 14 >= pos >= 8 */
     exp = shl(sub(pos, 7), 4);
     x = shr(x, sub(pos, 4));
     mant = sub(x, 16); /* remove leading 1 */
    }
   ELSE
    {
      exp = 0;
     mant = shr(x, 4);
    }
    ind_tmp = add(signe, add(exp, mant) );
    indice = s_xor(ind_tmp, 0x0055); /* toogle odd bits */
    return(indice); /* only 8LSB bits are used */
   }

A-11:

  function Alaw_to_lin(indice)
    signe = and(indice, 0x80);
    y = and(xor(indice, 0x0055), 0x7F) /* without sign */
    exp = shift_right(y, 4)
    val = shift_left(and(y, 0xF), 4) + 8 /* with rounding */
    if exp > 0
      val = shift_left(val + 256, exp - 1) /* add leading 1 */
    end
    if signe == 0 /* sign bit ==0 → negative value */
      val = -val
    end
  return val

Version ITU-T STL-2005 :

  short Alaw_to_lin (short indice)
  {
    short y, signe, exp, val;
    signe = s_and(indice, 0x80);
    y = s_and(s_xor (indice, 0x0055), 0x7F); /* without sign */
    exp = shr(y, 4);
    val = add(shl(s_and(y, 0xF), 4), 8); /* rounding */
    if(exp > 0)
    {
      val = shl(add(val, 256), sub(exp, 1)); /*add leading 1 */
    }
    if(signe == 0) /* sign bit ==0 'negative value */
    {
      val = negate(val);
    }
    return(val);
  }

A-12:

  function lin_to_mulaw(input_16bit)
    x = input_16bit
    signe = 0x80 /* supposing + */
    if x > 32635 /* to avoid overflow after adding 132*/
      x = 32635
    end
    if x < -32635
      x = -32635
    end
    if x < 0
      x = ∼x /*abs(x) - 1*/
      signe = 0x00
    end
    x = x + 132
    /* always 1st bit 1 + 4 saved bits */
    pos = cherche_position_bit_1_poids_fort(x) /* 14 >= pos >=
    7 */
    exp = shift_left(pos - 7, 4)
    x = shift_right(x, pos - 4)
    mant = x - 16 /* remove leading 1 */
    ind_tmp = signe + exp + mant
    indice = xor(ind_tmp, 0x007F) /* toggle all bits */
  return indice /* only 8LSB bits are used */

A-13:

function mulaw_to_lin(indice)
    signe = and(indice, 0x80);
    y = and(xor(indice, 0x00FF), 0x7F) /* without sign */
    exp = shift_right(y, 4)
    val = shift_left(and(y, 0xF), 3) + 132 /* leading 1 &
    rounding */
    val = shift_left(val, exp) - 132 /* suppress encoder offset
    */
    if signe == 0 /* sign bit ==0 → negative value */
      val = -val
    end
  return val

A-14:

  x = shift_right(x, pos - 6) /* first part of shift*/
    ext = and(x, 0x3) /*save last two bits*/
    x = shift_right(x, 2) /* finish shift*/

A-15:

  function lin_to_Alaw_enh(input_16bit)
    x = input_16bit
    signe = 0x80 /*supposing + */
    if x < 0
      x = ∼x /*abs(x) - 1*/
      signe = 0
    end
    if x > 255 /* 1st bit 1 + 4 saved bits */
      pos = cherche_position_bit_1_poids_fort (x) /* 14 >= pos
      >= 8 */
      exp = shift_left(pos - 7, 4)
      x = shift_right(x, pos - 6) /* first part of shift */
      ext = and(x, 0x3 /* save last to bits */
      x = shift_right(x, 2) /* finish shift */
      mant = x - 16 /* remove leading 1 */
    else
      exp = 0
      x = shift_right(x, 2)
      ext = and(x, 0x3) /* save last two bits */
      x = shift_right(x, 2) /* finish shift */
    end
    ind_tmp = signe + exp + mant
    indice = xor(ind_tmp, 0x0055) /* toggle odd bits */
  return indice, ext /* only 8LSB bits are used in indice and
  2LSB bits in ext*/

A-16:

  function lin_to_mulaw_enh(input_16bit)
    x = input_16bit
    signe = 0x80 /* supposing + */
    if x > 32635 /* to avoid overflow after adding 132*/
      x = 32635
    end
    if x < -32635
      x = -32635
    end
    if x < 0
      x = ∼x /*abs(x) - 1*/
      signe = 0x00
    end
    x = x + 132
    /* always 1st bit 1 + 4 saved bits */
    pos = cherche_position_bit_1_poids_fort(x) /* 14 >= pos >=
    7 */
    exp = shift_left(pos - 7, 4)
    x = shift_right(x, pos - 6) /* first part of shift */
    ext = and(x, 0x3) /* save last two bits */
    x = shift_right(x, 2) /* finish shift */
    mant = x - 16 /* remove leading 1 */
    ind_tmp = signe + exp + mant
    indice = xor (ind_tmp, 0x007F) /* toggle all bits */
  return indice, ext /* only 8LSB bits are used in indice and
  2LSB bits in ext*/

A-17:
Loi A:

  function Alaw_to_lin_enh(indice, ext, roundval)
    signe = and(indice, 0x80);
    y = and(xor(indice, 0x0055), 0x7F) /* without sign */
    exp = shift_right(y, 4)
    ext = shift_left(and(ext, 0x03), 2) /* put extension bits in
    position 2 & 3 */
    val = shift_left(and(y, 0xF), 4) + ext + roundval /* with
    rounding */
    if exp > 0
      val = shift_left(val + 256, exp - 1) /* adding leading 1
      */
    end
    if signe == 0 /* sign bit ==0 → negative value */
      val = -val
    end
  return val

Loi mu:

  function mulaw_to_lin_enh(indice, ext, roundval)
    signe = and(indice, 0x80);
    y = and(xor(indice, 0x007F), 0x7F) /* without sign */
    exp = shift_right(y, 4)
    ext = shift_left(and(ext, 0x03), 1) /* put extension bits in
    position 1 & 2 */
    val = shift_left(and(y, 0xF), 3) + 128 + ext + roundval /*
    leading 1 & rounding */
    val = shift_left(val, exp) - 132 /* suppress encoder offset
    */
    if signe == 0 /* sign bit ==0 → negative value */
      val = -val
    end
  return val

A-18:

  x = shift_right(x, pos - 4 - ext_bits) /* first part of
  shift*/
    ext = and(x, shift_left(1, ext_bits) -1) /* last ext_bits
    bits*/
    x = shift_right(x, ext_bits) /* finish shift*/

Claims

Procédé de codage par quantification scalaire des échantillons d'un signal audionumérique (S), les échantillons étant codés sur un nombre prédéterminés de bits pour obtenir une trame binaire d'indices de quantification (I_MIC), le codage s'effectuant selon une loi logarithmique de compression d'amplitude, un nombre prédéterminé de bits de poids faible du signal audionumérique en format MIC linéaire n'étant pas pris en compte dans l'opération de compression pour former la trame binaire d'indices de quantification, caractérisé en ce qu'il comporte les étapes suivantes:
- mémorisation (27) d'au moins une partie des bits de poids faible qui ne sont pas pris en compte dans l'opération de compression pour former la trame binaire d'indice de quantification;

- détermination (28) d'un flux d'amélioration (I_EXT) comportant au moins un bit ainsi mémorisé.
Procédé selon la revendication 1, caractérisé en ce que les bits mémorisés sont les bits de poids le plus fort parmi les bits qui ne sont pas pris en compte dans l'opération de compression pour former la trame binaire d'indices de quantification.
Procédé selon l'une des revendications 1 à 2, caractérisé en ce que le nombre de bits pris en compte pour déterminer le flux d'amélioration est fonction du débit disponible au cours d'une transmission vers un décodeur.
Procédé selon l'une des revendications 1 à 3, caractérisé en ce que l'étape de quantification scalaire est une quantification de type MIC selon une loi de codage logarithmique de compression d'amplitude de type A ou de type mu conforme à la norme ITU-T G.711.
Procédé de décodage d'une trame binaire d'indices de quantification (I'_MIC) comportant un nombre prédéterminé de bits par une étape de quantification inverse (22) et selon une loi logarithmique de compression d'amplitude caractérisé en ce qu'il comporte les étapes suivantes:
- réception (29) d'un flux d'amélioration (I'_EXT) comportant un ou plusieurs bits d'extension déterminés selon un procédé de codage conforme à la revendication 1;

- concaténation (30) des bits d'extension derrière les bits issus de la trame binaire pour obtenir un signal audio décodé.
Procédé de décodage selon la revendication 5, caractérisé en ce qu'il comporte en outre une étape d'adaptation d'une valeur d'arrondi en fonction du nombre de bits d'extension reçu pour obtenir le signal audio décodé.
Codeur audio comportant un module de quantification scalaire (20) des échantillons d'un signal audionumérique (S), les échantillons étant codés sur un nombre prédéterminés de bits pour obtenir une trame binaire d'indices de quantification (I_MIC), le codage s'effectuant selon une loi logarithmique de compression d'amplitude, un nombre prédéterminé de bits de poids faible du signal audionumérique en format MIC linéaire n'étant pas pris en compte dans l'opération de compression pour former la trame binaire d'indices de quantification, caractérisé en ce qu'il comporte:
- un espace mémoire (27) apte à mémoriser au moins une partie des bits de poids faible qui ne sont pas pris en compte dans l'opération de compression pour former la trame binaire d'indice de quantification;

- des moyens de détermination (28) d'un flux d'amélioration (I_EXT) comportant au moins un bit ainsi mémorisé.
Décodeur audio apte à décoder une trame binaire d'indices de quantification (I'_MIC) comportant un nombre prédéterminé de bits par un module de quantification inverse (22) et selon une loi logarithmique de compression d'amplitude caractérisé en ce qu'il comporte:
- des moyens de réception (29) d'un flux d'amélioration comportant un ou plusieurs bits d'extension déterminés par un codeur conforme à la revendication 7;

- des moyens de concaténation (30) des bits d'extension derrière les bits issus de la trame binaire pour obtenir un signal audio décodé.
Programme informatique destiné à être stocké dans une mémoire d'un codeur et /ou un support mémoire apte à coopérer avec un lecteur du codeur, comportant des instructions de code pour la mise en oeuvre des étapes du procédé de codage selon l'une quelconque des revendications 1 à 4 lorsqu'il est exécuté par un processeur du codeur.
Programme informatique destiné à être stocké dans une mémoire d'un décodeur et /ou un support mémoire apte à coopérer avec un lecteur du décodeur, comportant des instructions de code pour la mise en oeuvre des étapes du procédé de décodage selon l'une quelconque des revendications 5 à 6 lorsqu'il est exécuté par un processeur du décodeur.