81 { -1, -1, -1, -1, 2, 4, 6, 8 },
82 { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
95 unsigned int min_channels = 1;
96 unsigned int max_channels = 2;
149 if (step_index < 0) step_index = 0;
150 else if (step_index > 88) step_index = 88;
157 diff = ((2 * delta + 1) * step) >> shift;
159 if (sign) predictor -= diff;
160 else predictor += diff;
176 step_index = av_clip(step_index, 0, 88);
179 if (nibble & 4) diff +=
step;
180 if (nibble & 2) diff += step >> 1;
181 if (nibble & 1) diff += step >> 2;
199 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->
idelta;
202 c->
sample1 = av_clip_int16(predictor);
211 int sign,
delta, diff;
219 diff = ((2 * delta + 1) * c->
step) >> 3;
225 c->
step = av_clip(new_step, 511, 32767);
232 int sign,
delta, diff;
234 sign = nibble & (1<<(size-1));
235 delta = nibble & ((1<<(size-1))-1);
236 diff = delta << (7 + c->
step + shift);
242 if (delta >= (2*size - 3) && c->
step < 3)
244 else if (delta == 0 && c->
step > 0)
260 c->
step = av_clip(c->
step, 127, 24567);
265 short *out,
const unsigned char *in,
275 shift = 12 - (in[4+i*2] & 15);
276 filter = in[4+i*2] >> 4;
279 "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
292 t = (
signed char)(d<<4)>>4;
293 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
295 s_1 = av_clip_int16(s);
305 out = out + 1 - 28*2;
308 shift = 12 - (in[5+i*2] & 15);
309 filter = in[5+i*2] >> 4;
312 "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
322 t = (
signed char)d >> 4;
323 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
325 s_1 = av_clip_int16(s);
353 int buf_size,
int *coded_samples)
358 int has_coded_samples = 0;
366 if (buf_size < 76 * ch)
371 if (buf_size < 34 * ch)
380 nb_samples = buf_size * 2 / ch;
395 return (buf_size - header_size) * 2 / ch;
400 has_coded_samples = 1;
404 *coded_samples -= *coded_samples % 28;
405 nb_samples = (buf_size - 12) / 30 * 28;
408 has_coded_samples = 1;
412 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
415 nb_samples = ((buf_size - ch) / (2 * ch)) * 2 * ch;
422 has_coded_samples = 1;
427 header_size = 4 + 9 * ch;
431 header_size = 4 + 5 * ch;
435 header_size = 4 + 5 * ch;
439 *coded_samples -= *coded_samples % 28;
440 nb_samples = (buf_size - header_size) * 2 / ch;
441 nb_samples -= nb_samples % 28;
446 nb_samples = ((buf_size - 16) * 8 / 3) / ch;
449 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
454 nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
459 nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
465 int samples_per_byte;
475 nb_samples += buf_size * samples_per_byte / ch;
480 int buf_bits = buf_size * 8 - 2;
481 int nbits = (buf[0] >> 6) + 2;
482 int block_hdr_size = 22 * ch;
483 int block_size = block_hdr_size + nbits * ch * 4095;
484 int nblocks = buf_bits / block_size;
485 int bits_left = buf_bits - nblocks * block_size;
486 nb_samples = nblocks * 4096;
487 if (bits_left >= block_hdr_size)
488 nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
492 has_coded_samples = 1;
495 *coded_samples =
AV_RB32(&buf[4]);
496 *coded_samples -= *coded_samples % 14;
497 nb_samples = (buf_size - 80) / (8 * ch) * 14;
500 nb_samples = (buf_size / 128) * 224 / ch;
505 if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
512 #define DK3_GET_NEXT_NIBBLE() \
513 if (decode_top_nibble_next) \
515 nibble = last_byte >> 4; \
516 decode_top_nibble_next = 0; \
522 last_byte = *src++; \
523 if (src >= buf + buf_size) \
525 nibble = last_byte & 0x0F; \
526 decode_top_nibble_next = 1; \
530 int *got_frame_ptr,
AVPacket *avpkt)
532 const uint8_t *buf = avpkt->
data;
533 int buf_size = avpkt->
size;
536 int n, m, channel, i;
541 int nb_samples, coded_samples, ret;
543 nb_samples =
get_nb_samples(avctx, buf, buf_size, &coded_samples);
544 if (nb_samples <= 0) {
560 if (coded_samples != nb_samples)
573 for (channel = 0; channel < avctx->
channels; channel++) {
576 cs = &(c->
status[channel]);
581 step_index = predictor & 0x7F;
587 int diff = (int)predictor - cs->
predictor;
603 samples = (
short *)c->
frame.
data[0] + channel;
605 for (m = 0; m < 32; m++) {
620 cs->
predictor = *samples++ = (int16_t)bytestream_get_le16(&src);
627 if (*src++)
av_log(avctx,
AV_LOG_ERROR,
"unused byte should be null but is %d!!\n", src[-1]);
630 for (n = (nb_samples - 1) / 8; n > 0; n--) {
631 for (i = 0; i < avctx->
channels; i++) {
633 for (m = 0; m < 4; m++) {
646 for (i = 0; i < avctx->
channels; i++)
649 for (i = 0; i < avctx->
channels; i++) {
654 for (i = 0; i < avctx->
channels; i++) {
657 for (n = nb_samples >> 1; n > 0; n--, src++) {
673 block_predictor = av_clip(*src++, 0, 6);
677 block_predictor = av_clip(*src++, 0, 6);
681 c->
status[0].
idelta = (int16_t)bytestream_get_le16(&src);
683 c->
status[1].
idelta = (int16_t)bytestream_get_le16(&src);
695 for(n = (nb_samples - 2) >> (1 - st); n > 0; n--, src++) {
705 for (channel = 0; channel < avctx->
channels; channel++) {
707 cs->
predictor = (int16_t)bytestream_get_le16(&src);
712 for (n = (nb_samples >> (1 - st)) - 1; n > 0; n--, src++) {
720 unsigned char last_byte = 0;
721 unsigned char nibble;
722 int decode_top_nibble_next = 0;
723 int end_of_packet = 0;
769 for (channel = 0; channel < avctx->
channels; channel++) {
771 cs->
predictor = (int16_t)bytestream_get_le16(&src);
776 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
792 while (src < buf + buf_size) {
799 while (buf_size >= 128) {
811 for (i=0; i<=st; i++)
813 for (i=0; i<=st; i++)
816 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
822 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
829 int32_t previous_left_sample, previous_right_sample;
830 int32_t current_left_sample, current_right_sample;
831 int32_t next_left_sample, next_right_sample;
832 int32_t coeff1l, coeff2l, coeff1r, coeff2r;
833 uint8_t shift_left, shift_right;
840 current_left_sample = (int16_t)bytestream_get_le16(&src);
841 previous_left_sample = (int16_t)bytestream_get_le16(&src);
842 current_right_sample = (int16_t)bytestream_get_le16(&src);
843 previous_right_sample = (int16_t)bytestream_get_le16(&src);
845 for (count1 = 0; count1 < nb_samples / 28; count1++) {
852 shift_left = 20 - (*src >> 4);
853 shift_right = 20 - (*src & 0x0F);
856 for (count2 = 0; count2 < 28; count2++) {
857 next_left_sample =
sign_extend(*src >> 4, 4) << shift_left;
858 next_right_sample =
sign_extend(*src, 4) << shift_right;
861 next_left_sample = (next_left_sample +
862 (current_left_sample * coeff1l) +
863 (previous_left_sample * coeff2l) + 0x80) >> 8;
864 next_right_sample = (next_right_sample +
865 (current_right_sample * coeff1r) +
866 (previous_right_sample * coeff2r) + 0x80) >> 8;
868 previous_left_sample = current_left_sample;
869 current_left_sample = av_clip_int16(next_left_sample);
870 previous_right_sample = current_right_sample;
871 current_right_sample = av_clip_int16(next_right_sample);
872 *samples++ = (
unsigned short)current_left_sample;
873 *samples++ = (
unsigned short)current_right_sample;
877 if (src - buf == buf_size - 2)
884 int coeff[2][2], shift[2];
886 for(channel = 0; channel < avctx->
channels; channel++) {
889 shift[channel] = 20 - (*src & 0x0F);
892 for (count1 = 0; count1 < nb_samples / 2; count1++) {
893 for(i = 4; i >= 0; i-=4) {
894 for(channel = 0; channel < avctx->
channels; channel++) {
895 int32_t sample =
sign_extend(src[channel] >> i, 4) << shift[channel];
907 src = buf + buf_size;
918 int32_t previous_sample, current_sample, next_sample;
919 int32_t coeff1, coeff2;
921 unsigned int channel;
924 const uint8_t *src_end = buf + buf_size;
929 for (channel=0; channel<avctx->
channels; channel++) {
930 int32_t offset = (big_endian ? bytestream_get_be32(&src)
931 : bytestream_get_le32(&src))
934 if ((offset < 0) || (offset >= src_end - src - 4))
break;
936 samplesC = samples + channel;
939 current_sample = (int16_t)bytestream_get_le16(&srcC);
940 previous_sample = (int16_t)bytestream_get_le16(&srcC);
946 for (count1 = 0; count1 < nb_samples / 28; count1++) {
949 if (srcC > src_end - 30*2)
break;
950 current_sample = (int16_t)bytestream_get_be16(&srcC);
951 previous_sample = (int16_t)bytestream_get_be16(&srcC);
953 for (count2=0; count2<28; count2++) {
954 *samplesC = (int16_t)bytestream_get_be16(&srcC);
960 shift = 20 - (*srcC++ & 0x0F);
962 if (srcC > src_end - 14)
break;
963 for (count2=0; count2<28; count2++) {
969 next_sample += (current_sample * coeff1) +
970 (previous_sample * coeff2);
971 next_sample = av_clip_int16(next_sample >> 8);
973 previous_sample = current_sample;
974 current_sample = next_sample;
975 *samplesC = current_sample;
982 }
else if (count != count1) {
984 count =
FFMAX(count, count1);
998 for (channel=0; channel<avctx->
channels; channel++) {
999 int coeff[2][4], shift[4];
1000 short *
s2, *s = &samples[channel];
1001 for (n=0; n<4; n++, s+=32*avctx->
channels) {
1004 shift[n] = 20 - (src[2] & 0x0F);
1005 for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->
channels)
1006 s2[0] = (src[0]&0xF0) + (src[1]<<8);
1009 for (m=2; m<32; m+=2) {
1010 s = &samples[m*avctx->
channels + channel];
1011 for (n=0; n<4; n++, src++, s+=32*avctx->
channels) {
1012 for (s2=s, i=0; i<8; i+=4, s2+=avctx->
channels) {
1015 + s2[-2*avctx->
channels] * coeff[1][n];
1016 s2[0] = av_clip_int16((level + pred + 0x80) >> 8);
1034 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1049 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1060 *samples++ = 128 * (*src++ - 0x80);
1062 *samples++ = 128 * (*src++ - 0x80);
1067 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1071 src[0] & 0x0F, 4, 0);
1074 for (n = nb_samples / 3; n > 0; n--, src++) {
1076 src[0] >> 5 , 3, 0);
1078 (src[0] >> 2) & 0x07, 3, 0);
1080 src[0] & 0x03, 2, 0);
1083 for (n = nb_samples >> (2 - st); n > 0; n--, src++) {
1085 src[0] >> 6 , 2, 2);
1087 (src[0] >> 4) & 0x03, 2, 2);
1089 (src[0] >> 2) & 0x03, 2, 2);
1091 src[0] & 0x03, 2, 2);
1099 int k0, signmask, nb_bits, count;
1100 int size = buf_size*8;
1108 k0 = 1 << (nb_bits-2);
1109 signmask = 1 << (nb_bits-1);
1112 for (i = 0; i < avctx->
channels; i++) {
1120 for (i = 0; i < avctx->
channels; i++) {
1135 if (delta & signmask)
1153 for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1168 for (i = 0; i < 32; i++)
1169 table[0][i] = (int16_t)bytestream_get_be16(&src);
1172 for (i = 0; i < 4; i++)
1173 prev[0][i] = (int16_t)bytestream_get_be16(&src);
1175 for (ch = 0; ch <= st; ch++) {
1176 samples = (
short *)c->
frame.
data[0] + ch;
1179 for (i = 0; i < nb_samples / 14; i++) {
1180 int index = (*src >> 4) & 7;
1181 unsigned int exp = *src++ & 15;
1182 int factor1 = table[ch][index * 2];
1183 int factor2 = table[ch][index * 2 + 1];
1186 for (n = 0; n < 14; n++) {
1191 sampledat = ((prev[ch][0]*factor1
1192 + prev[ch][1]*factor2) >> 11) + (sampledat << exp);
1193 *samples = av_clip_int16(sampledat);
1194 prev[ch][1] = prev[ch][0];
1195 prev[ch][0] = *samples++;
1217 #define ADPCM_DECODER(id_, name_, long_name_) \
1218 AVCodec ff_ ## name_ ## _decoder = { \
1220 .type = AVMEDIA_TYPE_AUDIO, \
1222 .priv_data_size = sizeof(ADPCMDecodeContext), \
1223 .init = adpcm_decode_init, \
1224 .decode = adpcm_decode_frame, \
1225 .capabilities = CODEC_CAP_DR1, \
1226 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \