ffmpeg / libavcodec / g726.c @ 8a01fc47
History  View  Annotate  Download (12 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 library is free software; you can redistribute it and/or

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

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

11 
* version 2 of the License, or (at your option) any later version.

12 
*

13 
* This library is distributed in the hope that it will be useful,

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

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

16 
* Lesser General Public License for more details.

17 
*

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

19 
* License along with this library; if not, write to the Free Software

20 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 021111307 USA

21 
*/

22 
#include <limits.h> 
23 
#include "avcodec.h" 
24 
#include "common.h" 
25  
26 
/**

27 
* G.726 11bit float.

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

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

30 
* instead of simply using 32bit integer arithmetic.

31 
*/

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

41 
if (f>sign)

42 
i = i; 
43 
f>exp = av_log2_16bit(i) + !!i; 
44 
f>mant = i? (i<<6) >> f>exp :

45 
1<<5; 
46 
return f;

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

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

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

74 

75 
Float11 sr[2]; /**< prev. reconstructed samples */ 
76 
Float11 dq[6]; /**< prev. difference */ 
77 
int a[2]; /**< second order predictor coeffs */ 
78 
int b[6]; /**< sixth order predictor coeffs */ 
79 
int pk[2]; /**< signs of prev. 2 sez + dq */ 
80 

81 
int ap; /**< scale factor control */ 
82 
int yu; /**< fast scale factor */ 
83 
int yl; /**< slow scale factor */ 
84 
int dms; /**< short average magnitude of F[i] */ 
85 
int dml; /**< long average magnitude of F[i] */ 
86 
int td; /**< tone detect */ 
87  
88 
int se; /**< estimated signal for the next iteration */ 
89 
int sez; /**< estimated second order prediction */ 
90 
int y; /**< quantizer scaling factor for the next iteration */ 
91 
} G726Context; 
92  
93 
static int quant_tbl16[] = /**< 16kbit/s 2bits per sample */ 
94 
{ 260, INT_MAX };

95 
static int iquant_tbl16[] = 
96 
{ 116, 365, 365, 116 }; 
97 
static int W_tbl16[] = 
98 
{ 22, 439, 439, 22 }; 
99 
static int F_tbl16[] = 
100 
{ 0, 7, 7, 0 }; 
101 

102 
static int quant_tbl24[] = /**< 24kbit/s 3bits per sample */ 
103 
{ 7, 217, 330, INT_MAX }; 
104 
static int iquant_tbl24[] = 
105 
{ INT_MIN, 135, 273, 373, 373, 273, 135, INT_MIN }; 
106 
static int W_tbl24[] = 
107 
{ 4, 30, 137, 582, 582, 137, 30, 4 }; 
108 
static int F_tbl24[] = 
109 
{ 0, 1, 2, 7, 7, 2, 1, 0 }; 
110 

111 
static int quant_tbl32[] = /**< 32kbit/s 4bits per sample */ 
112 
{ 125, 79, 177, 245, 299, 348, 399, INT_MAX }; 
113 
static int iquant_tbl32[] = 
114 
{ INT_MIN, 4, 135, 213, 273, 323, 373, 425, 
115 
425, 373, 323, 273, 213, 135, 4, INT_MIN }; 
116 
static int W_tbl32[] = 
117 
{ 12, 18, 41, 64, 112, 198, 355, 1122, 
118 
1122, 355, 198, 112, 64, 41, 18, 12}; 
119 
static int F_tbl32[] = 
120 
{ 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 }; 
121 

122 
static int quant_tbl40[] = /**< 40kbit/s 5bits per sample */ 
123 
{ 122, 16, 67, 138, 197, 249, 297, 338, 
124 
377, 412, 444, 474, 501, 527, 552, INT_MAX }; 
125 
static int iquant_tbl40[] = 
126 
{ INT_MIN, 66, 28, 104, 169, 224, 274, 318, 
127 
358, 395, 429, 459, 488, 514, 539, 566, 
128 
566, 539, 514, 488, 459, 429, 395, 358, 
129 
318, 274, 224, 169, 104, 28, 66, INT_MIN }; 
130 
static int W_tbl40[] = 
131 
{ 14, 14, 24, 39, 40, 41, 58, 100, 
132 
141, 179, 219, 280, 358, 440, 529, 696, 
133 
696, 529, 440, 358, 280, 219, 179, 141, 
134 
100, 58, 41, 40, 39, 24, 14, 14 }; 
135 
static int F_tbl40[] = 
136 
{ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 6, 
137 
6, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; 
138  
139 
static G726Tables G726Tables_pool[] =

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

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

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

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

144 

145  
146 
/**

147 
* Para 4.2.2 page 18: Adaptive quantizer.

148 
*/

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

152 

153 
sign = i = 0;

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

156 
d = d; 
157 
} 
158 
exp = av_log2_16bit(d); 
159 
dln = ((exp<<7) + (((d<<7)>>exp)&0x7f))  (c>y>>2); 
160 

161 
while (c>tbls>quant[i] < INT_MAX && c>tbls>quant[i] < dln)

162 
++i; 
163 

164 
if (sign)

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

168  
169 
return i;

170 
} 
171  
172 
/**

173 
* Para 4.2.3 page 22: Inverse adaptive quantizer.

174 
*/

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

178 

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

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

188 
Float11 f; 
189 

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

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

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

201 
else

202 
tr = 0;

203 

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

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

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

