ffmpeg / libavcodec / g726.c @ bb54f6ab
History  View  Annotate  Download (12.3 KB)
1 
/*


2 
* G.726 ADPCM audio codec

3 
* Copyright (c) 2004 Roman Shaposhnik.

4 
*

5 
* This is a very straightforward rendition of the G.726

6 
* Section 4 "Computational Details".

7 
*

8 
* This file is part of FFmpeg.

9 
*

10 
* FFmpeg is free software; you can redistribute it and/or

11 
* modify it under the terms of the GNU Lesser General Public

12 
* License as published by the Free Software Foundation; either

13 
* version 2.1 of the License, or (at your option) any later version.

14 
*

15 
* FFmpeg is distributed in the hope that it will be useful,

16 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

17 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

18 
* Lesser General Public License for more details.

19 
*

20 
* You should have received a copy of the GNU Lesser General Public

21 
* License along with FFmpeg; if not, write to the Free Software

22 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

23 
*/

24 
#include <limits.h> 
25 
#include "avcodec.h" 
26 
#include "common.h" 
27 
#include "bitstream.h" 
28  
29 
/**

30 
* G.726 11bit float.

31 
* G.726 Standard uses rather odd 11bit floating point arithmentic for

32 
* numerous occasions. It's a mistery to me why they did it this way

33 
* instead of simply using 32bit integer arithmetic.

34 
*/

35 
typedef struct Float11 { 
36 
int sign; /**< 1bit sign */ 
37 
int exp; /**< 4bit exponent */ 
38 
int mant; /**< 6bit mantissa */ 
39 
} Float11; 
40  
41 
static inline Float11* i2f(int16_t i, Float11* f) 
42 
{ 
43 
f>sign = (i < 0);

44 
if (f>sign)

45 
i = i; 
46 
f>exp = av_log2_16bit(i) + !!i; 
47 
f>mant = i? (i<<6) >> f>exp : 1<<5; 
48 
return f;

49 
} 
50  
51 
static inline int16_t mult(Float11* f1, Float11* f2) 
52 
{ 
53 
int res, exp;

54  
55 
exp = f1>exp + f2>exp; 
56 
res = (((f1>mant * f2>mant) + 0x30) >> 4) << 7; 
57 
res = exp > 26 ? res << (exp  26) : res >> (26  exp); 
58 
return (f1>sign ^ f2>sign) ? res : res;

59 
} 
60  
61 
static inline int sgn(int value) 
62 
{ 
63 
return (value < 0) ? 1 : 1; 
64 
} 
65  
66 
typedef struct G726Tables { 
67 
int bits; /**< bits per sample */ 
68 
int* quant; /**< quantization table */ 
69 
int* iquant; /**< inverse quantization table */ 
70 
int* W; /**< special table #1 ;) */ 
71 
int* F; /**< special table #2 */ 
72 
} G726Tables; 
73  
74 
typedef struct G726Context { 
75 
G726Tables* tbls; /**< static tables needed for computation */

76  
77 
Float11 sr[2]; /**< prev. reconstructed samples */ 
78 
Float11 dq[6]; /**< prev. difference */ 
79 
int a[2]; /**< second order predictor coeffs */ 
80 
int b[6]; /**< sixth order predictor coeffs */ 
81 
int pk[2]; /**< signs of prev. 2 sez + dq */ 
82  
83 
int ap; /**< scale factor control */ 
84 
int yu; /**< fast scale factor */ 
85 
int yl; /**< slow scale factor */ 
86 
int dms; /**< short average magnitude of F[i] */ 
87 
int dml; /**< long average magnitude of F[i] */ 
88 
int td; /**< tone detect */ 
89  
90 
int se; /**< estimated signal for the next iteration */ 
91 
int sez; /**< estimated second order prediction */ 
92 
int y; /**< quantizer scaling factor for the next iteration */ 
93 
} G726Context; 
94  
95 
static int quant_tbl16[] = /**< 16kbit/s 2bits per sample */ 
96 
{ 260, INT_MAX };

