ffmpeg / libavcodec / g726.c @ 2029f312
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 "bitstream.h" 
27  
28 
/**

29 
* G.726 11bit float.

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

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

32 
* instead of simply using 32bit integer arithmetic.

33 
*/

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

43 
if (f>sign)

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

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

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

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

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

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

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

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

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

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

145  
146  
147 
/**

148 
* Para 4.2.2 page 18: Adaptive quantizer.

149 
*/

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

153  
154 
sign = i = 0;

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

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

163 
++i; 
164  
165 
if (sign)

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

169  
170 
return i;

171 
} 
172  
173 
/**

174 
* Para 4.2.3 page 22: Inverse adaptive quantizer.

175 
*/

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

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

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

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

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

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

202 
else

203 
tr = 0;

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

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

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

208 
if (tr) {

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

213 
} else {

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

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

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

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

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

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

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

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

243 
c>ap = 256;

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

246 
else

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

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

252  
253 
/* Next iteration for Y */

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

258 
c>se = 0;

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

261 
c>sez = c>se >> 1;

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

264 
c>se >>= 1;

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

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

276 
c>a[i] = 0;

277 
c>pk[i] = 1;

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

281 
c>b[i] = 0;

282 
} 
283 
c>ap = 0;

284 
c>dms = 0;

285 
c>dml = 0;

286 
c>yu = 544;

287 
c>yl = 34816;

288 
c>td = 0;

289  
290 
c>se = 0;

291 
c>sez = 0;

292 
c>y = 544;

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

298 
{ 
299 
return g726_iterate(c, i);

300 
} 
301  
302 
#ifdef CONFIG_ENCODERS

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

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

310 
} 
311 
#endif

312  
313 
/* Interfacing to the libavcodec */

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

318 
int bit_buffer;

319 
int code_size;

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

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

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

339 
c>bits_left = 0;

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

343 
return AVERROR(ENOMEM);

344 
avctx>coded_frame>key_frame = 1;

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

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

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

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

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

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

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

385 
goto out;

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

389 
if (c>bits_left) {

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

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

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

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

404 
} 
405  
406 
#ifdef CONFIG_ENCODERS

407 
AVCodec adpcm_g726_encoder = { 
408 
"g726",

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

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

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

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

424 
g726_init, 
425 
NULL,

426 
g726_close, 
427 
g726_decode_frame, 
428 
}; 