libavcodec/adpcm.c
Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2001-2003 The ffmpeg Project
00003  *
00004  * This file is part of Libav.
00005  *
00006  * Libav is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * Libav is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with Libav; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019  */
00020 #include "avcodec.h"
00021 #include "internal.h"
00022 #include "get_bits.h"
00023 #include "put_bits.h"
00024 #include "bytestream.h"
00025 #include "adpcm.h"
00026 #include "adpcm_data.h"
00027 
00060 /* These are for CD-ROM XA ADPCM */
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 // padded to zero where table size is less then 16
00078 static const int swf_index_tables[4][16] = {
00079     /*2*/ { -1, 2 },
00080     /*3*/ { -1, -1, 2, 4 },
00081     /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
00082     /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
00083 };
00084 
00085 /* end of tables */
00086 
00087 typedef struct ADPCMDecodeContext {
00088     AVFrame frame;
00089     ADPCMChannelStatus status[6];
00090 } ADPCMDecodeContext;
00091 
00092 static av_cold int adpcm_decode_init(AVCodecContext * avctx)
00093 {
00094     ADPCMDecodeContext *c = avctx->priv_data;
00095     unsigned int min_channels = 1;
00096     unsigned int max_channels = 2;
00097 
00098     switch(avctx->codec->id) {
00099     case CODEC_ID_ADPCM_EA:
00100         min_channels = 2;
00101         break;
00102     case CODEC_ID_ADPCM_EA_R1:
00103     case CODEC_ID_ADPCM_EA_R2:
00104     case CODEC_ID_ADPCM_EA_R3:
00105     case CODEC_ID_ADPCM_EA_XAS:
00106         max_channels = 6;
00107         break;
00108     }
00109     if (avctx->channels < min_channels || avctx->channels > max_channels) {
00110         av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
00111         return AVERROR(EINVAL);
00112     }
00113 
00114     switch(avctx->codec->id) {
00115     case CODEC_ID_ADPCM_CT:
00116         c->status[0].step = c->status[1].step = 511;
00117         break;
00118     case CODEC_ID_ADPCM_IMA_WAV:
00119         if (avctx->bits_per_coded_sample != 4) {
00120             av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
00121             return -1;
00122         }
00123         break;
00124     case CODEC_ID_ADPCM_IMA_WS:
00125         if (avctx->extradata && avctx->extradata_size == 2 * 4) {
00126             c->status[0].predictor = AV_RL32(avctx->extradata);
00127             c->status[1].predictor = AV_RL32(avctx->extradata + 4);
00128         }
00129         break;
00130     default:
00131         break;
00132     }
00133     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00134 
00135     avcodec_get_frame_defaults(&c->frame);
00136     avctx->coded_frame = &c->frame;
00137 
00138     return 0;
00139 }
00140 
00141 static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
00142 {
00143     int step_index;
00144     int predictor;
00145     int sign, delta, diff, step;
00146 
00147     step = ff_adpcm_step_table[c->step_index];
00148     step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
00149     if (step_index < 0) step_index = 0;
00150     else if (step_index > 88) step_index = 88;
00151 
00152     sign = nibble & 8;
00153     delta = nibble & 7;
00154     /* perform direct multiplication instead of series of jumps proposed by
00155      * the reference ADPCM implementation since modern CPUs can do the mults
00156      * quickly enough */
00157     diff = ((2 * delta + 1) * step) >> shift;
00158     predictor = c->predictor;
00159     if (sign) predictor -= diff;
00160     else predictor += diff;
00161 
00162     c->predictor = av_clip_int16(predictor);
00163     c->step_index = step_index;
00164 
00165     return (short)c->predictor;
00166 }
00167 
00168 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
00169 {
00170     int step_index;
00171     int predictor;
00172     int diff, step;
00173 
00174     step = ff_adpcm_step_table[c->step_index];
00175     step_index = c->step_index + ff_adpcm_index_table[nibble];
00176     step_index = av_clip(step_index, 0, 88);
00177 
00178     diff = step >> 3;
00179     if (nibble & 4) diff += step;
00180     if (nibble & 2) diff += step >> 1;
00181     if (nibble & 1) diff += step >> 2;
00182 
00183     if (nibble & 8)
00184         predictor = c->predictor - diff;
00185     else
00186         predictor = c->predictor + diff;
00187 
00188     c->predictor = av_clip_int16(predictor);
00189     c->step_index = step_index;
00190 
00191     return c->predictor;
00192 }
00193 
00194 static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
00195 {
00196     int predictor;
00197 
00198     predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
00199     predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
00200 
00201     c->sample2 = c->sample1;
00202     c->sample1 = av_clip_int16(predictor);
00203     c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
00204     if (c->idelta < 16) c->idelta = 16;
00205 
00206     return c->sample1;
00207 }
00208 
00209 static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
00210 {
00211     int sign, delta, diff;
00212     int new_step;
00213 
00214     sign = nibble & 8;
00215     delta = nibble & 7;
00216     /* perform direct multiplication instead of series of jumps proposed by
00217      * the reference ADPCM implementation since modern CPUs can do the mults
00218      * quickly enough */
00219     diff = ((2 * delta + 1) * c->step) >> 3;
00220     /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
00221     c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
00222     c->predictor = av_clip_int16(c->predictor);
00223     /* calculate new step and clamp it to range 511..32767 */
00224     new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
00225     c->step = av_clip(new_step, 511, 32767);
00226 
00227     return (short)c->predictor;
00228 }
00229 
00230 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
00231 {
00232     int sign, delta, diff;
00233 
00234     sign = nibble & (1<<(size-1));
00235     delta = nibble & ((1<<(size-1))-1);
00236     diff = delta << (7 + c->step + shift);
00237 
00238     /* clamp result */
00239     c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
00240 
00241     /* calculate new step */
00242     if (delta >= (2*size - 3) && c->step < 3)
00243         c->step++;
00244     else if (delta == 0 && c->step > 0)
00245         c->step--;
00246 
00247     return (short) c->predictor;
00248 }
00249 
00250 static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
00251 {
00252     if(!c->step) {
00253         c->predictor = 0;
00254         c->step = 127;
00255     }
00256 
00257     c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
00258     c->predictor = av_clip_int16(c->predictor);
00259     c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
00260     c->step = av_clip(c->step, 127, 24567);
00261     return c->predictor;
00262 }
00263 
00264 static int xa_decode(AVCodecContext *avctx,
00265                      short *out, const unsigned char *in,
00266                      ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
00267 {
00268     int i, j;
00269     int shift,filter,f0,f1;
00270     int s_1,s_2;
00271     int d,s,t;
00272 
00273     for(i=0;i<4;i++) {
00274 
00275         shift  = 12 - (in[4+i*2] & 15);
00276         filter = in[4+i*2] >> 4;
00277         if (filter > 4) {
00278             av_log(avctx, AV_LOG_ERROR,
00279                    "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
00280                    filter);
00281             return AVERROR_INVALIDDATA;
00282         }
00283         f0 = xa_adpcm_table[filter][0];
00284         f1 = xa_adpcm_table[filter][1];
00285 
00286         s_1 = left->sample1;
00287         s_2 = left->sample2;
00288 
00289         for(j=0;j<28;j++) {
00290             d = in[16+i+j*4];
00291 
00292             t = (signed char)(d<<4)>>4;
00293             s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
00294             s_2 = s_1;
00295             s_1 = av_clip_int16(s);
00296             *out = s_1;
00297             out += inc;
00298         }
00299 
00300         if (inc==2) { /* stereo */
00301             left->sample1 = s_1;
00302             left->sample2 = s_2;
00303             s_1 = right->sample1;
00304             s_2 = right->sample2;
00305             out = out + 1 - 28*2;
00306         }
00307 
00308         shift  = 12 - (in[5+i*2] & 15);
00309         filter = in[5+i*2] >> 4;
00310         if (filter > 4) {
00311             av_log(avctx, AV_LOG_ERROR,
00312                    "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
00313                    filter);
00314             return AVERROR_INVALIDDATA;
00315         }
00316         f0 = xa_adpcm_table[filter][0];
00317         f1 = xa_adpcm_table[filter][1];
00318 
00319         for(j=0;j<28;j++) {
00320             d = in[16+i+j*4];
00321 
00322             t = (signed char)d >> 4;
00323             s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
00324             s_2 = s_1;
00325             s_1 = av_clip_int16(s);
00326             *out = s_1;
00327             out += inc;
00328         }
00329 
00330         if (inc==2) { /* stereo */
00331             right->sample1 = s_1;
00332             right->sample2 = s_2;
00333             out -= 1;
00334         } else {
00335             left->sample1 = s_1;
00336             left->sample2 = s_2;
00337         }
00338     }
00339 
00340     return 0;
00341 }
00342 
00352 static int get_nb_samples(AVCodecContext *avctx, const uint8_t *buf,
00353                           int buf_size, int *coded_samples)
00354 {
00355     ADPCMDecodeContext *s = avctx->priv_data;
00356     int nb_samples        = 0;
00357     int ch                = avctx->channels;
00358     int has_coded_samples = 0;
00359     int header_size;
00360 
00361     *coded_samples = 0;
00362 
00363     switch (avctx->codec->id) {
00364     /* constant, only check buf_size */
00365     case CODEC_ID_ADPCM_EA_XAS:
00366         if (buf_size < 76 * ch)
00367             return 0;
00368         nb_samples = 128;
00369         break;
00370     case CODEC_ID_ADPCM_IMA_QT:
00371         if (buf_size < 34 * ch)
00372             return 0;
00373         nb_samples = 64;
00374         break;
00375     /* simple 4-bit adpcm */
00376     case CODEC_ID_ADPCM_CT:
00377     case CODEC_ID_ADPCM_IMA_EA_SEAD:
00378     case CODEC_ID_ADPCM_IMA_WS:
00379     case CODEC_ID_ADPCM_YAMAHA:
00380         nb_samples = buf_size * 2 / ch;
00381         break;
00382     }
00383     if (nb_samples)
00384         return nb_samples;
00385 
00386     /* simple 4-bit adpcm, with header */
00387     header_size = 0;
00388     switch (avctx->codec->id) {
00389         case CODEC_ID_ADPCM_4XM:
00390         case CODEC_ID_ADPCM_IMA_ISS:     header_size = 4 * ch;      break;
00391         case CODEC_ID_ADPCM_IMA_AMV:     header_size = 8;           break;
00392         case CODEC_ID_ADPCM_IMA_SMJPEG:  header_size = 4;           break;
00393     }
00394     if (header_size > 0)
00395         return (buf_size - header_size) * 2 / ch;
00396 
00397     /* more complex formats */
00398     switch (avctx->codec->id) {
00399     case CODEC_ID_ADPCM_EA:
00400         has_coded_samples = 1;
00401         if (buf_size < 4)
00402             return 0;
00403         *coded_samples  = AV_RL32(buf);
00404         *coded_samples -= *coded_samples % 28;
00405         nb_samples      = (buf_size - 12) / 30 * 28;
00406         break;
00407     case CODEC_ID_ADPCM_IMA_EA_EACS:
00408         has_coded_samples = 1;
00409         if (buf_size < 4)
00410             return 0;
00411         *coded_samples = AV_RL32(buf);
00412         nb_samples     = (buf_size - (4 + 8 * ch)) * 2 / ch;
00413         break;
00414     case CODEC_ID_ADPCM_EA_MAXIS_XA:
00415         nb_samples = ((buf_size - ch) / (2 * ch)) * 2 * ch;
00416         break;
00417     case CODEC_ID_ADPCM_EA_R1:
00418     case CODEC_ID_ADPCM_EA_R2:
00419     case CODEC_ID_ADPCM_EA_R3:
00420         /* maximum number of samples */
00421         /* has internal offsets and a per-frame switch to signal raw 16-bit */
00422         has_coded_samples = 1;
00423         if (buf_size < 4)
00424             return 0;
00425         switch (avctx->codec->id) {
00426         case CODEC_ID_ADPCM_EA_R1:
00427             header_size    = 4 + 9 * ch;
00428             *coded_samples = AV_RL32(buf);
00429             break;
00430         case CODEC_ID_ADPCM_EA_R2:
00431             header_size    = 4 + 5 * ch;
00432             *coded_samples = AV_RL32(buf);
00433             break;
00434         case CODEC_ID_ADPCM_EA_R3:
00435             header_size    = 4 + 5 * ch;
00436             *coded_samples = AV_RB32(buf);
00437             break;
00438         }
00439         *coded_samples -= *coded_samples % 28;
00440         nb_samples      = (buf_size - header_size) * 2 / ch;
00441         nb_samples     -= nb_samples % 28;
00442         break;
00443     case CODEC_ID_ADPCM_IMA_DK3:
00444         if (avctx->block_align > 0)
00445             buf_size = FFMIN(buf_size, avctx->block_align);
00446         nb_samples = ((buf_size - 16) * 8 / 3) / ch;
00447         break;
00448     case CODEC_ID_ADPCM_IMA_DK4:
00449         nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
00450         break;
00451     case CODEC_ID_ADPCM_IMA_WAV:
00452         if (avctx->block_align > 0)
00453             buf_size = FFMIN(buf_size, avctx->block_align);
00454         nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
00455         break;
00456     case CODEC_ID_ADPCM_MS:
00457         if (avctx->block_align > 0)
00458             buf_size = FFMIN(buf_size, avctx->block_align);
00459         nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
00460         break;
00461     case CODEC_ID_ADPCM_SBPRO_2:
00462     case CODEC_ID_ADPCM_SBPRO_3:
00463     case CODEC_ID_ADPCM_SBPRO_4:
00464     {
00465         int samples_per_byte;
00466         switch (avctx->codec->id) {
00467         case CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
00468         case CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
00469         case CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
00470         }
00471         if (!s->status[0].step_index) {
00472             nb_samples++;
00473             buf_size -= ch;
00474         }
00475         nb_samples += buf_size * samples_per_byte / ch;
00476         break;
00477     }
00478     case CODEC_ID_ADPCM_SWF:
00479     {
00480         int buf_bits       = buf_size * 8 - 2;
00481         int nbits          = (buf[0] >> 6) + 2;
00482         int block_hdr_size = 22 * ch;
00483         int block_size     = block_hdr_size + nbits * ch * 4095;
00484         int nblocks        = buf_bits / block_size;
00485         int bits_left      = buf_bits - nblocks * block_size;
00486         nb_samples         = nblocks * 4096;
00487         if (bits_left >= block_hdr_size)
00488             nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
00489         break;
00490     }
00491     case CODEC_ID_ADPCM_THP:
00492         has_coded_samples = 1;
00493         if (buf_size < 8)
00494             return 0;
00495         *coded_samples  = AV_RB32(&buf[4]);
00496         *coded_samples -= *coded_samples % 14;
00497         nb_samples      = (buf_size - 80) / (8 * ch) * 14;
00498         break;
00499     case CODEC_ID_ADPCM_XA:
00500         nb_samples = (buf_size / 128) * 224 / ch;
00501         break;
00502     }
00503 
00504     /* validate coded sample count */
00505     if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
00506         return AVERROR_INVALIDDATA;
00507 
00508     return nb_samples;
00509 }
00510 
00511 /* DK3 ADPCM support macro */
00512 #define DK3_GET_NEXT_NIBBLE() \
00513     if (decode_top_nibble_next) \
00514     { \
00515         nibble = last_byte >> 4; \
00516         decode_top_nibble_next = 0; \
00517     } \
00518     else \
00519     { \
00520         if (end_of_packet) \
00521             break; \
00522         last_byte = *src++; \
00523         if (src >= buf + buf_size) \
00524             end_of_packet = 1; \
00525         nibble = last_byte & 0x0F; \
00526         decode_top_nibble_next = 1; \
00527     }
00528 
00529 static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
00530                               int *got_frame_ptr, AVPacket *avpkt)
00531 {
00532     const uint8_t *buf = avpkt->data;
00533     int buf_size = avpkt->size;
00534     ADPCMDecodeContext *c = avctx->priv_data;
00535     ADPCMChannelStatus *cs;
00536     int n, m, channel, i;
00537     short *samples;
00538     const uint8_t *src;
00539     int st; /* stereo */
00540     int count1, count2;
00541     int nb_samples, coded_samples, ret;
00542 
00543     nb_samples = get_nb_samples(avctx, buf, buf_size, &coded_samples);
00544     if (nb_samples <= 0) {
00545         av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
00546         return AVERROR_INVALIDDATA;
00547     }
00548 
00549     /* get output buffer */
00550     c->frame.nb_samples = nb_samples;
00551     if ((ret = ff_get_buffer(avctx, &c->frame)) < 0) {
00552         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00553         return ret;
00554     }
00555     samples = (short *)c->frame.data[0];
00556 
00557     /* use coded_samples when applicable */
00558     /* it is always <= nb_samples, so the output buffer will be large enough */
00559     if (coded_samples) {
00560         if (coded_samples != nb_samples)
00561             av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
00562         c->frame.nb_samples = nb_samples = coded_samples;
00563     }
00564 
00565     src = buf;
00566 
00567     st = avctx->channels == 2 ? 1 : 0;
00568 
00569     switch(avctx->codec->id) {
00570     case CODEC_ID_ADPCM_IMA_QT:
00571         /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
00572            Channel data is interleaved per-chunk. */
00573         for (channel = 0; channel < avctx->channels; channel++) {
00574             int16_t predictor;
00575             int step_index;
00576             cs = &(c->status[channel]);
00577             /* (pppppp) (piiiiiii) */
00578 
00579             /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
00580             predictor = AV_RB16(src);
00581             step_index = predictor & 0x7F;
00582             predictor &= 0xFF80;
00583 
00584             src += 2;
00585 
00586             if (cs->step_index == step_index) {
00587                 int diff = (int)predictor - cs->predictor;
00588                 if (diff < 0)
00589                     diff = - diff;
00590                 if (diff > 0x7f)
00591                     goto update;
00592             } else {
00593             update:
00594                 cs->step_index = step_index;
00595                 cs->predictor = predictor;
00596             }
00597 
00598             if (cs->step_index > 88){
00599                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
00600                 cs->step_index = 88;
00601             }
00602 
00603             samples = (short *)c->frame.data[0] + channel;
00604 
00605             for (m = 0; m < 32; m++) {
00606                 *samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);
00607                 samples += avctx->channels;
00608                 *samples = adpcm_ima_qt_expand_nibble(cs, src[0] >> 4  , 3);
00609                 samples += avctx->channels;
00610                 src ++;
00611             }
00612         }
00613         break;
00614     case CODEC_ID_ADPCM_IMA_WAV:
00615         if (avctx->block_align != 0 && buf_size > avctx->block_align)
00616             buf_size = avctx->block_align;
00617 
00618         for(i=0; i<avctx->channels; i++){
00619             cs = &(c->status[i]);
00620             cs->predictor = *samples++ = (int16_t)bytestream_get_le16(&src);
00621 
00622             cs->step_index = *src++;
00623             if (cs->step_index > 88){
00624                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
00625                 cs->step_index = 88;
00626             }
00627             if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
00628         }
00629 
00630         for (n = (nb_samples - 1) / 8; n > 0; n--) {
00631             for (i = 0; i < avctx->channels; i++) {
00632                 cs = &c->status[i];
00633                 for (m = 0; m < 4; m++) {
00634                     uint8_t v = *src++;
00635                     *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
00636                     samples += avctx->channels;
00637                     *samples = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
00638                     samples += avctx->channels;
00639                 }
00640                 samples -= 8 * avctx->channels - 1;
00641             }
00642             samples += 7 * avctx->channels;
00643         }
00644         break;
00645     case CODEC_ID_ADPCM_4XM:
00646         for (i = 0; i < avctx->channels; i++)
00647             c->status[i].predictor= (int16_t)bytestream_get_le16(&src);
00648 
00649         for (i = 0; i < avctx->channels; i++) {
00650             c->status[i].step_index= (int16_t)bytestream_get_le16(&src);
00651             c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
00652         }
00653 
00654         for (i = 0; i < avctx->channels; i++) {
00655             samples = (short *)c->frame.data[0] + i;
00656             cs = &c->status[i];
00657             for (n = nb_samples >> 1; n > 0; n--, src++) {
00658                 uint8_t v = *src;
00659                 *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
00660                 samples += avctx->channels;
00661                 *samples = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
00662                 samples += avctx->channels;
00663             }
00664         }
00665         break;
00666     case CODEC_ID_ADPCM_MS:
00667     {
00668         int block_predictor;
00669 
00670         if (avctx->block_align != 0 && buf_size > avctx->block_align)
00671             buf_size = avctx->block_align;
00672 
00673         block_predictor = av_clip(*src++, 0, 6);
00674         c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
00675         c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
00676         if (st) {
00677             block_predictor = av_clip(*src++, 0, 6);
00678             c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
00679             c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
00680         }
00681         c->status[0].idelta = (int16_t)bytestream_get_le16(&src);
00682         if (st){
00683             c->status[1].idelta = (int16_t)bytestream_get_le16(&src);
00684         }
00685 
00686         c->status[0].sample1 = bytestream_get_le16(&src);
00687         if (st) c->status[1].sample1 = bytestream_get_le16(&src);
00688         c->status[0].sample2 = bytestream_get_le16(&src);
00689         if (st) c->status[1].sample2 = bytestream_get_le16(&src);
00690 
00691         *samples++ = c->status[0].sample2;
00692         if (st) *samples++ = c->status[1].sample2;
00693         *samples++ = c->status[0].sample1;
00694         if (st) *samples++ = c->status[1].sample1;
00695         for(n = (nb_samples - 2) >> (1 - st); n > 0; n--, src++) {
00696             *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], src[0] >> 4  );
00697             *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
00698         }
00699         break;
00700     }
00701     case CODEC_ID_ADPCM_IMA_DK4:
00702         if (avctx->block_align != 0 && buf_size > avctx->block_align)
00703             buf_size = avctx->block_align;
00704 
00705         for (channel = 0; channel < avctx->channels; channel++) {
00706             cs = &c->status[channel];
00707             cs->predictor  = (int16_t)bytestream_get_le16(&src);
00708             cs->step_index = av_clip(*src++, 0, 88);
00709             src++;
00710             *samples++ = cs->predictor;
00711         }
00712         for (n = (nb_samples >> (1 - st)) - 1; n > 0; n--, src++) {
00713             uint8_t v = *src;
00714             *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
00715             *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
00716         }
00717         break;
00718     case CODEC_ID_ADPCM_IMA_DK3:
00719     {
00720         unsigned char last_byte = 0;
00721         unsigned char nibble;
00722         int decode_top_nibble_next = 0;
00723         int end_of_packet = 0;
00724         int diff_channel;
00725 
00726         if (avctx->block_align != 0 && buf_size > avctx->block_align)
00727             buf_size = avctx->block_align;
00728 
00729         c->status[0].predictor  = (int16_t)AV_RL16(src + 10);
00730         c->status[1].predictor  = (int16_t)AV_RL16(src + 12);
00731         c->status[0].step_index = av_clip(src[14], 0, 88);
00732         c->status[1].step_index = av_clip(src[15], 0, 88);
00733         /* sign extend the predictors */
00734         src += 16;
00735         diff_channel = c->status[1].predictor;
00736 
00737         /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
00738          * the buffer is consumed */
00739         while (1) {
00740 
00741             /* for this algorithm, c->status[0] is the sum channel and
00742              * c->status[1] is the diff channel */
00743 
00744             /* process the first predictor of the sum channel */
00745             DK3_GET_NEXT_NIBBLE();
00746             adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
00747 
00748             /* process the diff channel predictor */
00749             DK3_GET_NEXT_NIBBLE();
00750             adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
00751 
00752             /* process the first pair of stereo PCM samples */
00753             diff_channel = (diff_channel + c->status[1].predictor) / 2;
00754             *samples++ = c->status[0].predictor + c->status[1].predictor;
00755             *samples++ = c->status[0].predictor - c->status[1].predictor;
00756 
00757             /* process the second predictor of the sum channel */
00758             DK3_GET_NEXT_NIBBLE();
00759             adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
00760 
00761             /* process the second pair of stereo PCM samples */
00762             diff_channel = (diff_channel + c->status[1].predictor) / 2;
00763             *samples++ = c->status[0].predictor + c->status[1].predictor;
00764             *samples++ = c->status[0].predictor - c->status[1].predictor;
00765         }
00766         break;
00767     }
00768     case CODEC_ID_ADPCM_IMA_ISS:
00769         for (channel = 0; channel < avctx->channels; channel++) {
00770             cs = &c->status[channel];
00771             cs->predictor  = (int16_t)bytestream_get_le16(&src);
00772             cs->step_index = av_clip(*src++, 0, 88);
00773             src++;
00774         }
00775 
00776         for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
00777             uint8_t v1, v2;
00778             uint8_t v = *src;
00779             /* nibbles are swapped for mono */
00780             if (st) {
00781                 v1 = v >> 4;
00782                 v2 = v & 0x0F;
00783             } else {
00784                 v2 = v >> 4;
00785                 v1 = v & 0x0F;
00786             }
00787             *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
00788             *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
00789         }
00790         break;
00791     case CODEC_ID_ADPCM_IMA_WS:
00792         while (src < buf + buf_size) {
00793             uint8_t v = *src++;
00794             *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
00795             *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
00796         }
00797         break;
00798     case CODEC_ID_ADPCM_XA:
00799         while (buf_size >= 128) {
00800             if ((ret = xa_decode(avctx, samples, src, &c->status[0],
00801                                  &c->status[1], avctx->channels)) < 0)
00802                 return ret;
00803             src += 128;
00804             samples += 28 * 8;
00805             buf_size -= 128;
00806         }
00807         break;
00808     case CODEC_ID_ADPCM_IMA_EA_EACS:
00809         src += 4; // skip sample count (already read)
00810 
00811         for (i=0; i<=st; i++)
00812             c->status[i].step_index = av_clip(bytestream_get_le32(&src), 0, 88);
00813         for (i=0; i<=st; i++)
00814             c->status[i].predictor  = bytestream_get_le32(&src);
00815 
00816         for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
00817             *samples++ = adpcm_ima_expand_nibble(&c->status[0],  *src>>4,   3);
00818             *samples++ = adpcm_ima_expand_nibble(&c->status[st], *src&0x0F, 3);
00819         }
00820         break;
00821     case CODEC_ID_ADPCM_IMA_EA_SEAD:
00822         for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
00823             *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] >> 4, 6);
00824             *samples++ = adpcm_ima_expand_nibble(&c->status[st],src[0]&0x0F, 6);
00825         }
00826         break;
00827     case CODEC_ID_ADPCM_EA:
00828     {
00829         int32_t previous_left_sample, previous_right_sample;
00830         int32_t current_left_sample, current_right_sample;
00831         int32_t next_left_sample, next_right_sample;
00832         int32_t coeff1l, coeff2l, coeff1r, coeff2r;
00833         uint8_t shift_left, shift_right;
00834 
00835         /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
00836            each coding 28 stereo samples. */
00837 
00838         src += 4; // skip sample count (already read)
00839 
00840         current_left_sample   = (int16_t)bytestream_get_le16(&src);
00841         previous_left_sample  = (int16_t)bytestream_get_le16(&src);
00842         current_right_sample  = (int16_t)bytestream_get_le16(&src);
00843         previous_right_sample = (int16_t)bytestream_get_le16(&src);
00844 
00845         for (count1 = 0; count1 < nb_samples / 28; count1++) {
00846             coeff1l = ea_adpcm_table[ *src >> 4       ];
00847             coeff2l = ea_adpcm_table[(*src >> 4  ) + 4];
00848             coeff1r = ea_adpcm_table[*src & 0x0F];
00849             coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
00850             src++;
00851 
00852             shift_left  = 20 - (*src >> 4);
00853             shift_right = 20 - (*src & 0x0F);
00854             src++;
00855 
00856             for (count2 = 0; count2 < 28; count2++) {
00857                 next_left_sample  = sign_extend(*src >> 4, 4) << shift_left;
00858                 next_right_sample = sign_extend(*src,      4) << shift_right;
00859                 src++;
00860 
00861                 next_left_sample = (next_left_sample +
00862                     (current_left_sample * coeff1l) +
00863                     (previous_left_sample * coeff2l) + 0x80) >> 8;
00864                 next_right_sample = (next_right_sample +
00865                     (current_right_sample * coeff1r) +
00866                     (previous_right_sample * coeff2r) + 0x80) >> 8;
00867 
00868                 previous_left_sample = current_left_sample;
00869                 current_left_sample = av_clip_int16(next_left_sample);
00870                 previous_right_sample = current_right_sample;
00871                 current_right_sample = av_clip_int16(next_right_sample);
00872                 *samples++ = (unsigned short)current_left_sample;
00873                 *samples++ = (unsigned short)current_right_sample;
00874             }
00875         }
00876 
00877         if (src - buf == buf_size - 2)
00878             src += 2; // Skip terminating 0x0000
00879 
00880         break;
00881     }
00882     case CODEC_ID_ADPCM_EA_MAXIS_XA:
00883     {
00884         int coeff[2][2], shift[2];
00885 
00886         for(channel = 0; channel < avctx->channels; channel++) {
00887             for (i=0; i<2; i++)
00888                 coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i];
00889             shift[channel] = 20 - (*src & 0x0F);
00890             src++;
00891         }
00892         for (count1 = 0; count1 < nb_samples / 2; count1++) {
00893             for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
00894                 for(channel = 0; channel < avctx->channels; channel++) {
00895                     int32_t sample = sign_extend(src[channel] >> i, 4) << shift[channel];
00896                     sample = (sample +
00897                              c->status[channel].sample1 * coeff[channel][0] +
00898                              c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
00899                     c->status[channel].sample2 = c->status[channel].sample1;
00900                     c->status[channel].sample1 = av_clip_int16(sample);
00901                     *samples++ = c->status[channel].sample1;
00902                 }
00903             }
00904             src+=avctx->channels;
00905         }
00906         /* consume whole packet */
00907         src = buf + buf_size;
00908         break;
00909     }
00910     case CODEC_ID_ADPCM_EA_R1:
00911     case CODEC_ID_ADPCM_EA_R2:
00912     case CODEC_ID_ADPCM_EA_R3: {
00913         /* channel numbering
00914            2chan: 0=fl, 1=fr
00915            4chan: 0=fl, 1=rl, 2=fr, 3=rr
00916            6chan: 0=fl, 1=c,  2=fr, 3=rl,  4=rr, 5=sub */
00917         const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3;
00918         int32_t previous_sample, current_sample, next_sample;
00919         int32_t coeff1, coeff2;
00920         uint8_t shift;
00921         unsigned int channel;
00922         uint16_t *samplesC;
00923         const uint8_t *srcC;
00924         const uint8_t *src_end = buf + buf_size;
00925         int count = 0;
00926 
00927         src += 4; // skip sample count (already read)
00928 
00929         for (channel=0; channel<avctx->channels; channel++) {
00930             int32_t offset = (big_endian ? bytestream_get_be32(&src)
00931                                          : bytestream_get_le32(&src))
00932                            + (avctx->channels-channel-1) * 4;
00933 
00934             if ((offset < 0) || (offset >= src_end - src - 4)) break;
00935             srcC  = src + offset;
00936             samplesC = samples + channel;
00937 
00938             if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) {
00939                 current_sample  = (int16_t)bytestream_get_le16(&srcC);
00940                 previous_sample = (int16_t)bytestream_get_le16(&srcC);
00941             } else {
00942                 current_sample  = c->status[channel].predictor;
00943                 previous_sample = c->status[channel].prev_sample;
00944             }
00945 
00946             for (count1 = 0; count1 < nb_samples / 28; count1++) {
00947                 if (*srcC == 0xEE) {  /* only seen in R2 and R3 */
00948                     srcC++;
00949                     if (srcC > src_end - 30*2) break;
00950                     current_sample  = (int16_t)bytestream_get_be16(&srcC);
00951                     previous_sample = (int16_t)bytestream_get_be16(&srcC);
00952 
00953                     for (count2=0; count2<28; count2++) {
00954                         *samplesC = (int16_t)bytestream_get_be16(&srcC);
00955                         samplesC += avctx->channels;
00956                     }
00957                 } else {
00958                     coeff1 = ea_adpcm_table[ *srcC>>4     ];
00959                     coeff2 = ea_adpcm_table[(*srcC>>4) + 4];
00960                     shift = 20 - (*srcC++ & 0x0F);
00961 
00962                     if (srcC > src_end - 14) break;
00963                     for (count2=0; count2<28; count2++) {
00964                         if (count2 & 1)
00965                             next_sample = sign_extend(*srcC++,    4) << shift;
00966                         else
00967                             next_sample = sign_extend(*srcC >> 4, 4) << shift;
00968 
00969                         next_sample += (current_sample  * coeff1) +
00970                                        (previous_sample * coeff2);
00971                         next_sample = av_clip_int16(next_sample >> 8);
00972 
00973                         previous_sample = current_sample;
00974                         current_sample  = next_sample;
00975                         *samplesC = current_sample;
00976                         samplesC += avctx->channels;
00977                     }
00978                 }
00979             }
00980             if (!count) {
00981                 count = count1;
00982             } else if (count != count1) {
00983                 av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
00984                 count = FFMAX(count, count1);
00985             }
00986 
00987             if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) {
00988                 c->status[channel].predictor   = current_sample;
00989                 c->status[channel].prev_sample = previous_sample;
00990             }
00991         }
00992 
00993         c->frame.nb_samples = count * 28;
00994         src = src_end;
00995         break;
00996     }
00997     case CODEC_ID_ADPCM_EA_XAS:
00998         for (channel=0; channel<avctx->channels; channel++) {
00999             int coeff[2][4], shift[4];
01000             short *s2, *s = &samples[channel];
01001             for (n=0; n<4; n++, s+=32*avctx->channels) {
01002                 for (i=0; i<2; i++)
01003                     coeff[i][n] = ea_adpcm_table[(src[0]&0x0F)+4*i];
01004                 shift[n] = 20 - (src[2] & 0x0F);
01005                 for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->channels)
01006                     s2[0] = (src[0]&0xF0) + (src[1]<<8);
01007             }
01008 
01009             for (m=2; m<32; m+=2) {
01010                 s = &samples[m*avctx->channels + channel];
01011                 for (n=0; n<4; n++, src++, s+=32*avctx->channels) {
01012                     for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) {
01013                         int level = sign_extend(*src >> (4 - i), 4) << shift[n];
01014                         int pred  = s2[-1*avctx->channels] * coeff[0][n]
01015                                   + s2[-2*avctx->channels] * coeff[1][n];
01016                         s2[0] = av_clip_int16((level + pred + 0x80) >> 8);
01017                     }
01018                 }
01019             }
01020         }
01021         break;
01022     case CODEC_ID_ADPCM_IMA_AMV:
01023     case CODEC_ID_ADPCM_IMA_SMJPEG:
01024         if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) {
01025             c->status[0].predictor = sign_extend(bytestream_get_le16(&src), 16);
01026             c->status[0].step_index = av_clip(bytestream_get_le16(&src), 0, 88);
01027             src += 4;
01028         } else {
01029             c->status[0].predictor = sign_extend(bytestream_get_be16(&src), 16);
01030             c->status[0].step_index = av_clip(bytestream_get_byte(&src), 0, 88);
01031             src += 1;
01032         }
01033 
01034         for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
01035             char hi, lo;
01036             lo = *src & 0x0F;
01037             hi = *src >> 4;
01038 
01039             if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)
01040                 FFSWAP(char, hi, lo);
01041 
01042             *samples++ = adpcm_ima_expand_nibble(&c->status[0],
01043                 lo, 3);
01044             *samples++ = adpcm_ima_expand_nibble(&c->status[0],
01045                 hi, 3);
01046         }
01047         break;
01048     case CODEC_ID_ADPCM_CT:
01049         for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
01050             uint8_t v = *src;
01051             *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
01052             *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
01053         }
01054         break;
01055     case CODEC_ID_ADPCM_SBPRO_4:
01056     case CODEC_ID_ADPCM_SBPRO_3:
01057     case CODEC_ID_ADPCM_SBPRO_2:
01058         if (!c->status[0].step_index) {
01059             /* the first byte is a raw sample */
01060             *samples++ = 128 * (*src++ - 0x80);
01061             if (st)
01062               *samples++ = 128 * (*src++ - 0x80);
01063             c->status[0].step_index = 1;
01064             nb_samples--;
01065         }
01066         if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
01067             for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
01068                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01069                     src[0] >> 4, 4, 0);
01070                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
01071                     src[0] & 0x0F, 4, 0);
01072             }
01073         } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
01074             for (n = nb_samples / 3; n > 0; n--, src++) {
01075                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01076                      src[0] >> 5        , 3, 0);
01077                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01078                     (src[0] >> 2) & 0x07, 3, 0);
01079                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01080                     src[0] & 0x03, 2, 0);
01081             }
01082         } else {
01083             for (n = nb_samples >> (2 - st); n > 0; n--, src++) {
01084                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01085                      src[0] >> 6        , 2, 2);
01086                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
01087                     (src[0] >> 4) & 0x03, 2, 2);
01088                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
01089                     (src[0] >> 2) & 0x03, 2, 2);
01090                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
01091                     src[0] & 0x03, 2, 2);
01092             }
01093         }
01094         break;
01095     case CODEC_ID_ADPCM_SWF:
01096     {
01097         GetBitContext gb;
01098         const int *table;
01099         int k0, signmask, nb_bits, count;
01100         int size = buf_size*8;
01101 
01102         init_get_bits(&gb, buf, size);
01103 
01104         //read bits & initial values
01105         nb_bits = get_bits(&gb, 2)+2;
01106         //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
01107         table = swf_index_tables[nb_bits-2];
01108         k0 = 1 << (nb_bits-2);
01109         signmask = 1 << (nb_bits-1);
01110 
01111         while (get_bits_count(&gb) <= size - 22*avctx->channels) {
01112             for (i = 0; i < avctx->channels; i++) {
01113                 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
01114                 c->status[i].step_index = get_bits(&gb, 6);
01115             }
01116 
01117             for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
01118                 int i;
01119 
01120                 for (i = 0; i < avctx->channels; i++) {
01121                     // similar to IMA adpcm
01122                     int delta = get_bits(&gb, nb_bits);
01123                     int step = ff_adpcm_step_table[c->status[i].step_index];
01124                     long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
01125                     int k = k0;
01126 
01127                     do {
01128                         if (delta & k)
01129                             vpdiff += step;
01130                         step >>= 1;
01131                         k >>= 1;
01132                     } while(k);
01133                     vpdiff += step;
01134 
01135                     if (delta & signmask)
01136                         c->status[i].predictor -= vpdiff;
01137                     else
01138                         c->status[i].predictor += vpdiff;
01139 
01140                     c->status[i].step_index += table[delta & (~signmask)];
01141 
01142                     c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
01143                     c->status[i].predictor = av_clip_int16(c->status[i].predictor);
01144 
01145                     *samples++ = c->status[i].predictor;
01146                 }
01147             }
01148         }
01149         src += buf_size;
01150         break;
01151     }
01152     case CODEC_ID_ADPCM_YAMAHA:
01153         for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
01154             uint8_t v = *src;
01155             *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
01156             *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
01157         }
01158         break;
01159     case CODEC_ID_ADPCM_THP:
01160     {
01161         int table[2][16];
01162         int prev[2][2];
01163         int ch;
01164 
01165         src += 4; // skip channel size
01166         src += 4; // skip number of samples (already read)
01167 
01168         for (i = 0; i < 32; i++)
01169             table[0][i] = (int16_t)bytestream_get_be16(&src);
01170 
01171         /* Initialize the previous sample.  */
01172         for (i = 0; i < 4; i++)
01173             prev[0][i] = (int16_t)bytestream_get_be16(&src);
01174 
01175         for (ch = 0; ch <= st; ch++) {
01176             samples = (short *)c->frame.data[0] + ch;
01177 
01178             /* Read in every sample for this channel.  */
01179             for (i = 0; i < nb_samples / 14; i++) {
01180                 int index = (*src >> 4) & 7;
01181                 unsigned int exp = *src++ & 15;
01182                 int factor1 = table[ch][index * 2];
01183                 int factor2 = table[ch][index * 2 + 1];
01184 
01185                 /* Decode 14 samples.  */
01186                 for (n = 0; n < 14; n++) {
01187                     int32_t sampledat;
01188                     if(n&1) sampledat = sign_extend(*src++, 4);
01189                     else    sampledat = sign_extend(*src >> 4, 4);
01190 
01191                     sampledat = ((prev[ch][0]*factor1
01192                                 + prev[ch][1]*factor2) >> 11) + (sampledat << exp);
01193                     *samples = av_clip_int16(sampledat);
01194                     prev[ch][1] = prev[ch][0];
01195                     prev[ch][0] = *samples++;
01196 
01197                     /* In case of stereo, skip one sample, this sample
01198                        is for the other channel.  */
01199                     samples += st;
01200                 }
01201             }
01202         }
01203         break;
01204     }
01205 
01206     default:
01207         return -1;
01208     }
01209 
01210     *got_frame_ptr   = 1;
01211     *(AVFrame *)data = c->frame;
01212 
01213     return src - buf;
01214 }
01215 
01216 
01217 #define ADPCM_DECODER(id_, name_, long_name_)               \
01218 AVCodec ff_ ## name_ ## _decoder = {                        \
01219     .name           = #name_,                               \
01220     .type           = AVMEDIA_TYPE_AUDIO,                   \
01221     .id             = id_,                                  \
01222     .priv_data_size = sizeof(ADPCMDecodeContext),           \
01223     .init           = adpcm_decode_init,                    \
01224     .decode         = adpcm_decode_frame,                   \
01225     .capabilities   = CODEC_CAP_DR1,                        \
01226     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
01227 }
01228 
01229 /* Note: Do not forget to add new entries to the Makefile as well. */
01230 ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
01231 ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
01232 ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
01233 ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
01234 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
01235 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
01236 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
01237 ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
01238 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
01239 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
01240 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
01241 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
01242 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
01243 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
01244 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
01245 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
01246 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
01247 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
01248 ADPCM_DECODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
01249 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
01250 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
01251 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
01252 ADPCM_DECODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
01253 ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
01254 ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
01255 ADPCM_DECODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");