207 
if (tr) {

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

212 
} else {

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

214 
fa1 = clip((c>a[0]*c>pk[0]*pk0)>>5, 256, 255); 
215 

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

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

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

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

233 
c>dq[0].sign = I >> (c>tbls>bits  1); /* Isn't it crazy ?!?! */ 
234 

235 
/* Update tone detect [I'm not sure 'tr == 0' is really needed] */

236 
c>td = (tr == 0 && c>a[1] < 11776); 
237 

238 
/* Update Ap */

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

242 
c>ap = 256;

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

245 
else

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

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

251 

252 
/* Next iteration for Y */

253 
al = (c>ap >= 256) ? 1<<6 : c>ap >> 2; 
254 
c>y = (c>yl + (c>yu  (c>yl>>6))*al) >> 6; 
255 

256 
/* Next iteration for SE and SEZ */

257 
c>se = 0;

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

260 
c>sez = c>se >> 1;

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

263 
c>se >>= 1;

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

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

275 
c>a[i] = 0;

276 
c>pk[i] = 1;

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

280 
c>b[i] = 0;

281 
} 
282 
c>ap = 0;

283 
c>dms = 0;

284 
c>dml = 0;

285 
c>yu = 544;

286 
c>yl = 34816;

287 
c>td = 0;

288  
289 
c>se = 0;

290 
c>sez = 0;

291 
c>y = 544;

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

297 
{ 
298 
return g726_iterate(c, i);

299 
} 
300  
301 
static int16_t g726_encode(G726Context* c, int16_t sig)

302 
{ 
303 
uint8_t i; 
304 

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

308 
} 
309  
310 
/* Interfacing to the libavcodec */

311  
312 
typedef struct AVG726Context { 
313 
G726Context c; 
314 
int bits_left;

315 
int bit_buffer;

316 
int code_size;

317 
} AVG726Context; 
318  
319 
static int g726_init(AVCodecContext * avctx) 
320 
{ 
321 
AVG726Context* c = (AVG726Context*)avctx>priv_data; 
322 

323 
if (avctx>channels != 1  
324 
(avctx>bit_rate != 16000 && avctx>bit_rate != 24000 && 
325 
avctx>bit_rate != 32000 && avctx>bit_rate != 40000)) { 
326 
av_log(avctx, AV_LOG_ERROR, "G726: unsupported audio format\n");

327 
return 1; 
328 
} 
329 
if (avctx>sample_rate != 8000 && avctx>strict_std_compliance>=0) { 
330 
av_log(avctx, AV_LOG_ERROR, "G726: unsupported audio format\n");

331 
return 1; 
332 
} 
333 
g726_reset(&c>c, avctx>bit_rate); 
334 
c>code_size = c>c.tbls>bits; 
335 
c>bit_buffer = 0;

336 
c>bits_left = 0;

337  
338 
avctx>coded_frame = avcodec_alloc_frame(); 
339 
if (!avctx>coded_frame)

340 
return ENOMEM;

341 
avctx>coded_frame>key_frame = 1;

342  
343 
return 0; 
344 
} 
345  
346 
static int g726_close(AVCodecContext *avctx) 
347 
{ 
348 
av_freep(&avctx>coded_frame); 
349 
return 0; 
350 
} 
351  
352 
static int g726_encode_frame(AVCodecContext *avctx, 
353 
uint8_t *dst, int buf_size, void *data) 
354 
{ 
355 
AVG726Context *c = avctx>priv_data; 
356 
short *samples = data;

357 
PutBitContext pb; 
358  
359 
init_put_bits(&pb, dst, 1024*1024); 
360  
361 
for (; buf_size; buf_size)

362 
put_bits(&pb, c>code_size, g726_encode(&c>c, *samples++)); 
363  
364 
flush_put_bits(&pb); 
365  
366 
return put_bits_count(&pb)>>3; 
367 
} 
368  
369 
static int g726_decode_frame(AVCodecContext *avctx, 
370 
void *data, int *data_size, 
371 
uint8_t *buf, int buf_size)

372 
{ 
373 
AVG726Context *c = avctx>priv_data; 
374 
short *samples = data;

375 
uint8_t code; 
376 
uint8_t mask; 
377 
GetBitContext gb; 
378 

379 
if (!buf_size)

380 
goto out;

381 

382 
mask = (1<<c>code_size)  1; 
383 
init_get_bits(&gb, buf, buf_size * 8);

384 
if (c>bits_left) {

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

386 
code = (c>bit_buffer << s)  get_bits(&gb, s); 
387 
*samples++ = g726_decode(&c>c, code & mask); 
388 
} 
389 

390 
while (get_bits_count(&gb) + c>code_size <= buf_size*8) 
391 
*samples++ = g726_decode(&c>c, get_bits(&gb, c>code_size) & mask); 
392 

393 
c>bits_left = buf_size*8  get_bits_count(&gb);

394 
c>bit_buffer = get_bits(&gb, c>bits_left); 
395 

396 
out:

397 
*data_size = (uint8_t*)samples  (uint8_t*)data; 
398 
return buf_size;

399 
} 
400  
401 
#ifdef CONFIG_ENCODERS

402 
AVCodec adpcm_g726_encoder = { 
403 
"g726",

404 
CODEC_TYPE_AUDIO, 
405 
CODEC_ID_ADPCM_G726, 
406 
sizeof(AVG726Context),

407 
g726_init, 
408 
g726_encode_frame, 
409 
g726_close, 
410 
NULL,

411 
}; 
412 
#endif //CONFIG_ENCODERS 
413  
414 
AVCodec adpcm_g726_decoder = { 
415 
"g726",

416 
CODEC_TYPE_AUDIO, 
417 
CODEC_ID_ADPCM_G726, 
418 
sizeof(AVG726Context),

419 
g726_init, 
420 
NULL,

421 
g726_close, 
422 
g726_decode_frame, 
423 
}; 