00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "avcodec.h"
00021 #include "get_bits.h"
00022 #include "put_bits.h"
00023 #include "bytestream.h"
00024 #include "adpcm.h"
00025 #include "adpcm_data.h"
00026 #include "internal.h"
00027
00060
00061 static const int xa_adpcm_table[5][2] = {
00062 { 0, 0 },
00063 { 60, 0 },
00064 { 115, -52 },
00065 { 98, -55 },
00066 { 122, -60 }
00067 };
00068
00069 static const int ea_adpcm_table[] = {
00070 0, 240, 460, 392,
00071 0, 0, -208, -220,
00072 0, 1, 3, 4,
00073 7, 8, 10, 11,
00074 0, -1, -3, -4
00075 };
00076
00077
00078 static const int swf_index_tables[4][16] = {
00079 { -1, 2 },
00080 { -1, -1, 2, 4 },
00081 { -1, -1, -1, -1, 2, 4, 6, 8 },
00082 { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
00083 };
00084
00085
00086
00087 typedef struct ADPCMDecodeContext {
00088 AVFrame frame;
00089 ADPCMChannelStatus status[6];
00090 int vqa_version;
00091 } ADPCMDecodeContext;
00092
00093 static av_cold int adpcm_decode_init(AVCodecContext * avctx)
00094 {
00095 ADPCMDecodeContext *c = avctx->priv_data;
00096 unsigned int min_channels = 1;
00097 unsigned int max_channels = 2;
00098
00099 switch(avctx->codec->id) {
00100 case AV_CODEC_ID_ADPCM_EA:
00101 min_channels = 2;
00102 break;
00103 case AV_CODEC_ID_ADPCM_AFC:
00104 case AV_CODEC_ID_ADPCM_EA_R1:
00105 case AV_CODEC_ID_ADPCM_EA_R2:
00106 case AV_CODEC_ID_ADPCM_EA_R3:
00107 case AV_CODEC_ID_ADPCM_EA_XAS:
00108 case AV_CODEC_ID_ADPCM_THP:
00109 max_channels = 6;
00110 break;
00111 }
00112 if (avctx->channels < min_channels || avctx->channels > max_channels) {
00113 av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
00114 return AVERROR(EINVAL);
00115 }
00116
00117 switch(avctx->codec->id) {
00118 case AV_CODEC_ID_ADPCM_CT:
00119 c->status[0].step = c->status[1].step = 511;
00120 break;
00121 case AV_CODEC_ID_ADPCM_IMA_WAV:
00122 if (avctx->bits_per_coded_sample != 4) {
00123 av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
00124 return -1;
00125 }
00126 break;
00127 case AV_CODEC_ID_ADPCM_IMA_APC:
00128 if (avctx->extradata && avctx->extradata_size >= 8) {
00129 c->status[0].predictor = AV_RL32(avctx->extradata);
00130 c->status[1].predictor = AV_RL32(avctx->extradata + 4);
00131 }
00132 break;
00133 case AV_CODEC_ID_ADPCM_IMA_WS:
00134 if (avctx->extradata && avctx->extradata_size >= 2)
00135 c->vqa_version = AV_RL16(avctx->extradata);
00136 break;
00137 default:
00138 break;
00139 }
00140
00141 switch(avctx->codec->id) {
00142 case AV_CODEC_ID_ADPCM_IMA_QT:
00143 case AV_CODEC_ID_ADPCM_IMA_WAV:
00144 case AV_CODEC_ID_ADPCM_4XM:
00145 case AV_CODEC_ID_ADPCM_XA:
00146 case AV_CODEC_ID_ADPCM_EA_R1:
00147 case AV_CODEC_ID_ADPCM_EA_R2:
00148 case AV_CODEC_ID_ADPCM_EA_R3:
00149 case AV_CODEC_ID_ADPCM_EA_XAS:
00150 case AV_CODEC_ID_ADPCM_THP:
00151 case AV_CODEC_ID_ADPCM_AFC:
00152 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
00153 break;
00154 case AV_CODEC_ID_ADPCM_IMA_WS:
00155 avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
00156 AV_SAMPLE_FMT_S16;
00157 break;
00158 default:
00159 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00160 }
00161
00162 avcodec_get_frame_defaults(&c->frame);
00163 avctx->coded_frame = &c->frame;
00164
00165 return 0;
00166 }
00167
00168 static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
00169 {
00170 int step_index;
00171 int predictor;
00172 int sign, delta, diff, step;
00173
00174 step = ff_adpcm_step_table[c->step_index];
00175 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
00176 step_index = av_clip(step_index, 0, 88);
00177
00178 sign = nibble & 8;
00179 delta = nibble & 7;
00180
00181
00182
00183 diff = ((2 * delta + 1) * step) >> shift;
00184 predictor = c->predictor;
00185 if (sign) predictor -= diff;
00186 else predictor += diff;
00187
00188 c->predictor = av_clip_int16(predictor);
00189 c->step_index = step_index;
00190
00191 return (short)c->predictor;
00192 }
00193
00194 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
00195 {
00196 int step_index;
00197 int predictor;
00198 int diff, step;
00199
00200 step = ff_adpcm_step_table[c->step_index];
00201 step_index = c->step_index + ff_adpcm_index_table[nibble];
00202 step_index = av_clip(step_index, 0, 88);
00203
00204 diff = step >> 3;
00205 if (nibble & 4) diff += step;
00206 if (nibble & 2) diff += step >> 1;
00207 if (nibble & 1) diff += step >> 2;
00208
00209 if (nibble & 8)
00210 predictor = c->predictor - diff;
00211 else
00212 predictor = c->predictor + diff;
00213
00214 c->predictor = av_clip_int16(predictor);
00215 c->step_index = step_index;
00216
00217 return c->predictor;
00218 }
00219
00220 static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
00221 {
00222 int predictor;
00223
00224 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
00225 predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
00226
00227 c->sample2 = c->sample1;
00228 c->sample1 = av_clip_int16(predictor);
00229 c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
00230 if (c->idelta < 16) c->idelta = 16;
00231
00232 return c->sample1;
00233 }
00234
00235 static inline short adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
00236 {
00237 int step_index, predictor, sign, delta, diff, step;
00238
00239 step = ff_adpcm_oki_step_table[c->step_index];
00240 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
00241 step_index = av_clip(step_index, 0, 48);
00242
00243 sign = nibble & 8;
00244 delta = nibble & 7;
00245 diff = ((2 * delta + 1) * step) >> 3;
00246 predictor = c->predictor;
00247 if (sign) predictor -= diff;
00248 else predictor += diff;
00249
00250 c->predictor = av_clip(predictor, -2048, 2047);
00251 c->step_index = step_index;
00252
00253 return c->predictor << 4;
00254 }
00255
00256 static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
00257 {
00258 int sign, delta, diff;
00259 int new_step;
00260
00261 sign = nibble & 8;
00262 delta = nibble & 7;
00263
00264
00265
00266 diff = ((2 * delta + 1) * c->step) >> 3;
00267
00268 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
00269 c->predictor = av_clip_int16(c->predictor);
00270
00271 new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
00272 c->step = av_clip(new_step, 511, 32767);
00273
00274 return (short)c->predictor;
00275 }
00276
00277 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
00278 {
00279 int sign, delta, diff;
00280
00281 sign = nibble & (1<<(size-1));
00282 delta = nibble & ((1<<(size-1))-1);
00283 diff = delta << (7 + c->step + shift);
00284
00285
00286 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
00287
00288
00289 if (delta >= (2*size - 3) && c->step < 3)
00290 c->step++;
00291 else if (delta == 0 && c->step > 0)
00292 c->step--;
00293
00294 return (short) c->predictor;
00295 }
00296
00297 static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
00298 {
00299 if(!c->step) {
00300 c->predictor = 0;
00301 c->step = 127;
00302 }
00303
00304 c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
00305 c->predictor = av_clip_int16(c->predictor);
00306 c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
00307 c->step = av_clip(c->step, 127, 24567);
00308 return c->predictor;
00309 }
00310
00311 static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
00312 const uint8_t *in, ADPCMChannelStatus *left,
00313 ADPCMChannelStatus *right, int channels, int sample_offset)
00314 {
00315 int i, j;
00316 int shift,filter,f0,f1;
00317 int s_1,s_2;
00318 int d,s,t;
00319
00320 out0 += sample_offset;
00321 if (channels == 1)
00322 out1 = out0 + 28;
00323 else
00324 out1 += sample_offset;
00325
00326 for(i=0;i<4;i++) {
00327 shift = 12 - (in[4+i*2] & 15);
00328 filter = in[4+i*2] >> 4;
00329 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
00330 av_log_ask_for_sample(avctx, "unknown XA-ADPCM filter %d\n", filter);
00331 filter=0;
00332 }
00333 f0 = xa_adpcm_table[filter][0];
00334 f1 = xa_adpcm_table[filter][1];
00335
00336 s_1 = left->sample1;
00337 s_2 = left->sample2;
00338
00339 for(j=0;j<28;j++) {
00340 d = in[16+i+j*4];
00341
00342 t = sign_extend(d, 4);
00343 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
00344 s_2 = s_1;
00345 s_1 = av_clip_int16(s);
00346 out0[j] = s_1;
00347 }
00348
00349 if (channels == 2) {
00350 left->sample1 = s_1;
00351 left->sample2 = s_2;
00352 s_1 = right->sample1;
00353 s_2 = right->sample2;
00354 }
00355
00356 shift = 12 - (in[5+i*2] & 15);
00357 filter = in[5+i*2] >> 4;
00358 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
00359 av_log_ask_for_sample(avctx, "unknown XA-ADPCM filter %d\n", filter);
00360 filter=0;
00361 }
00362
00363 f0 = xa_adpcm_table[filter][0];
00364 f1 = xa_adpcm_table[filter][1];
00365
00366 for(j=0;j<28;j++) {
00367 d = in[16+i+j*4];
00368
00369 t = sign_extend(d >> 4, 4);
00370 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
00371 s_2 = s_1;
00372 s_1 = av_clip_int16(s);
00373 out1[j] = s_1;
00374 }
00375
00376 if (channels == 2) {
00377 right->sample1 = s_1;
00378 right->sample2 = s_2;
00379 } else {
00380 left->sample1 = s_1;
00381 left->sample2 = s_2;
00382 }
00383
00384 out0 += 28 * (3 - channels);
00385 out1 += 28 * (3 - channels);
00386 }
00387
00388 return 0;
00389 }
00390
00391 static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
00392 {
00393 ADPCMDecodeContext *c = avctx->priv_data;
00394 GetBitContext gb;
00395 const int *table;
00396 int k0, signmask, nb_bits, count;
00397 int size = buf_size*8;
00398 int i;
00399
00400 init_get_bits(&gb, buf, size);
00401
00402
00403 nb_bits = get_bits(&gb, 2)+2;
00404 table = swf_index_tables[nb_bits-2];
00405 k0 = 1 << (nb_bits-2);
00406 signmask = 1 << (nb_bits-1);
00407
00408 while (get_bits_count(&gb) <= size - 22*avctx->channels) {
00409 for (i = 0; i < avctx->channels; i++) {
00410 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
00411 c->status[i].step_index = get_bits(&gb, 6);
00412 }
00413
00414 for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
00415 int i;
00416
00417 for (i = 0; i < avctx->channels; i++) {
00418
00419 int delta = get_bits(&gb, nb_bits);
00420 int step = ff_adpcm_step_table[c->status[i].step_index];
00421 long vpdiff = 0;
00422 int k = k0;
00423
00424 do {
00425 if (delta & k)
00426 vpdiff += step;
00427 step >>= 1;
00428 k >>= 1;
00429 } while(k);
00430 vpdiff += step;
00431
00432 if (delta & signmask)
00433 c->status[i].predictor -= vpdiff;
00434 else
00435 c->status[i].predictor += vpdiff;
00436
00437 c->status[i].step_index += table[delta & (~signmask)];
00438
00439 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
00440 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
00441
00442 *samples++ = c->status[i].predictor;
00443 }
00444 }
00445 }
00446 }
00447
00457 static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
00458 int buf_size, int *coded_samples)
00459 {
00460 ADPCMDecodeContext *s = avctx->priv_data;
00461 int nb_samples = 0;
00462 int ch = avctx->channels;
00463 int has_coded_samples = 0;
00464 int header_size;
00465
00466 *coded_samples = 0;
00467
00468 if(ch <= 0)
00469 return 0;
00470
00471 switch (avctx->codec->id) {
00472
00473 case AV_CODEC_ID_ADPCM_EA_XAS:
00474 if (buf_size < 76 * ch)
00475 return 0;
00476 nb_samples = 128;
00477 break;
00478 case AV_CODEC_ID_ADPCM_IMA_QT:
00479 if (buf_size < 34 * ch)
00480 return 0;
00481 nb_samples = 64;
00482 break;
00483
00484 case AV_CODEC_ID_ADPCM_CT:
00485 case AV_CODEC_ID_ADPCM_IMA_APC:
00486 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
00487 case AV_CODEC_ID_ADPCM_IMA_OKI:
00488 case AV_CODEC_ID_ADPCM_IMA_WS:
00489 case AV_CODEC_ID_ADPCM_YAMAHA:
00490 nb_samples = buf_size * 2 / ch;
00491 break;
00492 }
00493 if (nb_samples)
00494 return nb_samples;
00495
00496
00497 header_size = 0;
00498 switch (avctx->codec->id) {
00499 case AV_CODEC_ID_ADPCM_4XM:
00500 case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
00501 case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;
00502 case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break;
00503 }
00504 if (header_size > 0)
00505 return (buf_size - header_size) * 2 / ch;
00506
00507
00508 switch (avctx->codec->id) {
00509 case AV_CODEC_ID_ADPCM_EA:
00510 has_coded_samples = 1;
00511 *coded_samples = bytestream2_get_le32(gb);
00512 *coded_samples -= *coded_samples % 28;
00513 nb_samples = (buf_size - 12) / 30 * 28;
00514 break;
00515 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
00516 has_coded_samples = 1;
00517 *coded_samples = bytestream2_get_le32(gb);
00518 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
00519 break;
00520 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
00521 nb_samples = (buf_size - ch) / ch * 2;
00522 break;
00523 case AV_CODEC_ID_ADPCM_EA_R1:
00524 case AV_CODEC_ID_ADPCM_EA_R2:
00525 case AV_CODEC_ID_ADPCM_EA_R3:
00526
00527
00528 has_coded_samples = 1;
00529 switch (avctx->codec->id) {
00530 case AV_CODEC_ID_ADPCM_EA_R1:
00531 header_size = 4 + 9 * ch;
00532 *coded_samples = bytestream2_get_le32(gb);
00533 break;
00534 case AV_CODEC_ID_ADPCM_EA_R2:
00535 header_size = 4 + 5 * ch;
00536 *coded_samples = bytestream2_get_le32(gb);
00537 break;
00538 case AV_CODEC_ID_ADPCM_EA_R3:
00539 header_size = 4 + 5 * ch;
00540 *coded_samples = bytestream2_get_be32(gb);
00541 break;
00542 }
00543 *coded_samples -= *coded_samples % 28;
00544 nb_samples = (buf_size - header_size) * 2 / ch;
00545 nb_samples -= nb_samples % 28;
00546 break;
00547 case AV_CODEC_ID_ADPCM_IMA_DK3:
00548 if (avctx->block_align > 0)
00549 buf_size = FFMIN(buf_size, avctx->block_align);
00550 nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
00551 break;
00552 case AV_CODEC_ID_ADPCM_IMA_DK4:
00553 if (avctx->block_align > 0)
00554 buf_size = FFMIN(buf_size, avctx->block_align);
00555 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
00556 break;
00557 case AV_CODEC_ID_ADPCM_IMA_WAV:
00558 if (avctx->block_align > 0)
00559 buf_size = FFMIN(buf_size, avctx->block_align);
00560 nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
00561 break;
00562 case AV_CODEC_ID_ADPCM_MS:
00563 if (avctx->block_align > 0)
00564 buf_size = FFMIN(buf_size, avctx->block_align);
00565 nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
00566 break;
00567 case AV_CODEC_ID_ADPCM_SBPRO_2:
00568 case AV_CODEC_ID_ADPCM_SBPRO_3:
00569 case AV_CODEC_ID_ADPCM_SBPRO_4:
00570 {
00571 int samples_per_byte;
00572 switch (avctx->codec->id) {
00573 case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
00574 case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
00575 case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
00576 }
00577 if (!s->status[0].step_index) {
00578 nb_samples++;
00579 buf_size -= ch;
00580 }
00581 nb_samples += buf_size * samples_per_byte / ch;
00582 break;
00583 }
00584 case AV_CODEC_ID_ADPCM_SWF:
00585 {
00586 int buf_bits = buf_size * 8 - 2;
00587 int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
00588 int block_hdr_size = 22 * ch;
00589 int block_size = block_hdr_size + nbits * ch * 4095;
00590 int nblocks = buf_bits / block_size;
00591 int bits_left = buf_bits - nblocks * block_size;
00592 nb_samples = nblocks * 4096;
00593 if (bits_left >= block_hdr_size)
00594 nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
00595 break;
00596 }
00597 case AV_CODEC_ID_ADPCM_THP:
00598 has_coded_samples = 1;
00599 bytestream2_skip(gb, 4);
00600 *coded_samples = bytestream2_get_be32(gb);
00601 *coded_samples -= *coded_samples % 14;
00602 nb_samples = (buf_size - (8 + 36 * ch)) / (8 * ch) * 14;
00603 break;
00604 case AV_CODEC_ID_ADPCM_AFC:
00605 nb_samples = buf_size / (9 * ch) * 16;
00606 break;
00607 case AV_CODEC_ID_ADPCM_XA:
00608 nb_samples = (buf_size / 128) * 224 / ch;
00609 break;
00610 }
00611
00612
00613 if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
00614 return AVERROR_INVALIDDATA;
00615
00616 return nb_samples;
00617 }
00618
00619 static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
00620 int *got_frame_ptr, AVPacket *avpkt)
00621 {
00622 const uint8_t *buf = avpkt->data;
00623 int buf_size = avpkt->size;
00624 ADPCMDecodeContext *c = avctx->priv_data;
00625 ADPCMChannelStatus *cs;
00626 int n, m, channel, i;
00627 short *samples;
00628 int16_t **samples_p;
00629 int st;
00630 int count1, count2;
00631 int nb_samples, coded_samples, ret;
00632 GetByteContext gb;
00633
00634 bytestream2_init(&gb, buf, buf_size);
00635 nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples);
00636 if (nb_samples <= 0) {
00637 av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
00638 return AVERROR_INVALIDDATA;
00639 }
00640
00641
00642 c->frame.nb_samples = nb_samples;
00643 if ((ret = ff_get_buffer(avctx, &c->frame)) < 0) {
00644 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00645 return ret;
00646 }
00647 samples = (short *)c->frame.data[0];
00648 samples_p = (int16_t **)c->frame.extended_data;
00649
00650
00651
00652 if (coded_samples) {
00653 if (coded_samples != nb_samples)
00654 av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
00655 c->frame.nb_samples = nb_samples = coded_samples;
00656 }
00657
00658 st = avctx->channels == 2 ? 1 : 0;
00659
00660 switch(avctx->codec->id) {
00661 case AV_CODEC_ID_ADPCM_IMA_QT:
00662
00663
00664 for (channel = 0; channel < avctx->channels; channel++) {
00665 int predictor;
00666 int step_index;
00667 cs = &(c->status[channel]);
00668
00669
00670
00671 predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
00672 step_index = predictor & 0x7F;
00673 predictor &= ~0x7F;
00674
00675 if (cs->step_index == step_index) {
00676 int diff = predictor - cs->predictor;
00677 if (diff < 0)
00678 diff = - diff;
00679 if (diff > 0x7f)
00680 goto update;
00681 } else {
00682 update:
00683 cs->step_index = step_index;
00684 cs->predictor = predictor;
00685 }
00686
00687 if (cs->step_index > 88u){
00688 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
00689 channel, cs->step_index);
00690 return AVERROR_INVALIDDATA;
00691 }
00692
00693 samples = samples_p[channel];
00694
00695 for (m = 0; m < 64; m += 2) {
00696 int byte = bytestream2_get_byteu(&gb);
00697 samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3);
00698 samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 , 3);
00699 }
00700 }
00701 break;
00702 case AV_CODEC_ID_ADPCM_IMA_WAV:
00703 for(i=0; i<avctx->channels; i++){
00704 cs = &(c->status[i]);
00705 cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
00706
00707 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
00708 if (cs->step_index > 88u){
00709 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
00710 i, cs->step_index);
00711 return AVERROR_INVALIDDATA;
00712 }
00713 }
00714
00715 for (n = 0; n < (nb_samples - 1) / 8; n++) {
00716 for (i = 0; i < avctx->channels; i++) {
00717 cs = &c->status[i];
00718 samples = &samples_p[i][1 + n * 8];
00719 for (m = 0; m < 8; m += 2) {
00720 int v = bytestream2_get_byteu(&gb);
00721 samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
00722 samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
00723 }
00724 }
00725 }
00726 break;
00727 case AV_CODEC_ID_ADPCM_4XM:
00728 for (i = 0; i < avctx->channels; i++)
00729 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
00730
00731 for (i = 0; i < avctx->channels; i++) {
00732 c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
00733 if (c->status[i].step_index > 88u) {
00734 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
00735 i, c->status[i].step_index);
00736 return AVERROR_INVALIDDATA;
00737 }
00738 }
00739
00740 for (i = 0; i < avctx->channels; i++) {
00741 samples = (int16_t *)c->frame.data[i];
00742 cs = &c->status[i];
00743 for (n = nb_samples >> 1; n > 0; n--) {
00744 int v = bytestream2_get_byteu(&gb);
00745 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
00746 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
00747 }
00748 }
00749 break;
00750 case AV_CODEC_ID_ADPCM_MS:
00751 {
00752 int block_predictor;
00753
00754 block_predictor = bytestream2_get_byteu(&gb);
00755 if (block_predictor > 6) {
00756 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
00757 block_predictor);
00758 return AVERROR_INVALIDDATA;
00759 }
00760 c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
00761 c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
00762 if (st) {
00763 block_predictor = bytestream2_get_byteu(&gb);
00764 if (block_predictor > 6) {
00765 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
00766 block_predictor);
00767 return AVERROR_INVALIDDATA;
00768 }
00769 c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
00770 c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
00771 }
00772 c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
00773 if (st){
00774 c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
00775 }
00776
00777 c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
00778 if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
00779 c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
00780 if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
00781
00782 *samples++ = c->status[0].sample2;
00783 if (st) *samples++ = c->status[1].sample2;
00784 *samples++ = c->status[0].sample1;
00785 if (st) *samples++ = c->status[1].sample1;
00786 for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
00787 int byte = bytestream2_get_byteu(&gb);
00788 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
00789 *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
00790 }
00791 break;
00792 }
00793 case AV_CODEC_ID_ADPCM_IMA_DK4:
00794 for (channel = 0; channel < avctx->channels; channel++) {
00795 cs = &c->status[channel];
00796 cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
00797 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
00798 if (cs->step_index > 88u){
00799 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
00800 channel, cs->step_index);
00801 return AVERROR_INVALIDDATA;
00802 }
00803 }
00804 for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
00805 int v = bytestream2_get_byteu(&gb);
00806 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
00807 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
00808 }
00809 break;
00810 case AV_CODEC_ID_ADPCM_IMA_DK3:
00811 {
00812 int last_byte = 0;
00813 int nibble;
00814 int decode_top_nibble_next = 0;
00815 int diff_channel;
00816 const int16_t *samples_end = samples + avctx->channels * nb_samples;
00817
00818 bytestream2_skipu(&gb, 10);
00819 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
00820 c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
00821 c->status[0].step_index = bytestream2_get_byteu(&gb);
00822 c->status[1].step_index = bytestream2_get_byteu(&gb);
00823 if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
00824 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
00825 c->status[0].step_index, c->status[1].step_index);
00826 return AVERROR_INVALIDDATA;
00827 }
00828
00829 diff_channel = c->status[1].predictor;
00830
00831
00832 #define DK3_GET_NEXT_NIBBLE() \
00833 if (decode_top_nibble_next) { \
00834 nibble = last_byte >> 4; \
00835 decode_top_nibble_next = 0; \
00836 } else { \
00837 last_byte = bytestream2_get_byteu(&gb); \
00838 nibble = last_byte & 0x0F; \
00839 decode_top_nibble_next = 1; \
00840 }
00841
00842 while (samples < samples_end) {
00843
00844
00845
00846
00847
00848 DK3_GET_NEXT_NIBBLE();
00849 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
00850
00851
00852 DK3_GET_NEXT_NIBBLE();
00853 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
00854
00855
00856 diff_channel = (diff_channel + c->status[1].predictor) / 2;
00857 *samples++ = c->status[0].predictor + c->status[1].predictor;
00858 *samples++ = c->status[0].predictor - c->status[1].predictor;
00859
00860
00861 DK3_GET_NEXT_NIBBLE();
00862 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
00863
00864
00865 diff_channel = (diff_channel + c->status[1].predictor) / 2;
00866 *samples++ = c->status[0].predictor + c->status[1].predictor;
00867 *samples++ = c->status[0].predictor - c->status[1].predictor;
00868 }
00869 break;
00870 }
00871 case AV_CODEC_ID_ADPCM_IMA_ISS:
00872 for (channel = 0; channel < avctx->channels; channel++) {
00873 cs = &c->status[channel];
00874 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
00875 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
00876 if (cs->step_index > 88u){
00877 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
00878 channel, cs->step_index);
00879 return AVERROR_INVALIDDATA;
00880 }
00881 }
00882
00883 for (n = nb_samples >> (1 - st); n > 0; n--) {
00884 int v1, v2;
00885 int v = bytestream2_get_byteu(&gb);
00886
00887 if (st) {
00888 v1 = v >> 4;
00889 v2 = v & 0x0F;
00890 } else {
00891 v2 = v >> 4;
00892 v1 = v & 0x0F;
00893 }
00894 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
00895 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
00896 }
00897 break;
00898 case AV_CODEC_ID_ADPCM_IMA_APC:
00899 while (bytestream2_get_bytes_left(&gb) > 0) {
00900 int v = bytestream2_get_byteu(&gb);
00901 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
00902 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
00903 }
00904 break;
00905 case AV_CODEC_ID_ADPCM_IMA_OKI:
00906 while (bytestream2_get_bytes_left(&gb) > 0) {
00907 int v = bytestream2_get_byteu(&gb);
00908 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 );
00909 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);
00910 }
00911 break;
00912 case AV_CODEC_ID_ADPCM_IMA_WS:
00913 if (c->vqa_version == 3) {
00914 for (channel = 0; channel < avctx->channels; channel++) {
00915 int16_t *smp = samples_p[channel];
00916
00917 for (n = nb_samples / 2; n > 0; n--) {
00918 int v = bytestream2_get_byteu(&gb);
00919 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
00920 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
00921 }
00922 }
00923 } else {
00924 for (n = nb_samples / 2; n > 0; n--) {
00925 for (channel = 0; channel < avctx->channels; channel++) {
00926 int v = bytestream2_get_byteu(&gb);
00927 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
00928 samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
00929 }
00930 samples += avctx->channels;
00931 }
00932 }
00933 bytestream2_seek(&gb, 0, SEEK_END);
00934 break;
00935 case AV_CODEC_ID_ADPCM_XA:
00936 {
00937 int16_t *out0 = samples_p[0];
00938 int16_t *out1 = samples_p[1];
00939 int samples_per_block = 28 * (3 - avctx->channels) * 4;
00940 int sample_offset = 0;
00941 while (bytestream2_get_bytes_left(&gb) >= 128) {
00942 if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
00943 &c->status[0], &c->status[1],
00944 avctx->channels, sample_offset)) < 0)
00945 return ret;
00946 bytestream2_skipu(&gb, 128);
00947 sample_offset += samples_per_block;
00948 }
00949 break;
00950 }
00951 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
00952 for (i=0; i<=st; i++) {
00953 c->status[i].step_index = bytestream2_get_le32u(&gb);
00954 if (c->status[i].step_index > 88u) {
00955 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
00956 i, c->status[i].step_index);
00957 return AVERROR_INVALIDDATA;
00958 }
00959 }
00960 for (i=0; i<=st; i++)
00961 c->status[i].predictor = bytestream2_get_le32u(&gb);
00962
00963 for (n = nb_samples >> (1 - st); n > 0; n--) {
00964 int byte = bytestream2_get_byteu(&gb);
00965 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
00966 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
00967 }
00968 break;
00969 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
00970 for (n = nb_samples >> (1 - st); n > 0; n--) {
00971 int byte = bytestream2_get_byteu(&gb);
00972 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
00973 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
00974 }
00975 break;
00976 case AV_CODEC_ID_ADPCM_EA:
00977 {
00978 int previous_left_sample, previous_right_sample;
00979 int current_left_sample, current_right_sample;
00980 int next_left_sample, next_right_sample;
00981 int coeff1l, coeff2l, coeff1r, coeff2r;
00982 int shift_left, shift_right;
00983
00984
00985
00986
00987 if(avctx->channels != 2)
00988 return AVERROR_INVALIDDATA;
00989
00990 current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
00991 previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
00992 current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
00993 previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
00994
00995 for (count1 = 0; count1 < nb_samples / 28; count1++) {
00996 int byte = bytestream2_get_byteu(&gb);
00997 coeff1l = ea_adpcm_table[ byte >> 4 ];
00998 coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
00999 coeff1r = ea_adpcm_table[ byte & 0x0F];
01000 coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
01001
01002 byte = bytestream2_get_byteu(&gb);
01003 shift_left = 20 - (byte >> 4);
01004 shift_right = 20 - (byte & 0x0F);
01005
01006 for (count2 = 0; count2 < 28; count2++) {
01007 byte = bytestream2_get_byteu(&gb);
01008 next_left_sample = sign_extend(byte >> 4, 4) << shift_left;
01009 next_right_sample = sign_extend(byte, 4) << shift_right;
01010
01011 next_left_sample = (next_left_sample +
01012 (current_left_sample * coeff1l) +
01013 (previous_left_sample * coeff2l) + 0x80) >> 8;
01014 next_right_sample = (next_right_sample +
01015 (current_right_sample * coeff1r) +
01016 (previous_right_sample * coeff2r) + 0x80) >> 8;
01017
01018 previous_left_sample = current_left_sample;
01019 current_left_sample = av_clip_int16(next_left_sample);
01020 previous_right_sample = current_right_sample;
01021 current_right_sample = av_clip_int16(next_right_sample);
01022 *samples++ = current_left_sample;
01023 *samples++ = current_right_sample;
01024 }
01025 }
01026
01027 bytestream2_skip(&gb, 2);
01028
01029 break;
01030 }
01031 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
01032 {
01033 int coeff[2][2], shift[2];
01034
01035 for(channel = 0; channel < avctx->channels; channel++) {
01036 int byte = bytestream2_get_byteu(&gb);
01037 for (i=0; i<2; i++)
01038 coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
01039 shift[channel] = 20 - (byte & 0x0F);
01040 }
01041 for (count1 = 0; count1 < nb_samples / 2; count1++) {
01042 int byte[2];
01043
01044 byte[0] = bytestream2_get_byteu(&gb);
01045 if (st) byte[1] = bytestream2_get_byteu(&gb);
01046 for(i = 4; i >= 0; i-=4) {
01047 for(channel = 0; channel < avctx->channels; channel++) {
01048 int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
01049 sample = (sample +
01050 c->status[channel].sample1 * coeff[channel][0] +
01051 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
01052 c->status[channel].sample2 = c->status[channel].sample1;
01053 c->status[channel].sample1 = av_clip_int16(sample);
01054 *samples++ = c->status[channel].sample1;
01055 }
01056 }
01057 }
01058 bytestream2_seek(&gb, 0, SEEK_END);
01059 break;
01060 }
01061 case AV_CODEC_ID_ADPCM_EA_R1:
01062 case AV_CODEC_ID_ADPCM_EA_R2:
01063 case AV_CODEC_ID_ADPCM_EA_R3: {
01064
01065
01066
01067
01068 const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
01069 int previous_sample, current_sample, next_sample;
01070 int coeff1, coeff2;
01071 int shift;
01072 unsigned int channel;
01073 uint16_t *samplesC;
01074 int count = 0;
01075 int offsets[6];
01076
01077 for (channel=0; channel<avctx->channels; channel++)
01078 offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
01079 bytestream2_get_le32(&gb)) +
01080 (avctx->channels + 1) * 4;
01081
01082 for (channel=0; channel<avctx->channels; channel++) {
01083 bytestream2_seek(&gb, offsets[channel], SEEK_SET);
01084 samplesC = samples_p[channel];
01085
01086 if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
01087 current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
01088 previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
01089 } else {
01090 current_sample = c->status[channel].predictor;
01091 previous_sample = c->status[channel].prev_sample;
01092 }
01093
01094 for (count1 = 0; count1 < nb_samples / 28; count1++) {
01095 int byte = bytestream2_get_byte(&gb);
01096 if (byte == 0xEE) {
01097 current_sample = sign_extend(bytestream2_get_be16(&gb), 16);
01098 previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
01099
01100 for (count2=0; count2<28; count2++)
01101 *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
01102 } else {
01103 coeff1 = ea_adpcm_table[ byte >> 4 ];
01104 coeff2 = ea_adpcm_table[(byte >> 4) + 4];
01105 shift = 20 - (byte & 0x0F);
01106
01107 for (count2=0; count2<28; count2++) {
01108 if (count2 & 1)
01109 next_sample = sign_extend(byte, 4) << shift;
01110 else {
01111 byte = bytestream2_get_byte(&gb);
01112 next_sample = sign_extend(byte >> 4, 4) << shift;
01113 }
01114
01115 next_sample += (current_sample * coeff1) +
01116 (previous_sample * coeff2);
01117 next_sample = av_clip_int16(next_sample >> 8);
01118
01119 previous_sample = current_sample;
01120 current_sample = next_sample;
01121 *samplesC++ = current_sample;
01122 }
01123 }
01124 }
01125 if (!count) {
01126 count = count1;
01127 } else if (count != count1) {
01128 av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
01129 count = FFMAX(count, count1);
01130 }
01131
01132 if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
01133 c->status[channel].predictor = current_sample;
01134 c->status[channel].prev_sample = previous_sample;
01135 }
01136 }
01137
01138 c->frame.nb_samples = count * 28;
01139 bytestream2_seek(&gb, 0, SEEK_END);
01140 break;
01141 }
01142 case AV_CODEC_ID_ADPCM_EA_XAS:
01143 for (channel=0; channel<avctx->channels; channel++) {
01144 int coeff[2][4], shift[4];
01145 int16_t *s = samples_p[channel];
01146 for (n = 0; n < 4; n++, s += 32) {
01147 int val = sign_extend(bytestream2_get_le16u(&gb), 16);
01148 for (i=0; i<2; i++)
01149 coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
01150 s[0] = val & ~0x0F;
01151
01152 val = sign_extend(bytestream2_get_le16u(&gb), 16);
01153 shift[n] = 20 - (val & 0x0F);
01154 s[1] = val & ~0x0F;
01155 }
01156
01157 for (m=2; m<32; m+=2) {
01158 s = &samples_p[channel][m];
01159 for (n = 0; n < 4; n++, s += 32) {
01160 int level, pred;
01161 int byte = bytestream2_get_byteu(&gb);
01162
01163 level = sign_extend(byte >> 4, 4) << shift[n];
01164 pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
01165 s[0] = av_clip_int16((level + pred + 0x80) >> 8);
01166
01167 level = sign_extend(byte, 4) << shift[n];
01168 pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
01169 s[1] = av_clip_int16((level + pred + 0x80) >> 8);
01170 }
01171 }
01172 }
01173 break;
01174 case AV_CODEC_ID_ADPCM_IMA_AMV:
01175 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
01176 c->status[0].step_index = bytestream2_get_le16u(&gb);
01177 bytestream2_skipu(&gb, 4);
01178 if (c->status[0].step_index > 88u) {
01179 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
01180 c->status[0].step_index);
01181 return AVERROR_INVALIDDATA;
01182 }
01183
01184 for (n = nb_samples >> (1 - st); n > 0; n--) {
01185 int v = bytestream2_get_byteu(&gb);
01186
01187 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
01188 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);
01189 }
01190 break;
01191 case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
01192 for (i = 0; i < avctx->channels; i++) {
01193 c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
01194 c->status[i].step_index = bytestream2_get_byteu(&gb);
01195 bytestream2_skipu(&gb, 1);
01196 if (c->status[i].step_index > 88u) {
01197 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
01198 c->status[i].step_index);
01199 return AVERROR_INVALIDDATA;
01200 }
01201 }
01202
01203 for (n = nb_samples >> (1 - st); n > 0; n--) {
01204 int v = bytestream2_get_byteu(&gb);
01205
01206 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3);
01207 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3);
01208 }
01209 break;
01210 case AV_CODEC_ID_ADPCM_CT:
01211 for (n = nb_samples >> (1 - st); n > 0; n--) {
01212 int v = bytestream2_get_byteu(&gb);
01213 *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
01214 *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
01215 }
01216 break;
01217 case AV_CODEC_ID_ADPCM_SBPRO_4:
01218 case AV_CODEC_ID_ADPCM_SBPRO_3:
01219 case AV_CODEC_ID_ADPCM_SBPRO_2:
01220 if (!c->status[0].step_index) {
01221
01222 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
01223 if (st)
01224 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
01225 c->status[0].step_index = 1;
01226 nb_samples--;
01227 }
01228 if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
01229 for (n = nb_samples >> (1 - st); n > 0; n--) {
01230 int byte = bytestream2_get_byteu(&gb);
01231 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01232 byte >> 4, 4, 0);
01233 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
01234 byte & 0x0F, 4, 0);
01235 }
01236 } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
01237 for (n = nb_samples / 3; n > 0; n--) {
01238 int byte = bytestream2_get_byteu(&gb);
01239 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01240 byte >> 5 , 3, 0);
01241 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01242 (byte >> 2) & 0x07, 3, 0);
01243 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01244 byte & 0x03, 2, 0);
01245 }
01246 } else {
01247 for (n = nb_samples >> (2 - st); n > 0; n--) {
01248 int byte = bytestream2_get_byteu(&gb);
01249 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01250 byte >> 6 , 2, 2);
01251 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
01252 (byte >> 4) & 0x03, 2, 2);
01253 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01254 (byte >> 2) & 0x03, 2, 2);
01255 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
01256 byte & 0x03, 2, 2);
01257 }
01258 }
01259 break;
01260 case AV_CODEC_ID_ADPCM_SWF:
01261 adpcm_swf_decode(avctx, buf, buf_size, samples);
01262 bytestream2_seek(&gb, 0, SEEK_END);
01263 break;
01264 case AV_CODEC_ID_ADPCM_YAMAHA:
01265 for (n = nb_samples >> (1 - st); n > 0; n--) {
01266 int v = bytestream2_get_byteu(&gb);
01267 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
01268 *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
01269 }
01270 break;
01271 case AV_CODEC_ID_ADPCM_AFC:
01272 {
01273 int samples_per_block;
01274 int blocks;
01275
01276 if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) {
01277 samples_per_block = avctx->extradata[0] / 16;
01278 blocks = nb_samples / avctx->extradata[0];
01279 } else {
01280 samples_per_block = nb_samples / 16;
01281 blocks = 1;
01282 }
01283
01284 for (m = 0; m < blocks; m++) {
01285 for (channel = 0; channel < avctx->channels; channel++) {
01286 int prev1 = c->status[channel].sample1;
01287 int prev2 = c->status[channel].sample2;
01288
01289 samples = samples_p[channel] + m * 16;
01290
01291 for (i = 0; i < samples_per_block; i++) {
01292 int byte = bytestream2_get_byteu(&gb);
01293 int scale = 1 << (byte >> 4);
01294 int index = byte & 0xf;
01295 int factor1 = ff_adpcm_afc_coeffs[0][index];
01296 int factor2 = ff_adpcm_afc_coeffs[1][index];
01297
01298
01299 for (n = 0; n < 16; n++) {
01300 int32_t sampledat;
01301
01302 if (n & 1) {
01303 sampledat = sign_extend(byte, 4);
01304 } else {
01305 byte = bytestream2_get_byteu(&gb);
01306 sampledat = sign_extend(byte >> 4, 4);
01307 }
01308
01309 sampledat = ((prev1 * factor1 + prev2 * factor2) +
01310 ((sampledat * scale) << 11)) >> 11;
01311 *samples = av_clip_int16(sampledat);
01312 prev2 = prev1;
01313 prev1 = *samples++;
01314 }
01315 }
01316
01317 c->status[channel].sample1 = prev1;
01318 c->status[channel].sample2 = prev2;
01319 }
01320 }
01321 bytestream2_seek(&gb, 0, SEEK_END);
01322 break;
01323 }
01324 case AV_CODEC_ID_ADPCM_THP:
01325 {
01326 int table[6][16];
01327 int ch;
01328
01329 for (i = 0; i < avctx->channels; i++)
01330 for (n = 0; n < 16; n++)
01331 table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
01332
01333
01334 for (i = 0; i < avctx->channels; i++) {
01335 c->status[i].sample1 = sign_extend(bytestream2_get_be16u(&gb), 16);
01336 c->status[i].sample2 = sign_extend(bytestream2_get_be16u(&gb), 16);
01337 }
01338
01339 for (ch = 0; ch < avctx->channels; ch++) {
01340 samples = samples_p[ch];
01341
01342
01343 for (i = 0; i < nb_samples / 14; i++) {
01344 int byte = bytestream2_get_byteu(&gb);
01345 int index = (byte >> 4) & 7;
01346 unsigned int exp = byte & 0x0F;
01347 int factor1 = table[ch][index * 2];
01348 int factor2 = table[ch][index * 2 + 1];
01349
01350
01351 for (n = 0; n < 14; n++) {
01352 int32_t sampledat;
01353
01354 if (n & 1) {
01355 sampledat = sign_extend(byte, 4);
01356 } else {
01357 byte = bytestream2_get_byteu(&gb);
01358 sampledat = sign_extend(byte >> 4, 4);
01359 }
01360
01361 sampledat = ((c->status[ch].sample1 * factor1
01362 + c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp);
01363 *samples = av_clip_int16(sampledat);
01364 c->status[ch].sample2 = c->status[ch].sample1;
01365 c->status[ch].sample1 = *samples++;
01366 }
01367 }
01368 }
01369 break;
01370 }
01371
01372 default:
01373 return -1;
01374 }
01375
01376 if (avpkt->size && bytestream2_tell(&gb) == 0) {
01377 av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
01378 return AVERROR_INVALIDDATA;
01379 }
01380
01381 *got_frame_ptr = 1;
01382 *(AVFrame *)data = c->frame;
01383
01384 return bytestream2_tell(&gb);
01385 }
01386
01387
01388 static const enum AVSampleFormat sample_fmts_s16[] = { AV_SAMPLE_FMT_S16,
01389 AV_SAMPLE_FMT_NONE };
01390 static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16,
01391 AV_SAMPLE_FMT_NONE };
01392 static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
01393 AV_SAMPLE_FMT_S16P,
01394 AV_SAMPLE_FMT_NONE };
01395
01396 #define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
01397 AVCodec ff_ ## name_ ## _decoder = { \
01398 .name = #name_, \
01399 .type = AVMEDIA_TYPE_AUDIO, \
01400 .id = id_, \
01401 .priv_data_size = sizeof(ADPCMDecodeContext), \
01402 .init = adpcm_decode_init, \
01403 .decode = adpcm_decode_frame, \
01404 .capabilities = CODEC_CAP_DR1, \
01405 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
01406 .sample_fmts = sample_fmts_, \
01407 }
01408
01409
01410 ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, sample_fmts_s16p, adpcm_4xm, "ADPCM 4X Movie");
01411 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC, sample_fmts_s16p, adpcm_afc, "ADPCM Nintendo Gamecube AFC");
01412 ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, sample_fmts_s16, adpcm_ct, "ADPCM Creative Technology");
01413 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, sample_fmts_s16, adpcm_ea, "ADPCM Electronic Arts");
01414 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
01415 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, sample_fmts_s16p, adpcm_ea_r1, "ADPCM Electronic Arts R1");
01416 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2, sample_fmts_s16p, adpcm_ea_r2, "ADPCM Electronic Arts R2");
01417 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3, sample_fmts_s16p, adpcm_ea_r3, "ADPCM Electronic Arts R3");
01418 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS, sample_fmts_s16p, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
01419 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV, sample_fmts_s16, adpcm_ima_amv, "ADPCM IMA AMV");
01420 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC, sample_fmts_s16, adpcm_ima_apc, "ADPCM IMA CRYO APC");
01421 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3, sample_fmts_s16, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
01422 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, sample_fmts_s16, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
01423 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
01424 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
01425 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, sample_fmts_s16, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
01426 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI, sample_fmts_s16, adpcm_ima_oki, "ADPCM IMA Dialogic OKI");
01427 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, sample_fmts_s16p, adpcm_ima_qt, "ADPCM IMA QuickTime");
01428 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, sample_fmts_s16, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
01429 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, sample_fmts_s16p, adpcm_ima_wav, "ADPCM IMA WAV");
01430 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, sample_fmts_both, adpcm_ima_ws, "ADPCM IMA Westwood");
01431 ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS, sample_fmts_s16, adpcm_ms, "ADPCM Microsoft");
01432 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, sample_fmts_s16, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
01433 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, sample_fmts_s16, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
01434 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, sample_fmts_s16, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
01435 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, sample_fmts_s16, adpcm_swf, "ADPCM Shockwave Flash");
01436 ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo Gamecube THP");
01437 ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, sample_fmts_s16p, adpcm_xa, "ADPCM CDROM XA");
01438 ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, sample_fmts_s16, adpcm_yamaha, "ADPCM Yamaha");