80 { -1, -1, -1, -1, 2, 4, 6, 8 },
81 { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
94 unsigned int min_channels = 1;
95 unsigned int max_channels = 2;
148 if (step_index < 0) step_index = 0;
149 else if (step_index > 88) step_index = 88;
156 diff = ((2 * delta + 1) * step) >> shift;
158 if (sign) predictor -= diff;
159 else predictor += diff;
175 step_index = av_clip(step_index, 0, 88);
178 if (nibble & 4) diff +=
step;
179 if (nibble & 2) diff += step >> 1;
180 if (nibble & 1) diff += step >> 2;
198 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->
idelta;
201 c->
sample1 = av_clip_int16(predictor);
210 int sign,
delta, diff;
218 diff = ((2 * delta + 1) * c->
step) >> 3;
224 c->
step = av_clip(new_step, 511, 32767);
231 int sign,
delta, diff;
233 sign = nibble & (1<<(size-1));
234 delta = nibble & ((1<<(size-1))-1);
235 diff = delta << (7 + c->
step + shift);
241 if (delta >= (2*size - 3) && c->
step < 3)
243 else if (delta == 0 && c->
step > 0)
259 c->
step = av_clip(c->
step, 127, 24567);
264 short *out,
const unsigned char *in,
274 shift = 12 - (in[4+i*2] & 15);
275 filter = in[4+i*2] >> 4;
278 "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
291 t = (
signed char)(d<<4)>>4;
292 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
294 s_1 = av_clip_int16(s);
304 out = out + 1 - 28*2;
307 shift = 12 - (in[5+i*2] & 15);
308 filter = in[5+i*2] >> 4;
311 "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
321 t = (
signed char)d >> 4;
322 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
324 s_1 = av_clip_int16(s);
352 int buf_size,
int *coded_samples)
357 int has_coded_samples = 0;
365 if (buf_size < 76 * ch)
370 if (buf_size < 34 * ch)
379 nb_samples = buf_size * 2 / ch;
394 return (buf_size - header_size) * 2 / ch;
399 has_coded_samples = 1;
403 *coded_samples -= *coded_samples % 28;
404 nb_samples = (buf_size - 12) / 30 * 28;
407 has_coded_samples = 1;
411 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
414 nb_samples = ((buf_size - ch) / (2 * ch)) * 2 * ch;
421 has_coded_samples = 1;
426 header_size = 4 + 9 * ch;
430 header_size = 4 + 5 * ch;
434 header_size = 4 + 5 * ch;
438 *coded_samples -= *coded_samples % 28;
439 nb_samples = (buf_size - header_size) * 2 / ch;
440 nb_samples -= nb_samples % 28;
445 nb_samples = ((buf_size - 16) * 8 / 3) / ch;
448 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
453 nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
458 nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
464 int samples_per_byte;
474 nb_samples += buf_size * samples_per_byte / ch;
479 int buf_bits = buf_size * 8 - 2;
480 int nbits = (buf[0] >> 6) + 2;
481 int block_hdr_size = 22 * ch;
482 int block_size = block_hdr_size + nbits * ch * 4095;
483 int nblocks = buf_bits / block_size;
484 int bits_left = buf_bits - nblocks * block_size;
485 nb_samples = nblocks * 4096;
486 if (bits_left >= block_hdr_size)
487 nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
491 has_coded_samples = 1;
494 *coded_samples =
AV_RB32(&buf[4]);
495 *coded_samples -= *coded_samples % 14;
496 nb_samples = (buf_size - 80) / (8 * ch) * 14;
499 nb_samples = (buf_size / 128) * 224 / ch;
504 if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
511 #define DK3_GET_NEXT_NIBBLE() \
512 if (decode_top_nibble_next) \
514 nibble = last_byte >> 4; \
515 decode_top_nibble_next = 0; \
521 last_byte = *src++; \
522 if (src >= buf + buf_size) \
524 nibble = last_byte & 0x0F; \
525 decode_top_nibble_next = 1; \
529 int *got_frame_ptr,
AVPacket *avpkt)
531 const uint8_t *buf = avpkt->
data;
532 int buf_size = avpkt->
size;
535 int n, m, channel, i;
540 int nb_samples, coded_samples, ret;
542 nb_samples =
get_nb_samples(avctx, buf, buf_size, &coded_samples);
543 if (nb_samples <= 0) {
559 if (coded_samples != nb_samples)
572 for (channel = 0; channel < avctx->
channels; channel++) {
575 cs = &(c->
status[channel]);
580 step_index = predictor & 0x7F;
586 int diff = (int)predictor - cs->
predictor;
602 samples = (
short *)c->
frame.
data[0] + channel;
604 for (m = 0; m < 32; m++) {
619 cs->
predictor = *samples++ = (int16_t)bytestream_get_le16(&src);
626 if (*src++)
av_log(avctx,
AV_LOG_ERROR,
"unused byte should be null but is %d!!\n", src[-1]);
629 for (n = (nb_samples - 1) / 8; n > 0; n--) {
630 for (i = 0; i < avctx->
channels; i++) {
632 for (m = 0; m < 4; m++) {
645 for (i = 0; i < avctx->
channels; i++)
648 for (i = 0; i < avctx->
channels; i++) {
653 for (i = 0; i < avctx->
channels; i++) {
656 for (n = nb_samples >> 1; n > 0; n--, src++) {
672 block_predictor = av_clip(*src++, 0, 6);
676 block_predictor = av_clip(*src++, 0, 6);
680 c->
status[0].
idelta = (int16_t)bytestream_get_le16(&src);
682 c->
status[1].
idelta = (int16_t)bytestream_get_le16(&src);
694 for(n = (nb_samples - 2) >> (1 - st); n > 0; n--, src++) {
704 for (channel = 0; channel < avctx->
channels; channel++) {
706 cs->
predictor = (int16_t)bytestream_get_le16(&src);
711 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
719 unsigned char last_byte = 0;
720 unsigned char nibble;
721 int decode_top_nibble_next = 0;
722 int end_of_packet = 0;
768 for (channel = 0; channel < avctx->
channels; channel++) {
770 cs->
predictor = (int16_t)bytestream_get_le16(&src);
775 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
791 while (src < buf + buf_size) {
798 while (buf_size >= 128) {
810 for (i=0; i<=st; i++)
812 for (i=0; i<=st; i++)
815 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
821 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
828 int32_t previous_left_sample, previous_right_sample;
829 int32_t current_left_sample, current_right_sample;
830 int32_t next_left_sample, next_right_sample;
831 int32_t coeff1l, coeff2l, coeff1r, coeff2r;
832 uint8_t shift_left, shift_right;
839 current_left_sample = (int16_t)bytestream_get_le16(&src);
840 previous_left_sample = (int16_t)bytestream_get_le16(&src);
841 current_right_sample = (int16_t)bytestream_get_le16(&src);
842 previous_right_sample = (int16_t)bytestream_get_le16(&src);
844 for (count1 = 0; count1 < nb_samples / 28; count1++) {
851 shift_left = 20 - (*src >> 4);
852 shift_right = 20 - (*src & 0x0F);
855 for (count2 = 0; count2 < 28; count2++) {
856 next_left_sample =
sign_extend(*src >> 4, 4) << shift_left;
857 next_right_sample =
sign_extend(*src, 4) << shift_right;
860 next_left_sample = (next_left_sample +
861 (current_left_sample * coeff1l) +
862 (previous_left_sample * coeff2l) + 0x80) >> 8;
863 next_right_sample = (next_right_sample +
864 (current_right_sample * coeff1r) +
865 (previous_right_sample * coeff2r) + 0x80) >> 8;
867 previous_left_sample = current_left_sample;
868 current_left_sample = av_clip_int16(next_left_sample);
869 previous_right_sample = current_right_sample;
870 current_right_sample = av_clip_int16(next_right_sample);
871 *samples++ = (
unsigned short)current_left_sample;
872 *samples++ = (
unsigned short)current_right_sample;
876 if (src - buf == buf_size - 2)
883 int coeff[2][2], shift[2];
885 for(channel = 0; channel < avctx->
channels; channel++) {
888 shift[channel] = 20 - (*src & 0x0F);
891 for (count1 = 0; count1 < nb_samples / 2; count1++) {
892 for(i = 4; i >= 0; i-=4) {
893 for(channel = 0; channel < avctx->
channels; channel++) {
894 int32_t sample =
sign_extend(src[channel] >> i, 4) << shift[channel];
906 src = buf + buf_size;
917 int32_t previous_sample, current_sample, next_sample;
918 int32_t coeff1, coeff2;
920 unsigned int channel;
923 const uint8_t *src_end = buf + buf_size;
928 for (channel=0; channel<avctx->
channels; channel++) {
929 int32_t offset = (big_endian ? bytestream_get_be32(&src)
930 : bytestream_get_le32(&src))
933 if ((offset < 0) || (offset >= src_end - src - 4))
break;
935 samplesC = samples + channel;
938 current_sample = (int16_t)bytestream_get_le16(&srcC);
939 previous_sample = (int16_t)bytestream_get_le16(&srcC);
945 for (count1 = 0; count1 < nb_samples / 28; count1++) {
948 if (srcC > src_end - 30*2)
break;
949 current_sample = (int16_t)bytestream_get_be16(&srcC);
950 previous_sample = (int16_t)bytestream_get_be16(&srcC);
952 for (count2=0; count2<28; count2++) {
953 *samplesC = (int16_t)bytestream_get_be16(&srcC);
959 shift = 20 - (*srcC++ & 0x0F);
961 if (srcC > src_end - 14)
break;
962 for (count2=0; count2<28; count2++) {
968 next_sample += (current_sample * coeff1) +
969 (previous_sample * coeff2);
970 next_sample = av_clip_int16(next_sample >> 8);
972 previous_sample = current_sample;
973 current_sample = next_sample;
974 *samplesC = current_sample;
981 }
else if (count != count1) {
983 count =
FFMAX(count, count1);
997 for (channel=0; channel<avctx->
channels; channel++) {
998 int coeff[2][4], shift[4];
999 short *
s2, *s = &samples[channel];
1000 for (n=0; n<4; n++, s+=32*avctx->
channels) {
1003 shift[n] = 20 - (src[2] & 0x0F);
1004 for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->
channels)
1005 s2[0] = (src[0]&0xF0) + (src[1]<<8);
1008 for (m=2; m<32; m+=2) {
1009 s = &samples[m*avctx->
channels + channel];
1010 for (n=0; n<4; n++, src++, s+=32*avctx->
channels) {
1011 for (s2=s, i=0; i<8; i+=4, s2+=avctx->
channels) {
1014 + s2[-2*avctx->
channels] * coeff[1][n];
1015 s2[0] = av_clip_int16((level + pred + 0x80) >> 8);
1033 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1048 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1059 *samples++ = 128 * (*src++ - 0x80);
1061 *samples++ = 128 * (*src++ - 0x80);
1066 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1070 src[0] & 0x0F, 4, 0);
1073 for (n = nb_samples / 3; n > 0; n--, src++) {
1075 src[0] >> 5 , 3, 0);
1077 (src[0] >> 2) & 0x07, 3, 0);
1079 src[0] & 0x03, 2, 0);
1082 for (n = nb_samples >> (2 - st); n > 0; n--, src++) {
1084 src[0] >> 6 , 2, 2);
1086 (src[0] >> 4) & 0x03, 2, 2);
1088 (src[0] >> 2) & 0x03, 2, 2);
1090 src[0] & 0x03, 2, 2);
1098 int k0, signmask, nb_bits, count;
1099 int size = buf_size*8;
1107 k0 = 1 << (nb_bits-2);
1108 signmask = 1 << (nb_bits-1);
1111 for (i = 0; i < avctx->
channels; i++) {
1119 for (i = 0; i < avctx->
channels; i++) {
1134 if (delta & signmask)
1152 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1167 for (i = 0; i < 32; i++)
1168 table[0][i] = (int16_t)bytestream_get_be16(&src);
1171 for (i = 0; i < 4; i++)
1172 prev[0][i] = (int16_t)bytestream_get_be16(&src);
1174 for (ch = 0; ch <= st; ch++) {
1175 samples = (
short *)c->
frame.
data[0] + ch;
1178 for (i = 0; i < nb_samples / 14; i++) {
1179 int index = (*src >> 4) & 7;
1180 unsigned int exp = *src++ & 15;
1181 int factor1 = table[ch][index * 2];
1182 int factor2 = table[ch][index * 2 + 1];
1185 for (n = 0; n < 14; n++) {
1190 sampledat = ((prev[ch][0]*factor1
1191 + prev[ch][1]*factor2) >> 11) + (sampledat << exp);
1192 *samples = av_clip_int16(sampledat);
1193 prev[ch][1] = prev[ch][0];
1194 prev[ch][0] = *samples++;
1216 #define ADPCM_DECODER(id_, name_, long_name_) \
1217 AVCodec ff_ ## name_ ## _decoder = { \
1219 .type = AVMEDIA_TYPE_AUDIO, \
1221 .priv_data_size = sizeof(ADPCMDecodeContext), \
1222 .init = adpcm_decode_init, \
1223 .decode = adpcm_decode_frame, \
1224 .capabilities = CODEC_CAP_DR1, \
1225 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \