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 02110-1301 USA 23 */ 24 25#include "config_components.h" 26 27#include <limits.h> 28 29#include "libavutil/channel_layout.h" 30#include "libavutil/opt.h" 31#include "avcodec.h" 32#include "codec_internal.h" 33#include "encode.h" 34#include "internal.h" 35#include "get_bits.h" 36#include "put_bits.h" 37 38/** 39 * G.726 11-bit float. 40 * G.726 Standard uses rather odd 11-bit floating point arithmetic for 41 * numerous occasions. It's a mystery to me why they did it this way 42 * instead of simply using 32-bit integer arithmetic. 43 */ 44typedef struct Float11 { 45 uint8_t sign; /**< 1 bit sign */ 46 uint8_t exp; /**< 4 bits exponent */ 47 uint8_t mant; /**< 6 bits mantissa */ 48} Float11; 49 50static inline Float11* i2f(int i, Float11* f) 51{ 52 f->sign = (i < 0); 53 if (f->sign) 54 i = -i; 55 f->exp = av_log2_16bit(i) + !!i; 56 f->mant = i? (i<<6) >> f->exp : 1<<5; 57 return f; 58} 59 60static inline int16_t mult(Float11* f1, Float11* f2) 61{ 62 int res, exp; 63 64 exp = f1->exp + f2->exp; 65 res = (((f1->mant * f2->mant) + 0x30) >> 4); 66 res = exp > 19 ? res << (exp - 19) : res >> (19 - exp); 67 return (f1->sign ^ f2->sign) ? -res : res; 68} 69 70static inline int sgn(int value) 71{ 72 return (value < 0) ? -1 : 1; 73} 74 75typedef struct G726Tables { 76 const int* quant; /**< quantization table */ 77 const int16_t* iquant; /**< inverse quantization table */ 78 const int16_t* W; /**< special table #1 ;-) */ 79 const uint8_t* F; /**< special table #2 */ 80} G726Tables; 81 82typedef struct G726Context { 83 AVClass *class; 84 G726Tables tbls; /**< static tables needed for computation */ 85 86 Float11 sr[2]; /**< prev. reconstructed samples */ 87 Float11 dq[6]; /**< prev. difference */ 88 int a[2]; /**< second order predictor coeffs */ 89 int b[6]; /**< sixth order predictor coeffs */ 90 int pk[2]; /**< signs of prev. 2 sez + dq */ 91 92 int ap; /**< scale factor control */ 93 int yu; /**< fast scale factor */ 94 int yl; /**< slow scale factor */ 95 int dms; /**< short average magnitude of F[i] */ 96 int dml; /**< long average magnitude of F[i] */ 97 int td; /**< tone detect */ 98 99 int se; /**< estimated signal for the next iteration */ 100 int sez; /**< estimated second order prediction */ 101 int y; /**< quantizer scaling factor for the next iteration */ 102 int code_size; 103 int little_endian; /**< little-endian bitstream as used in aiff and Sun AU */ 104} G726Context; 105 106static const int quant_tbl16[] = /**< 16kbit/s 2 bits per sample */ 107 { 260, INT_MAX }; 108static const int16_t iquant_tbl16[] = 109 { 116, 365, 365, 116 }; 110static const int16_t W_tbl16[] = 111 { -22, 439, 439, -22 }; 112static const uint8_t F_tbl16[] = 113 { 0, 7, 7, 0 }; 114 115static const int quant_tbl24[] = /**< 24kbit/s 3 bits per sample */ 116 { 7, 217, 330, INT_MAX }; 117static const int16_t iquant_tbl24[] = 118 { INT16_MIN, 135, 273, 373, 373, 273, 135, INT16_MIN }; 119static const int16_t W_tbl24[] = 120 { -4, 30, 137, 582, 582, 137, 30, -4 }; 121static const uint8_t F_tbl24[] = 122 { 0, 1, 2, 7, 7, 2, 1, 0 }; 123 124static const int quant_tbl32[] = /**< 32kbit/s 4 bits per sample */ 125 { -125, 79, 177, 245, 299, 348, 399, INT_MAX }; 126static const int16_t iquant_tbl32[] = 127 { INT16_MIN, 4, 135, 213, 273, 323, 373, 425, 128 425, 373, 323, 273, 213, 135, 4, INT16_MIN }; 129static const int16_t W_tbl32[] = 130 { -12, 18, 41, 64, 112, 198, 355, 1122, 131 1122, 355, 198, 112, 64, 41, 18, -12}; 132static const uint8_t F_tbl32[] = 133 { 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 }; 134 135static const int quant_tbl40[] = /**< 40kbit/s 5 bits per sample */ 136 { -122, -16, 67, 138, 197, 249, 297, 338, 137 377, 412, 444, 474, 501, 527, 552, INT_MAX }; 138static const int16_t iquant_tbl40[] = 139 { INT16_MIN, -66, 28, 104, 169, 224, 274, 318, 140 358, 395, 429, 459, 488, 514, 539, 566, 141 566, 539, 514, 488, 459, 429, 395, 358, 142 318, 274, 224, 169, 104, 28, -66, INT16_MIN }; 143static const int16_t W_tbl40[] = 144 { 14, 14, 24, 39, 40, 41, 58, 100, 145 141, 179, 219, 280, 358, 440, 529, 696, 146 696, 529, 440, 358, 280, 219, 179, 141, 147 100, 58, 41, 40, 39, 24, 14, 14 }; 148static const uint8_t F_tbl40[] = 149 { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 6, 150 6, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; 151 152static const G726Tables G726Tables_pool[] = 153 {{ quant_tbl16, iquant_tbl16, W_tbl16, F_tbl16 }, 154 { quant_tbl24, iquant_tbl24, W_tbl24, F_tbl24 }, 155 { quant_tbl32, iquant_tbl32, W_tbl32, F_tbl32 }, 156 { quant_tbl40, iquant_tbl40, W_tbl40, F_tbl40 }}; 157 158 159/** 160 * Paragraph 4.2.2 page 18: Adaptive quantizer. 161 */ 162static inline uint8_t quant(G726Context* c, int d) 163{ 164 int sign, exp, i, dln; 165 166 sign = i = 0; 167 if (d < 0) { 168 sign = 1; 169 d = -d; 170 } 171 exp = av_log2_16bit(d); 172 dln = ((exp<<7) + (((d<<7)>>exp)&0x7f)) - (c->y>>2); 173 174 while (c->tbls.quant[i] < INT_MAX && c->tbls.quant[i] < dln) 175 ++i; 176 177 if (sign) 178 i = ~i; 179 if (c->code_size != 2 && i == 0) /* I'm not sure this is a good idea */ 180 i = 0xff; 181 182 return i; 183} 184 185/** 186 * Paragraph 4.2.3 page 22: Inverse adaptive quantizer. 187 */ 188static inline int16_t inverse_quant(G726Context* c, int i) 189{ 190 int dql, dex, dqt; 191 192 dql = c->tbls.iquant[i] + (c->y >> 2); 193 dex = (dql>>7) & 0xf; /* 4-bit exponent */ 194 dqt = (1<<7) + (dql & 0x7f); /* log2 -> linear */ 195 return (dql < 0) ? 0 : ((dqt<<dex) >> 7); 196} 197 198static int16_t g726_decode(G726Context* c, int I) 199{ 200 int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0; 201 Float11 f; 202 int I_sig= I >> (c->code_size - 1); 203 204 dq = inverse_quant(c, I); 205 206 /* Transition detect */ 207 ylint = (c->yl >> 15); 208 ylfrac = (c->yl >> 10) & 0x1f; 209 thr2 = (ylint > 9) ? 0x1f << 10 : (0x20 + ylfrac) << ylint; 210 tr= (c->td == 1 && dq > ((3*thr2)>>2)); 211 212 if (I_sig) /* get the sign */ 213 dq = -dq; 214 re_signal = (int16_t)(c->se + dq); 215 216 /* Update second order predictor coefficient A2 and A1 */ 217 pk0 = (c->sez + dq) ? sgn(c->sez + dq) : 0; 218 dq0 = dq ? sgn(dq) : 0; 219 if (tr) { 220 c->a[0] = 0; 221 c->a[1] = 0; 222 for (i=0; i<6; i++) 223 c->b[i] = 0; 224 } else { 225 /* This is a bit crazy, but it really is +255 not +256 */ 226 fa1 = av_clip_intp2((-c->a[0]*c->pk[0]*pk0)>>5, 8); 227 228 c->a[1] += 128*pk0*c->pk[1] + fa1 - (c->a[1]>>7); 229 c->a[1] = av_clip(c->a[1], -12288, 12288); 230 c->a[0] += 64*3*pk0*c->pk[0] - (c->a[0] >> 8); 231 c->a[0] = av_clip(c->a[0], -(15360 - c->a[1]), 15360 - c->a[1]); 232 233 for (i=0; i<6; i++) 234 c->b[i] += 128*dq0*sgn(-c->dq[i].sign) - (c->b[i]>>8); 235 } 236 237 /* Update Dq and Sr and Pk */ 238 c->pk[1] = c->pk[0]; 239 c->pk[0] = pk0 ? pk0 : 1; 240 c->sr[1] = c->sr[0]; 241 i2f(re_signal, &c->sr[0]); 242 for (i=5; i>0; i--) 243 c->dq[i] = c->dq[i-1]; 244 i2f(dq, &c->dq[0]); 245 c->dq[0].sign = I_sig; /* Isn't it crazy ?!?! */ 246 247 c->td = c->a[1] < -11776; 248 249 /* Update Ap */ 250 c->dms += (c->tbls.F[I]<<4) + ((- c->dms) >> 5); 251 c->dml += (c->tbls.F[I]<<4) + ((- c->dml) >> 7); 252 if (tr) 253 c->ap = 256; 254 else { 255 c->ap += (-c->ap) >> 4; 256 if (c->y <= 1535 || c->td || abs((c->dms << 2) - c->dml) >= (c->dml >> 3)) 257 c->ap += 0x20; 258 } 259 260 /* Update Yu and Yl */ 261 c->yu = av_clip(c->y + c->tbls.W[I] + ((-c->y)>>5), 544, 5120); 262 c->yl += c->yu + ((-c->yl)>>6); 263 264 /* Next iteration for Y */ 265 al = (c->ap >= 256) ? 1<<6 : c->ap >> 2; 266 c->y = (c->yl + (c->yu - (c->yl>>6))*al) >> 6; 267 268 /* Next iteration for SE and SEZ */ 269 c->se = 0; 270 for (i=0; i<6; i++) 271 c->se += mult(i2f(c->b[i] >> 2, &f), &c->dq[i]); 272 c->sez = c->se >> 1; 273 for (i=0; i<2; i++) 274 c->se += mult(i2f(c->a[i] >> 2, &f), &c->sr[i]); 275 c->se >>= 1; 276 277 return av_clip(re_signal * 4, -0xffff, 0xffff); 278} 279 280static av_cold int g726_reset(G726Context *c) 281{ 282 int i; 283 284 c->tbls = G726Tables_pool[c->code_size - 2]; 285 for (i=0; i<2; i++) { 286 c->sr[i].mant = 1<<5; 287 c->pk[i] = 1; 288 } 289 for (i=0; i<6; i++) { 290 c->dq[i].mant = 1<<5; 291 } 292 c->yu = 544; 293 c->yl = 34816; 294 295 c->y = 544; 296 297 return 0; 298} 299 300#if CONFIG_ADPCM_G726_ENCODER || CONFIG_ADPCM_G726LE_ENCODER 301static int16_t g726_encode(G726Context* c, int16_t sig) 302{ 303 uint8_t i; 304 305 i = av_mod_uintp2(quant(c, sig/4 - c->se), c->code_size); 306 g726_decode(c, i); 307 return i; 308} 309 310/* Interfacing to the libavcodec */ 311 312static av_cold int g726_encode_init(AVCodecContext *avctx) 313{ 314 G726Context* c = avctx->priv_data; 315 316 c->little_endian = !strcmp(avctx->codec->name, "g726le"); 317 318 if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL && 319 avctx->sample_rate != 8000) { 320 av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not " 321 "allowed when the compliance level is higher than unofficial. " 322 "Resample or reduce the compliance level.\n"); 323 return AVERROR(EINVAL); 324 } 325 if (avctx->sample_rate <= 0) { 326 av_log(avctx, AV_LOG_ERROR, "Invalid sample rate %d\n", 327 avctx->sample_rate); 328 return AVERROR(EINVAL); 329 } 330 331 if (avctx->ch_layout.nb_channels != 1) { 332 av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n"); 333 return AVERROR(EINVAL); 334 } 335 336 if (avctx->bit_rate) 337 c->code_size = (avctx->bit_rate + avctx->sample_rate/2) / avctx->sample_rate; 338 339 c->code_size = av_clip(c->code_size, 2, 5); 340 avctx->bit_rate = c->code_size * avctx->sample_rate; 341 avctx->bits_per_coded_sample = c->code_size; 342 343 g726_reset(c); 344 345 /* select a frame size that will end on a byte boundary and have a size of 346 approximately 1024 bytes */ 347 avctx->frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[c->code_size - 2]; 348 349 return 0; 350} 351 352static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, 353 const AVFrame *frame, int *got_packet_ptr) 354{ 355 G726Context *c = avctx->priv_data; 356 const int16_t *samples = (const int16_t *)frame->data[0]; 357 PutBitContext pb; 358 int i, ret, out_size; 359 360 out_size = (frame->nb_samples * c->code_size + 7) / 8; 361 if ((ret = ff_get_encode_buffer(avctx, avpkt, out_size, 0)) < 0) 362 return ret; 363 init_put_bits(&pb, avpkt->data, avpkt->size); 364 365 for (i = 0; i < frame->nb_samples; i++) 366 if (c->little_endian) { 367 put_bits_le(&pb, c->code_size, g726_encode(c, *samples++)); 368 } else { 369 put_bits(&pb, c->code_size, g726_encode(c, *samples++)); 370 } 371 372 if (c->little_endian) { 373 flush_put_bits_le(&pb); 374 } else { 375 flush_put_bits(&pb); 376 } 377 378 *got_packet_ptr = 1; 379 return 0; 380} 381 382#define OFFSET(x) offsetof(G726Context, x) 383#define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 384static const AVOption options[] = { 385 { "code_size", "Bits per code", OFFSET(code_size), AV_OPT_TYPE_INT, { .i64 = 4 }, 2, 5, AE }, 386 { NULL }, 387}; 388 389static const AVClass g726_class = { 390 .class_name = "g726", 391 .item_name = av_default_item_name, 392 .option = options, 393 .version = LIBAVUTIL_VERSION_INT, 394}; 395 396static const FFCodecDefault defaults[] = { 397 { "b", "0" }, 398 { NULL }, 399}; 400#endif 401 402#if CONFIG_ADPCM_G726_ENCODER 403const FFCodec ff_adpcm_g726_encoder = { 404 .p.name = "g726", 405 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"), 406 .p.type = AVMEDIA_TYPE_AUDIO, 407 .p.id = AV_CODEC_ID_ADPCM_G726, 408 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME, 409 .priv_data_size = sizeof(G726Context), 410 .init = g726_encode_init, 411 FF_CODEC_ENCODE_CB(g726_encode_frame), 412 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, 413 AV_SAMPLE_FMT_NONE }, 414 .p.priv_class = &g726_class, 415 .defaults = defaults, 416 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 417}; 418#endif 419 420#if CONFIG_ADPCM_G726LE_ENCODER 421const FFCodec ff_adpcm_g726le_encoder = { 422 .p.name = "g726le", 423 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 little endian ADPCM (\"right-justified\")"), 424 .p.type = AVMEDIA_TYPE_AUDIO, 425 .p.id = AV_CODEC_ID_ADPCM_G726LE, 426 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME, 427 .priv_data_size = sizeof(G726Context), 428 .init = g726_encode_init, 429 FF_CODEC_ENCODE_CB(g726_encode_frame), 430 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, 431 AV_SAMPLE_FMT_NONE }, 432 .p.priv_class = &g726_class, 433 .defaults = defaults, 434 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 435}; 436#endif 437 438#if CONFIG_ADPCM_G726_DECODER || CONFIG_ADPCM_G726LE_DECODER 439static av_cold int g726_decode_init(AVCodecContext *avctx) 440{ 441 G726Context* c = avctx->priv_data; 442 443 if (avctx->ch_layout.nb_channels > 1){ 444 avpriv_request_sample(avctx, "Decoding more than one channel"); 445 return AVERROR_PATCHWELCOME; 446 } 447 av_channel_layout_uninit(&avctx->ch_layout); 448 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; 449 450 c->little_endian = !strcmp(avctx->codec->name, "g726le"); 451 452 c->code_size = avctx->bits_per_coded_sample; 453 if (c->code_size < 2 || c->code_size > 5) { 454 av_log(avctx, AV_LOG_ERROR, "Invalid number of bits %d\n", c->code_size); 455 return AVERROR(EINVAL); 456 } 457 g726_reset(c); 458 459 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 460 461 return 0; 462} 463 464static int g726_decode_frame(AVCodecContext *avctx, AVFrame *frame, 465 int *got_frame_ptr, AVPacket *avpkt) 466{ 467 const uint8_t *buf = avpkt->data; 468 int buf_size = avpkt->size; 469 G726Context *c = avctx->priv_data; 470 int16_t *samples; 471 GetBitContext gb; 472 int out_samples, ret; 473 474 out_samples = buf_size * 8 / c->code_size; 475 476 /* get output buffer */ 477 frame->nb_samples = out_samples; 478 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 479 return ret; 480 samples = (int16_t *)frame->data[0]; 481 482 init_get_bits(&gb, buf, buf_size * 8); 483 484 while (out_samples--) 485 *samples++ = g726_decode(c, c->little_endian ? 486 get_bits_le(&gb, c->code_size) : 487 get_bits(&gb, c->code_size)); 488 489 if (get_bits_left(&gb) > 0) 490 av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n"); 491 492 *got_frame_ptr = 1; 493 494 return buf_size; 495} 496 497static void g726_decode_flush(AVCodecContext *avctx) 498{ 499 G726Context *c = avctx->priv_data; 500 g726_reset(c); 501} 502#endif 503 504#if CONFIG_ADPCM_G726_DECODER 505const FFCodec ff_adpcm_g726_decoder = { 506 .p.name = "g726", 507 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"), 508 .p.type = AVMEDIA_TYPE_AUDIO, 509 .p.id = AV_CODEC_ID_ADPCM_G726, 510 .priv_data_size = sizeof(G726Context), 511 .init = g726_decode_init, 512 FF_CODEC_DECODE_CB(g726_decode_frame), 513 .flush = g726_decode_flush, 514 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, 515 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 516}; 517#endif 518 519#if CONFIG_ADPCM_G726LE_DECODER 520const FFCodec ff_adpcm_g726le_decoder = { 521 .p.name = "g726le", 522 .p.type = AVMEDIA_TYPE_AUDIO, 523 .p.id = AV_CODEC_ID_ADPCM_G726LE, 524 .priv_data_size = sizeof(G726Context), 525 .init = g726_decode_init, 526 FF_CODEC_DECODE_CB(g726_decode_frame), 527 .flush = g726_decode_flush, 528 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, 529 .p.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM little-endian"), 530 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 531}; 532#endif 533