ffmpeg / libavcodec / g726.c @ d36beb3f
History  View  Annotate  Download (12.4 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 "get_bits.h" 
27 
#include "put_bits.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 
uint8_t sign; /**< 1bit sign */

37 
uint8_t exp; /**< 4bit exponent */

38 
uint8_t mant; /**< 6bit mantissa */

39 
} Float11; 
40  
41 
static inline Float11* i2f(int 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); 
57 
res = exp > 19 ? res << (exp  19) : res >> (19  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 
const int* quant; /**< quantization table */ 
68 
const int16_t* iquant; /**< inverse quantization table */ 
69 
const int16_t* W; /**< special table #1 ;) */ 
70 
const uint8_t* 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 
int code_size;

93 
} G726Context; 
94  
95 
static const int quant_tbl16[] = /**< 16kbit/s 2bits per sample */ 
96 
{ 260, INT_MAX };

97 
static const int16_t iquant_tbl16[] = 
98 
{ 116, 365, 365, 116 }; 
99 
static const int16_t W_tbl16[] = 
100 
{ 22, 439, 439, 22 }; 
101 
static const uint8_t F_tbl16[] = 
102 
{ 0, 7, 7, 0 }; 
103  
104 
static const int quant_tbl24[] = /**< 24kbit/s 3bits per sample */ 
105 
{ 7, 217, 330, INT_MAX }; 
106 
static const int16_t iquant_tbl24[] = 
107 
{ INT16_MIN, 135, 273, 373, 373, 273, 135, INT16_MIN }; 
108 
static const int16_t W_tbl24[] = 
109 
{ 4, 30, 137, 582, 582, 137, 30, 4 }; 
110 
static const uint8_t F_tbl24[] = 
111 
{ 0, 1, 2, 7, 7, 2, 1, 0 }; 
112  
113 
static const int quant_tbl32[] = /**< 32kbit/s 4bits per sample */ 
114 
{ 125, 79, 177, 245, 299, 348, 399, INT_MAX }; 
115 
static const int16_t iquant_tbl32[] = 
116 
{ INT16_MIN, 4, 135, 213, 273, 323, 373, 425, 
117 
425, 373, 323, 273, 213, 135, 4, INT16_MIN }; 
118 
static const int16_t W_tbl32[] = 
119 
{ 12, 18, 41, 64, 112, 198, 355, 1122, 
120 
1122, 355, 198, 112, 64, 41, 18, 12}; 
121 
static const uint8_t F_tbl32[] = 
122 
{ 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 }; 
123  
124 
static const 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 const int16_t iquant_tbl40[] = 
128 
{ INT16_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, INT16_MIN }; 
132 
static const int16_t 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 const uint8_t 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 const G726Tables G726Tables_pool[] = 
142 
{{ quant_tbl16, iquant_tbl16, W_tbl16, F_tbl16 }, 
143 
{ quant_tbl24, iquant_tbl24, W_tbl24, F_tbl24 }, 
144 
{ quant_tbl32, iquant_tbl32, W_tbl32, F_tbl32 }, 
145 
{ 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>code_size != 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<<dex) >> 7); 
185 
} 
186  
187 
static int16_t g726_decode(G726Context* c, int I) 
188 
{ 
189 
int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0;

190 
Float11 f; 
191 
int I_sig= I >> (c>code_size  1); 
192  
193 
dq = inverse_quant(c, I); 
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 
tr= (c>td == 1 && dq > ((3*thr2)>>2)); 
200  
201 
if (I_sig) /* get the sign */ 
202 
dq = dq; 
203 
re_signal = c>se + dq; 
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_sig; /* Isn't it crazy ?!?! */ 
235  
236 
c>td = c>a[1] < 11776; 
237  
238 
/* Update Ap */

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

242 
c>ap = 256;

243 
else {

244 
c>ap += (c>ap) >> 4;

245 
if (c>y <= 1535  c>td  abs((c>dms << 2)  c>dml) >= (c>dml >> 3)) 
246 
c>ap += 0x20;

247 
} 
248  
249 
/* Update Yu and Yl */

250 
c>yu = av_clip(c>y + c>tbls.W[I] + ((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 av_cold int g726_reset(G726Context* c, int index) 
270 
{ 
271 
int i;

272  
273 
c>tbls = G726Tables_pool[index]; 
274 
for (i=0; i<2; i++) { 
275 
c>sr[i].mant = 1<<5; 
276 
c>pk[i] = 1;

277 
} 
278 
for (i=0; i<6; i++) { 
279 
c>dq[i].mant = 1<<5; 
280 
} 
281 
c>yu = 544;

282 
c>yl = 34816;

283  
284 
c>y = 544;

285  
286 
return 0; 
287 
} 
288  
289 
#if CONFIG_ADPCM_G726_ENCODER

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

291 
{ 
292 
uint8_t i; 
293  
294 
i = quant(c, sig/4  c>se) & ((1<<c>code_size)  1); 
295 
g726_decode(c, i); 
296 
return i;

297 
} 
298 
#endif

299  
300 
/* Interfacing to the libavcodec */

301  
302 
static av_cold int g726_init(AVCodecContext * avctx) 
303 
{ 
304 
G726Context* c = avctx>priv_data; 
305 
unsigned int index; 
306  
307 
if (avctx>sample_rate <= 0) { 
308 
av_log(avctx, AV_LOG_ERROR, "Samplerate is invalid\n");

309 
return 1; 
310 
} 
311  
312 
index = (avctx>bit_rate + avctx>sample_rate/2) / avctx>sample_rate  2; 
313  
314 
if (avctx>bit_rate % avctx>sample_rate && avctx>codec>encode) {

315 
av_log(avctx, AV_LOG_ERROR, "Bitrate  Samplerate combination is invalid\n");

316 
return 1; 
317 
} 
318 
if(avctx>channels != 1){ 
319 
av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n");

320 
return 1; 
321 
} 
322 
if(index>3){ 
323 
av_log(avctx, AV_LOG_ERROR, "Unsupported number of bits %d\n", index+2); 
324 
return 1; 
325 
} 
326 
g726_reset(c, index); 
327 
c>code_size = index+2;

328  
329 
avctx>coded_frame = avcodec_alloc_frame(); 
330 
if (!avctx>coded_frame)

331 
return AVERROR(ENOMEM);

332 
avctx>coded_frame>key_frame = 1;

333  
334 
if (avctx>codec>decode)

335 
avctx>sample_fmt = AV_SAMPLE_FMT_S16; 
336  
337 
/* select a frame size that will end on a byte boundary and have a size of

338 
approximately 1024 bytes */

339 
if (avctx>codec>encode)

340 
avctx>frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[index]; 
341  
342 
return 0; 
343 
} 
344  
345 
static av_cold int g726_close(AVCodecContext *avctx) 
346 
{ 
347 
av_freep(&avctx>coded_frame); 
348 
return 0; 
349 
} 
350  
351 
#if CONFIG_ADPCM_G726_ENCODER

352 
static int g726_encode_frame(AVCodecContext *avctx, 
353 
uint8_t *dst, int buf_size, void *data) 
354 
{ 
355 
G726Context *c = avctx>priv_data; 
356 
const short *samples = data; 
357 
PutBitContext pb; 
358 
int i;

359  
360 
init_put_bits(&pb, dst, 1024*1024); 
361  
362 
for (i = 0; i < avctx>frame_size; i++) 
363 
put_bits(&pb, c>code_size, g726_encode(c, *samples++)); 
364  
365 
flush_put_bits(&pb); 
366  
367 
return put_bits_count(&pb)>>3; 
368 
} 
369 
#endif

370  
371 
static int g726_decode_frame(AVCodecContext *avctx, 
372 
void *data, int *data_size, 
373 
AVPacket *avpkt) 
374 
{ 
375 
const uint8_t *buf = avpkt>data;

376 
int buf_size = avpkt>size;

377 
G726Context *c = avctx>priv_data; 
378 
short *samples = data;

379 
GetBitContext gb; 
380  
381 
init_get_bits(&gb, buf, buf_size * 8);

382  
383 
while (get_bits_count(&gb) + c>code_size <= buf_size*8) 
384 
*samples++ = g726_decode(c, get_bits(&gb, c>code_size)); 
385  
386 
if(buf_size*8 != get_bits_count(&gb)) 
387 
av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");

388  
389 
*data_size = (uint8_t*)samples  (uint8_t*)data; 
390 
return buf_size;

391 
} 
392  
393 
#if CONFIG_ADPCM_G726_ENCODER

394 
AVCodec ff_adpcm_g726_encoder = { 
395 
"g726",

396 
AVMEDIA_TYPE_AUDIO, 
397 
CODEC_ID_ADPCM_G726, 
398 
sizeof(G726Context),

399 
g726_init, 
400 
g726_encode_frame, 
401 
g726_close, 
402 
NULL,

403 
.capabilities = CODEC_CAP_SMALL_LAST_FRAME, 
404 
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, 
405 
.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),

406 
}; 
407 
#endif

408  
409 
AVCodec ff_adpcm_g726_decoder = { 
410 
"g726",

411 
AVMEDIA_TYPE_AUDIO, 
412 
CODEC_ID_ADPCM_G726, 
413 
sizeof(G726Context),

414 
g726_init, 
415 
NULL,

416 
g726_close, 
417 
g726_decode_frame, 
418 
.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),

419 
}; 