97 
static int iquant_tbl16[] = 
98 
{ 116, 365, 365, 116 }; 
99 
static int W_tbl16[] = 
100 
{ 22, 439, 439, 22 }; 
101 
static int F_tbl16[] = 
102 
{ 0, 7, 7, 0 }; 
103  
104 
static int quant_tbl24[] = /**< 24kbit/s 3bits per sample */ 
105 
{ 7, 217, 330, INT_MAX }; 
106 
static int iquant_tbl24[] = 
107 
{ INT_MIN, 135, 273, 373, 373, 273, 135, INT_MIN }; 
108 
static int W_tbl24[] = 
109 
{ 4, 30, 137, 582, 582, 137, 30, 4 }; 
110 
static int F_tbl24[] = 
111 
{ 0, 1, 2, 7, 7, 2, 1, 0 }; 
112  
113 
static int quant_tbl32[] = /**< 32kbit/s 4bits per sample */ 
114 
{ 125, 79, 177, 245, 299, 348, 399, INT_MAX }; 
115 
static int iquant_tbl32[] = 
116 
{ INT_MIN, 4, 135, 213, 273, 323, 373, 425, 
117 
425, 373, 323, 273, 213, 135, 4, INT_MIN }; 
118 
static int W_tbl32[] = 
119 
{ 12, 18, 41, 64, 112, 198, 355, 1122, 
120 
1122, 355, 198, 112, 64, 41, 18, 12}; 
121 
static int F_tbl32[] = 
122 
{ 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 }; 
123  
124 
static int quant_tbl40[] = /**< 40kbit/s 5bits per sample */ 
125 
{ 122, 16, 67, 138, 197, 249, 297, 338, 
126 
377, 412, 444, 474, 501, 527, 552, INT_MAX }; 
127 
static int iquant_tbl40[] = 
128 
{ INT_MIN, 66, 28, 104, 169, 224, 274, 318, 
129 
358, 395, 429, 459, 488, 514, 539, 566, 
130 
566, 539, 514, 488, 459, 429, 395, 358, 
131 
318, 274, 224, 169, 104, 28, 66, INT_MIN }; 
132 
static int W_tbl40[] = 
133 
{ 14, 14, 24, 39, 40, 41, 58, 100, 
134 
141, 179, 219, 280, 358, 440, 529, 696, 
135 
696, 529, 440, 358, 280, 219, 179, 141, 
136 
100, 58, 41, 40, 39, 24, 14, 14 }; 
137 
static int F_tbl40[] = 
138 
{ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 6, 
139 
6, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; 
140  
141 
static G726Tables G726Tables_pool[] =

142 
{{ 2, quant_tbl16, iquant_tbl16, W_tbl16, F_tbl16 },

143 
{ 3, quant_tbl24, iquant_tbl24, W_tbl24, F_tbl24 },

144 
{ 4, quant_tbl32, iquant_tbl32, W_tbl32, F_tbl32 },

145 
{ 5, quant_tbl40, iquant_tbl40, W_tbl40, F_tbl40 }};

146  
147  
148 
/**

149 
* Para 4.2.2 page 18: Adaptive quantizer.

150 
*/

151 
static inline uint8_t quant(G726Context* c, int d) 
152 
{ 
153 
int sign, exp, i, dln;

154  
155 
sign = i = 0;

156 
if (d < 0) { 
157 
sign = 1;

158 
d = d; 
159 
} 
160 
exp = av_log2_16bit(d); 
161 
dln = ((exp<<7) + (((d<<7)>>exp)&0x7f))  (c>y>>2); 
162  
163 
while (c>tbls>quant[i] < INT_MAX && c>tbls>quant[i] < dln)

164 
++i; 
165  
166 
if (sign)

167 
i = ~i; 
168 
if (c>tbls>bits != 2 && i == 0) /* I'm not sure this is a good idea */ 
169 
i = 0xff;

170  
171 
return i;

172 
} 
173  
174 
/**

175 
* Para 4.2.3 page 22: Inverse adaptive quantizer.

176 
*/

177 
static inline int16_t inverse_quant(G726Context* c, int i) 
178 
{ 
179 
int dql, dex, dqt;

180  
181 
dql = c>tbls>iquant[i] + (c>y >> 2);

182 
dex = (dql>>7) & 0xf; /* 4bit exponent */ 
183 
dqt = (1<<7) + (dql & 0x7f); /* log2 > linear */ 
184 
return (dql < 0) ? 0 : ((dqt<<7) >> (14dex)); 
185 
} 
186  
187 
static inline int16_t g726_iterate(G726Context* c, int16_t I) 
188 
{ 
189 
int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0;

190 
Float11 f; 
191  
192 
dq = inverse_quant(c, I); 
193 
if (I >> (c>tbls>bits  1)) /* get the sign */ 
194 
dq = dq; 
195 
re_signal = c>se + dq; 
196  
197 
/* Transition detect */

198 
ylint = (c>yl >> 15);

199 
ylfrac = (c>yl >> 10) & 0x1f; 
200 
thr2 = (ylint > 9) ? 0x1f << 10 : (0x20 + ylfrac) << ylint; 
201 
if (c>td == 1 && abs(dq) > ((thr2+(thr2>>1))>>1)) 
202 
tr = 1;

203 
else

204 
tr = 0;

205  
206 
/* Update second order predictor coefficient A2 and A1 */

207 
pk0 = (c>sez + dq) ? sgn(c>sez + dq) : 0;

208 
dq0 = dq ? sgn(dq) : 0;

209 
if (tr) {

210 
c>a[0] = 0; 
211 
c>a[1] = 0; 
212 
for (i=0; i<6; i++) 
213 
c>b[i] = 0;

214 
} else {

215 
/* This is a bit crazy, but it really is +255 not +256 */

216 
fa1 = clip((c>a[0]*c>pk[0]*pk0)>>5, 256, 255); 
217  
218 
c>a[1] += 128*pk0*c>pk[1] + fa1  (c>a[1]>>7); 
219 
c>a[1] = clip(c>a[1], 12288, 12288); 
220 
c>a[0] += 64*3*pk0*c>pk[0]  (c>a[0] >> 8); 
221 
c>a[0] = clip(c>a[0], (15360  c>a[1]), 15360  c>a[1]); 
222  
223 
for (i=0; i<6; i++) 
224 
c>b[i] += 128*dq0*sgn(c>dq[i].sign)  (c>b[i]>>8); 
225 
} 
226  
227 
/* Update Dq and Sr and Pk */

228 
c>pk[1] = c>pk[0]; 
229 
c>pk[0] = pk0 ? pk0 : 1; 
230 
c>sr[1] = c>sr[0]; 
231 
i2f(re_signal, &c>sr[0]);

232 
for (i=5; i>0; i) 
233 
c>dq[i] = c>dq[i1];

234 
i2f(dq, &c>dq[0]);

235 
c>dq[0].sign = I >> (c>tbls>bits  1); /* Isn't it crazy ?!?! */ 
236  
237 
/* Update tone detect [I'm not sure 'tr == 0' is really needed] */

238 
c>td = (tr == 0 && c>a[1] < 11776); 
239  
240 
/* Update Ap */

241 
c>dms += ((c>tbls>F[I]<<9)  c>dms) >> 5; 
242 
c>dml += ((c>tbls>F[I]<<11)  c>dml) >> 7; 
243 
if (tr)

244 
c>ap = 256;

245 
else if (c>y > 1535 && !c>td && (abs((c>dms << 2)  c>dml) < (c>dml >> 3))) 
246 
c>ap += (c>ap) >> 4;

247 
else

248 
c>ap += (0x200  c>ap) >> 4; 
249  
250 
/* Update Yu and Yl */

251 
c>yu = clip(c>y + (((c>tbls>W[I] << 5)  c>y) >> 5), 544, 5120); 
252 
c>yl += c>yu + ((c>yl)>>6);

253  
254 
/* Next iteration for Y */

255 
al = (c>ap >= 256) ? 1<<6 : c>ap >> 2; 
256 
c>y = (c>yl + (c>yu  (c>yl>>6))*al) >> 6; 
257  
258 
/* Next iteration for SE and SEZ */

259 
c>se = 0;

260 
for (i=0; i<6; i++) 
261 
c>se += mult(i2f(c>b[i] >> 2, &f), &c>dq[i]);

262 
c>sez = c>se >> 1;

263 
for (i=0; i<2; i++) 
264 
c>se += mult(i2f(c>a[i] >> 2, &f), &c>sr[i]);

265 
c>se >>= 1;

266  
267 
return clip(re_signal << 2, 0xffff, 0xffff); 
268 
} 
269  
270 
static int g726_reset(G726Context* c, int bit_rate) 
271 
{ 
272 
int i;

273  
274 
c>tbls = &G726Tables_pool[bit_rate/8000  2]; 
275 
for (i=0; i<2; i++) { 
276 
i2f(0, &c>sr[i]);

277 
c>a[i] = 0;

278 
c>pk[i] = 1;

279 
} 
280 
for (i=0; i<6; i++) { 
281 
i2f(0, &c>dq[i]);

282 
c>b[i] = 0;

283 
} 
284 
c>ap = 0;

285 
c>dms = 0;

286 
c>dml = 0;

287 
c>yu = 544;

288 
c>yl = 34816;

289 
c>td = 0;

290  
291 
c>se = 0;

292 
c>sez = 0;

293 
c>y = 544;

294  
295 
return 0; 
296 
} 
297  
298 
static int16_t g726_decode(G726Context* c, int16_t i)

299 
{ 
300 
return g726_iterate(c, i);

301 
} 
302  
303 
#ifdef CONFIG_ENCODERS

304 
static int16_t g726_encode(G726Context* c, int16_t sig)

305 
{ 
306 
uint8_t i; 
307  
308 
i = quant(c, sig/4  c>se) & ((1<<c>tbls>bits)  1); 
309 
g726_iterate(c, i); 
310 
return i;

311 
} 
312 
#endif

313  
314 
/* Interfacing to the libavcodec */

315  
316 
typedef struct AVG726Context { 
317 
G726Context c; 
318 
int bits_left;

319 
int bit_buffer;

320 
int code_size;

321 
} AVG726Context; 
322  
323 
static int g726_init(AVCodecContext * avctx) 
324 
{ 
325 
AVG726Context* c = (AVG726Context*)avctx>priv_data; 
326  
327 
if (avctx>channels != 1  
328 
(avctx>bit_rate != 16000 && avctx>bit_rate != 24000 && 
329 
avctx>bit_rate != 32000 && avctx>bit_rate != 40000)) { 
330 
av_log(avctx, AV_LOG_ERROR, "G726: unsupported audio format\n");

331 
return 1; 
332 
} 
333 
if (avctx>sample_rate != 8000 && avctx>strict_std_compliance>FF_COMPLIANCE_INOFFICIAL) { 
334 
av_log(avctx, AV_LOG_ERROR, "G726: unsupported audio format\n");

335 
return 1; 
336 
} 
337 
g726_reset(&c>c, avctx>bit_rate); 
338 
c>code_size = c>c.tbls>bits; 
339 
c>bit_buffer = 0;

340 
c>bits_left = 0;

341  
342 
avctx>coded_frame = avcodec_alloc_frame(); 
343 
if (!avctx>coded_frame)

344 
return ENOMEM;

345 
avctx>coded_frame>key_frame = 1;

346  
347 
return 0; 
348 
} 
349  
350 
static int g726_close(AVCodecContext *avctx) 
351 
{ 
352 
av_freep(&avctx>coded_frame); 
353 
return 0; 
354 
} 
355  
356 
#ifdef CONFIG_ENCODERS

357 
static int g726_encode_frame(AVCodecContext *avctx, 
358 
uint8_t *dst, int buf_size, void *data) 
359 
{ 
360 
AVG726Context *c = avctx>priv_data; 
361 
short *samples = data;

362 
PutBitContext pb; 
363  
364 
init_put_bits(&pb, dst, 1024*1024); 
365  
366 
for (; buf_size; buf_size)

367 
put_bits(&pb, c>code_size, g726_encode(&c>c, *samples++)); 
368  
369 
flush_put_bits(&pb); 
370  
371 
return put_bits_count(&pb)>>3; 
372 
} 
373 
#endif

374  
375 
static int g726_decode_frame(AVCodecContext *avctx, 
376 
void *data, int *data_size, 
377 
uint8_t *buf, int buf_size)

378 
{ 
379 
AVG726Context *c = avctx>priv_data; 
380 
short *samples = data;

381 
uint8_t code; 
382 
uint8_t mask; 
383 
GetBitContext gb; 
384  
385 
if (!buf_size)

386 
goto out;

387  
388 
mask = (1<<c>code_size)  1; 
389 
init_get_bits(&gb, buf, buf_size * 8);

390 
if (c>bits_left) {

391 
int s = c>code_size  c>bits_left;;

392 
code = (c>bit_buffer << s)  get_bits(&gb, s); 
393 
*samples++ = g726_decode(&c>c, code & mask); 
394 
} 
395  
396 
while (get_bits_count(&gb) + c>code_size <= buf_size*8) 
397 
*samples++ = g726_decode(&c>c, get_bits(&gb, c>code_size) & mask); 
398  
399 
c>bits_left = buf_size*8  get_bits_count(&gb);

400 
c>bit_buffer = get_bits(&gb, c>bits_left); 
401  
402 
out:

403 
*data_size = (uint8_t*)samples  (uint8_t*)data; 
404 
return buf_size;

405 
} 
406  
407 
#ifdef CONFIG_ENCODERS

408 
AVCodec adpcm_g726_encoder = { 
409 
"g726",

410 
CODEC_TYPE_AUDIO, 
411 
CODEC_ID_ADPCM_G726, 
412 
sizeof(AVG726Context),

413 
g726_init, 
414 
g726_encode_frame, 
415 
g726_close, 
416 
NULL,

417 
}; 
418 
#endif //CONFIG_ENCODERS 
419  
420 
AVCodec adpcm_g726_decoder = { 
421 
"g726",

422 
CODEC_TYPE_AUDIO, 
423 
CODEC_ID_ADPCM_G726, 
424 
sizeof(AVG726Context),

425 
g726_init, 
426 
NULL,

427 
g726_close, 
428 
g726_decode_frame, 
429 
}; 