adpcm.c 31.6 KB
Newer Older
1 2
/*
 * ADPCM codecs
3
 * Copyright (c) 2001-2003 The ffmpeg Project
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "avcodec.h"

Michael Niedermayer's avatar
Michael Niedermayer committed
21 22 23
/**
 * @file adpcm.c
 * ADPCM codecs.
24
 * First version by Francois Revol (revol@free.fr)
25
 * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
26
 *   by Mike Melanson (melanson@pcisys.net)
27
 * CD-ROM XA ADPCM codec by BERO
28
 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
29 30 31 32
 *
 * Features and limitations:
 *
 * Reference documents:
33
 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
34 35 36
 * http://www.geocities.com/SiliconValley/8682/aud3.txt
 * http://openquicktime.sourceforge.net/plugins.htm
 * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
37 38
 * http://www.cs.ucla.edu/~leec/mediabench/applications.html
 * SoX source code http://home.sprynet.com/~cbagwell/sox.html
39 40 41 42 43
 *
 * CD-ROM XA:
 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html
 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html
 * readstr http://www.geocities.co.jp/Playtown/2004/
44 45 46 47 48 49 50 51 52 53 54 55
 */

#define BLKSIZE 1024

#define CLAMP_TO_SHORT(value) \
if (value > 32767) \
    value = 32767; \
else if (value < -32768) \
    value = -32768; \

/* step_table[] and index_table[] are from the ADPCM reference source */
/* This is the index table: */
56
static const int index_table[16] = {
57 58 59 60
    -1, -1, -1, -1, 2, 4, 6, 8,
    -1, -1, -1, -1, 2, 4, 6, 8,
};

Michael Niedermayer's avatar
Michael Niedermayer committed
61 62
/** 
 * This is the step table. Note that many programs use slight deviations from
63 64
 * this table, but such deviations are negligible:
 */
65
static const int step_table[89] = {
66 67 68 69 70 71 72 73 74 75 76
    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};

77
/* These are for MS-ADPCM */
78
/* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */
79
static const int AdaptationTable[] = {
80 81 82 83
        230, 230, 230, 230, 307, 409, 512, 614,
        768, 614, 512, 409, 307, 230, 230, 230
};

84
static const int AdaptCoeff1[] = {
85 86 87
        256, 512, 0, 192, 240, 460, 392
};

88
static const int AdaptCoeff2[] = {
89 90 91
        0, -256, 0, 64, 0, -208, -232
};

92
/* These are for CD-ROM XA ADPCM */
Alex Beregszaszi's avatar
100l  
Alex Beregszaszi committed
93
static const int xa_adpcm_table[5][2] = {
94 95 96 97 98 99 100
   {   0,   0 },
   {  60,   0 },
   { 115, -52 },
   {  98, -55 },
   { 122, -60 }
};

101 102 103 104 105
static int ea_adpcm_table[] = {
    0, 240, 460, 392, 0, 0, -208, -220, 0, 1,
    3, 4, 7, 8, 10, 11, 0, -1, -3, -4
};

106 107 108 109 110
static int ct_adpcm_table[8] = {
    0x00E6, 0x00E6, 0x00E6, 0x00E6,
    0x0133, 0x0199, 0x0200, 0x0266
};

111 112 113 114 115 116
/* end of tables */

typedef struct ADPCMChannelStatus {
    int predictor;
    short int step_index;
    int step;
117 118
    /* for encoding */
    int prev_sample;
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135

    /* MS version */
    short sample1;
    short sample2;
    int coeff1;
    int coeff2;
    int idelta;
} ADPCMChannelStatus;

typedef struct ADPCMContext {
    int channel; /* for stereo MOVs, decode left, then decode right, then tell it's decoded */
    ADPCMChannelStatus status[2];
    short sample_buffer[32]; /* hold left samples while waiting for right samples */
} ADPCMContext;

/* XXX: implement encoding */

136
#ifdef CONFIG_ENCODERS
137 138
static int adpcm_encode_init(AVCodecContext *avctx)
{
139 140
    if (avctx->channels > 2)
        return -1; /* only stereo or mono =) */
141 142
    switch(avctx->codec->id) {
    case CODEC_ID_ADPCM_IMA_QT:
Fabrice Bellard's avatar
Fabrice Bellard committed
143
        av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ima_qt unsupported for encoding !\n");
144 145
        avctx->frame_size = 64; /* XXX: can multiple of avctx->channels * 64 (left and right blocks are interleaved) */
        return -1;
146 147
        break;
    case CODEC_ID_ADPCM_IMA_WAV:
148 149 150 151 152 153
        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
                                                             /* and we have 4 bytes per channel overhead */
        avctx->block_align = BLKSIZE;
        /* seems frame_size isn't taken into account... have to buffer the samples :-( */
        break;
    case CODEC_ID_ADPCM_MS:
154 155 156
        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */
                                                             /* and we have 7 bytes per channel overhead */
        avctx->block_align = BLKSIZE;
157 158
        break;
    default:
159
        return -1;
160 161
        break;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
162 163 164 165

    avctx->coded_frame= avcodec_alloc_frame();
    avctx->coded_frame->key_frame= 1;

166 167 168 169 170
    return 0;
}

static int adpcm_encode_close(AVCodecContext *avctx)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
171 172
    av_freep(&avctx->coded_frame);

173 174 175
    return 0;
}

176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224

static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
{
    int step_index;
    unsigned char nibble;
    
    int sign = 0; /* sign bit of the nibble (MSB) */
    int delta, predicted_delta;

    delta = sample - c->prev_sample;

    if (delta < 0) {
        sign = 1;
        delta = -delta;
    }

    step_index = c->step_index;

    /* nibble = 4 * delta / step_table[step_index]; */
    nibble = (delta << 2) / step_table[step_index];

    if (nibble > 7)
        nibble = 7;

    step_index += index_table[nibble];
    if (step_index < 0)
        step_index = 0;
    if (step_index > 88)
        step_index = 88;

    /* what the decoder will find */
    predicted_delta = ((step_table[step_index] * nibble) / 4) + (step_table[step_index] / 8);

    if (sign)
        c->prev_sample -= predicted_delta;
    else
        c->prev_sample += predicted_delta;

    CLAMP_TO_SHORT(c->prev_sample);


    nibble += sign << 3; /* sign * 8 */   

    /* save back */
    c->step_index = step_index;

    return nibble;
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample)
{
    int predictor, nibble, bias;

    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
    
    nibble= sample - predictor;
    if(nibble>=0) bias= c->idelta/2;
    else          bias=-c->idelta/2;
        
    nibble= (nibble + bias) / c->idelta;
    nibble= clip(nibble, -8, 7)&0x0F;
    
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
    CLAMP_TO_SHORT(predictor);

    c->sample2 = c->sample1;
    c->sample1 = predictor;

    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
    if (c->idelta < 16) c->idelta = 16;

    return nibble;
}

250 251 252
static int adpcm_encode_frame(AVCodecContext *avctx,
			    unsigned char *frame, int buf_size, void *data)
{
253
    int n, i, st;
254 255
    short *samples;
    unsigned char *dst;
256 257 258 259
    ADPCMContext *c = avctx->priv_data;

    dst = frame;
    samples = (short *)data;
260
    st= avctx->channels == 2;
261
/*    n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
262 263

    switch(avctx->codec->id) {
264 265 266 267 268 269 270 271 272 273 274 275
    case CODEC_ID_ADPCM_IMA_QT: /* XXX: can't test until we get .mov writer */
        break;
    case CODEC_ID_ADPCM_IMA_WAV:
        n = avctx->frame_size / 8;
            c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
/*            c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
            *dst++ = (c->status[0].prev_sample) & 0xFF; /* little endian */
            *dst++ = (c->status[0].prev_sample >> 8) & 0xFF;
            *dst++ = (unsigned char)c->status[0].step_index;
            *dst++ = 0; /* unknown */
            samples++;
            if (avctx->channels == 2) {
Alex Beregszaszi's avatar
100l  
Alex Beregszaszi committed
276
                c->status[1].prev_sample = (signed short)samples[1];
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
/*                c->status[1].step_index = 0; */
                *dst++ = (c->status[1].prev_sample) & 0xFF;
                *dst++ = (c->status[1].prev_sample >> 8) & 0xFF;
                *dst++ = (unsigned char)c->status[1].step_index;
                *dst++ = 0;
                samples++;
            }
        
            /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
            for (; n>0; n--) {
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]) & 0x0F;
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0;
                dst++;
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]) & 0x0F;
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4) & 0xF0;
                dst++;
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]) & 0x0F;
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4) & 0xF0;
                dst++;
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]) & 0x0F;
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4) & 0xF0;
                dst++;
                /* right channel */
                if (avctx->channels == 2) {
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
                    dst++;
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
                    dst++;
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
                    dst++;
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
                    dst++;
                }
                samples += 8 * avctx->channels;
            }
        break;
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
    case CODEC_ID_ADPCM_MS:
        for(i=0; i<avctx->channels; i++){
            int predictor=0;

            *dst++ = predictor;
            c->status[i].coeff1 = AdaptCoeff1[predictor];
            c->status[i].coeff2 = AdaptCoeff2[predictor];
        }
        for(i=0; i<avctx->channels; i++){
            if (c->status[i].idelta < 16) 
                c->status[i].idelta = 16;
            
            *dst++ = c->status[i].idelta & 0xFF;
            *dst++ = c->status[i].idelta >> 8;
        }
        for(i=0; i<avctx->channels; i++){
            c->status[i].sample1= *samples++;

            *dst++ = c->status[i].sample1 & 0xFF;
            *dst++ = c->status[i].sample1 >> 8;
        }
        for(i=0; i<avctx->channels; i++){
            c->status[i].sample2= *samples++;

            *dst++ = c->status[i].sample2 & 0xFF;
            *dst++ = c->status[i].sample2 >> 8;
        }

        for(i=7*avctx->channels; i<avctx->block_align; i++) {
            int nibble;
            nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
            nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
            *dst++ = nibble;
        }
        break;
352 353 354 355 356
    default:
        return -1;
    }
    return dst - frame;
}
357
#endif //CONFIG_ENCODERS
358 359 360 361 362 363 364 365 366 367 368

static int adpcm_decode_init(AVCodecContext * avctx)
{
    ADPCMContext *c = avctx->priv_data;

    c->channel = 0;
    c->status[0].predictor = c->status[1].predictor = 0;
    c->status[0].step_index = c->status[1].step_index = 0;
    c->status[0].step = c->status[1].step = 0;

    switch(avctx->codec->id) {
369 370 371
    case CODEC_ID_ADPCM_CT:
	c->status[0].step = c->status[1].step = 511;
	break;
372 373 374 375 376 377
    default:
        break;
    }
    return 0;
}

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
378
static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
379 380 381 382 383
{
    int step_index;
    int predictor;
    int sign, delta, diff, step;

384
    step = step_table[c->step_index];
385 386
    step_index = c->step_index + index_table[(unsigned)nibble];
    if (step_index < 0) step_index = 0;
387
    else if (step_index > 88) step_index = 88;
388 389 390

    sign = nibble & 8;
    delta = nibble & 7;
391 392 393
    /* perform direct multiplication instead of series of jumps proposed by
     * the reference ADPCM implementation since modern CPUs can do the mults
     * quickly enough */
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
394
    diff = ((2 * delta + 1) * step) >> shift;
Michael Niedermayer's avatar
Michael Niedermayer committed
395 396 397 398 399 400 401 402 403 404 405
    predictor = c->predictor;
    if (sign) predictor -= diff;
    else predictor += diff;

    CLAMP_TO_SHORT(predictor);
    c->predictor = predictor;
    c->step_index = step_index;

    return (short)predictor;
}

406 407 408 409 410 411 412 413 414 415
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
{
    int predictor;

    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
    CLAMP_TO_SHORT(predictor);

    c->sample2 = c->sample1;
    c->sample1 = predictor;
416
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
417 418 419 420 421
    if (c->idelta < 16) c->idelta = 16;

    return (short)predictor;
}

422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
{
    int predictor;
    int sign, delta, diff;
    int new_step;

    sign = nibble & 8;
    delta = nibble & 7;
    /* perform direct multiplication instead of series of jumps proposed by
     * the reference ADPCM implementation since modern CPUs can do the mults
     * quickly enough */
    diff = ((2 * delta + 1) * c->step) >> 3;
    predictor = c->predictor;
    /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
    if(sign)
	predictor = ((predictor * 254) >> 8) - diff;
    else
    	predictor = ((predictor * 254) >> 8) + diff;
    /* calculate new step and clamp it to range 511..32767 */
    new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;
    c->step = new_step;
    if(c->step < 511)
	c->step = 511;
    if(c->step > 32767)
	c->step = 32767;

    CLAMP_TO_SHORT(predictor);
    c->predictor = predictor;
    return (short)predictor;
}

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
static void xa_decode(short *out, const unsigned char *in, 
    ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
{
    int i, j;
    int shift,filter,f0,f1;
    int s_1,s_2;
    int d,s,t;

    for(i=0;i<4;i++) {

        shift  = 12 - (in[4+i*2] & 15);
        filter = in[4+i*2] >> 4;
        f0 = xa_adpcm_table[filter][0];
        f1 = xa_adpcm_table[filter][1];

        s_1 = left->sample1;
        s_2 = left->sample2;

        for(j=0;j<28;j++) {
            d = in[16+i+j*4];

            t = (signed char)(d<<4)>>4;
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            CLAMP_TO_SHORT(s);
            *out = s;
            out += inc;
            s_2 = s_1;
            s_1 = s;
        }

        if (inc==2) { /* stereo */
            left->sample1 = s_1;
            left->sample2 = s_2;
            s_1 = right->sample1;
            s_2 = right->sample2;
            out = out + 1 - 28*2;
        }

        shift  = 12 - (in[5+i*2] & 15);
        filter = in[5+i*2] >> 4;

        f0 = xa_adpcm_table[filter][0];
        f1 = xa_adpcm_table[filter][1];

        for(j=0;j<28;j++) {
            d = in[16+i+j*4];

            t = (signed char)d >> 4;
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            CLAMP_TO_SHORT(s);
            *out = s;
            out += inc;
            s_2 = s_1;
            s_1 = s;
        }

        if (inc==2) { /* stereo */
            right->sample1 = s_1;
            right->sample2 = s_2;
            out -= 1;
        } else {
            left->sample1 = s_1;
            left->sample2 = s_2;
        }
    }
}


521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
/* DK3 ADPCM support macro */
#define DK3_GET_NEXT_NIBBLE() \
    if (decode_top_nibble_next) \
    { \
        nibble = (last_byte >> 4) & 0x0F; \
        decode_top_nibble_next = 0; \
    } \
    else \
    { \
        last_byte = *src++; \
        if (src >= buf + buf_size) break; \
        nibble = last_byte & 0x0F; \
        decode_top_nibble_next = 1; \
    }

536 537
static int adpcm_decode_frame(AVCodecContext *avctx,
			    void *data, int *data_size,
538
			    uint8_t *buf, int buf_size)
539 540 541
{
    ADPCMContext *c = avctx->priv_data;
    ADPCMChannelStatus *cs;
Michael Niedermayer's avatar
Michael Niedermayer committed
542
    int n, m, channel, i;
543 544
    int block_predictor[2];
    short *samples;
545
    uint8_t *src;
546 547
    int st; /* stereo */

548 549 550 551 552 553
    /* DK3 ADPCM accounting variables */
    unsigned char last_byte = 0;
    unsigned char nibble;
    int decode_top_nibble_next = 0;
    int diff_channel;

554 555 556 557 558 559 560 561 562
    /* EA ADPCM state variables */
    uint32_t samples_in_chunk;
    int32_t previous_left_sample, previous_right_sample;
    int32_t current_left_sample, current_right_sample;
    int32_t next_left_sample, next_right_sample;
    int32_t coeff1l, coeff2l, coeff1r, coeff2r;
    uint8_t shift_left, shift_right;
    int count1, count2;

Mike Melanson's avatar
Mike Melanson committed
563 564 565
    if (!buf_size)
        return 0;

566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
    samples = data;
    src = buf;

    st = avctx->channels == 2;

    switch(avctx->codec->id) {
    case CODEC_ID_ADPCM_IMA_QT:
        n = (buf_size - 2);/* >> 2*avctx->channels;*/
        channel = c->channel;
        cs = &(c->status[channel]);
        /* (pppppp) (piiiiiii) */

        /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
        cs->predictor = (*src++) << 8;
        cs->predictor |= (*src & 0x80);
        cs->predictor &= 0xFF80;

        /* sign extension */
        if(cs->predictor & 0x8000)
            cs->predictor -= 0x10000;

        CLAMP_TO_SHORT(cs->predictor);

        cs->step_index = (*src++) & 0x7F;

591
        if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
592 593 594 595 596 597 598 599
        if (cs->step_index > 88) cs->step_index = 88;

        cs->step = step_table[cs->step_index];

        if (st && channel)
            samples++;

        for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
600
            *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
601
            samples += avctx->channels;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
602
            *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
603 604 605 606 607 608
            samples += avctx->channels;
            src ++;
        }

        if(st) { /* handle stereo interlacing */
            c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
609
            if(channel == 1) { /* wait for the other packet before outputing anything */
610 611 612 613 614
                return src - buf;
            }
        }
        break;
    case CODEC_ID_ADPCM_IMA_WAV:
615 616 617
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
            buf_size = avctx->block_align;

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
618 619 620 621
        for(i=0; i<avctx->channels; i++){
            cs = &(c->status[i]);
            cs->predictor = *src++;
            cs->predictor |= (*src++) << 8;
622 623 624 625
            if(cs->predictor & 0x8000)
                cs->predictor -= 0x10000;
            CLAMP_TO_SHORT(cs->predictor);

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
626
	// XXX: is this correct ??: *samples++ = cs->predictor;
627

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
628
            cs->step_index = *src++;
629 630
            if (cs->step_index < 0) cs->step_index = 0;
            if (cs->step_index > 88) cs->step_index = 88;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
631
            if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null !!\n"); /* unused */
632 633
        }

Zdenek Kabelac's avatar
Zdenek Kabelac committed
634
        for(m=4; src < (buf + buf_size);) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
635
	    *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F, 3);
636
            if (st)
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
637 638
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F, 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F, 3);
Zdenek Kabelac's avatar
Zdenek Kabelac committed
639
	    if (st) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
640
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F, 3);
Zdenek Kabelac's avatar
Zdenek Kabelac committed
641 642 643 644 645 646
		if (!--m) {
		    m=4;
		    src+=4;
		}
	    }
	    src++;
647
	}
Michael Niedermayer's avatar
Michael Niedermayer committed
648 649 650 651 652 653 654 655 656 657 658
        break;
    case CODEC_ID_ADPCM_4XM:
        cs = &(c->status[0]);
        c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
        if(st){
            c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
        }
        c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
        if(st){
            c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
        }
659 660
        if (cs->step_index < 0) cs->step_index = 0;
        if (cs->step_index > 88) cs->step_index = 88;
Michael Niedermayer's avatar
Michael Niedermayer committed
661 662 663

        m= (buf_size - (src - buf))>>st;
        for(i=0; i<m; i++) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
664
	    *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
Michael Niedermayer's avatar
Michael Niedermayer committed
665
            if (st)
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
666 667
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
Michael Niedermayer's avatar
Michael Niedermayer committed
668
	    if (st)
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
669
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
Michael Niedermayer's avatar
Michael Niedermayer committed
670 671 672 673
	}

        src += m<<st;

674 675
        break;
    case CODEC_ID_ADPCM_MS:
676 677
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
            buf_size = avctx->block_align;
678 679 680
        n = buf_size - 7 * avctx->channels;
        if (n < 0)
            return -1;
681
        block_predictor[0] = clip(*src++, 0, 7);
682 683
        block_predictor[1] = 0;
        if (st)
684 685
            block_predictor[1] = clip(*src++, 0, 7);
        c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
686
        src+=2;
687 688
        if (st){
            c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
689
            src+=2;
690
        }
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
        c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
        c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
        c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
        c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
        
        c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
        src+=2;
        if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
        if (st) src+=2;
        c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
        src+=2;
        if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
        if (st) src+=2;

        *samples++ = c->status[0].sample1;
        if (st) *samples++ = c->status[1].sample1;
        *samples++ = c->status[0].sample2;
        if (st) *samples++ = c->status[1].sample2;
        for(;n>0;n--) {
            *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
            src ++;
        }
        break;
715
    case CODEC_ID_ADPCM_IMA_DK4:
716 717 718
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
            buf_size = avctx->block_align;

719
        c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8));
720 721 722 723
        c->status[0].step_index = src[2];
        src += 4;
        *samples++ = c->status[0].predictor;
        if (st) {
724
            c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8));
725 726 727 728 729 730 731 732
            c->status[1].step_index = src[2];
            src += 4;
            *samples++ = c->status[1].predictor;
        }
        while (src < buf + buf_size) {

            /* take care of the top nibble (always left or mono channel) */
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
733
                (src[0] >> 4) & 0x0F, 3);
734 735 736 737 738

            /* take care of the bottom nibble, which is right sample for
             * stereo, or another mono sample */
            if (st)
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], 
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
739
                    src[0] & 0x0F, 3);
740 741
            else
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
742
                    src[0] & 0x0F, 3);
743 744 745 746 747

            src++;
        }
        break;
    case CODEC_ID_ADPCM_IMA_DK3:
748 749 750
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
            buf_size = avctx->block_align;

751 752
        c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8));
        c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8));
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
        c->status[0].step_index = src[14];
        c->status[1].step_index = src[15];
        /* sign extend the predictors */
        src += 16;
        diff_channel = c->status[1].predictor;

        /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
         * the buffer is consumed */
        while (1) {

            /* for this algorithm, c->status[0] is the sum channel and
             * c->status[1] is the diff channel */

            /* process the first predictor of the sum channel */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
768
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
769 770 771

            /* process the diff channel predictor */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
772
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
773 774 775 776 777 778 779 780

            /* process the first pair of stereo PCM samples */
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
            *samples++ = c->status[0].predictor + c->status[1].predictor;
            *samples++ = c->status[0].predictor - c->status[1].predictor;

            /* process the second predictor of the sum channel */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
781
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
782 783 784 785 786 787 788

            /* process the second pair of stereo PCM samples */
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
            *samples++ = c->status[0].predictor + c->status[1].predictor;
            *samples++ = c->status[0].predictor - c->status[1].predictor;
        }
        break;
789 790 791 792 793 794
    case CODEC_ID_ADPCM_IMA_WS:
        /* no per-block initialization; just start decoding the data */
        while (src < buf + buf_size) {

            if (st) {
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
795
                    (src[0] >> 4) & 0x0F, 3);
796
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], 
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
797
                    src[0] & 0x0F, 3);
798 799
            } else {
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
800
                    (src[0] >> 4) & 0x0F, 3);
801
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
802
                    src[0] & 0x0F, 3);
803 804 805 806 807
            }

            src++;
        }
        break;
808 809 810 811 812 813 814 815 816 817 818
    case CODEC_ID_ADPCM_XA:
        c->status[0].sample1 = c->status[0].sample2 = 
        c->status[1].sample1 = c->status[1].sample2 = 0;
        while (buf_size >= 128) {
            xa_decode(samples, src, &c->status[0], &c->status[1], 
                avctx->channels);
            src += 128;
            samples += 28 * 8;
            buf_size -= 128;
        }
        break;
819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881
    case CODEC_ID_ADPCM_EA:
        samples_in_chunk = LE_32(src);
        if (samples_in_chunk >= ((buf_size - 12) * 2)) {
            src += buf_size;
            break;
        }
        src += 4;
        current_left_sample = (int16_t)LE_16(src);
        src += 2;
        previous_left_sample = (int16_t)LE_16(src);
        src += 2;
        current_right_sample = (int16_t)LE_16(src);
        src += 2;
        previous_right_sample = (int16_t)LE_16(src);
        src += 2;

        for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
            coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];
            coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];
            coeff1r = ea_adpcm_table[*src & 0x0F];
            coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
            src++;

            shift_left = ((*src >> 4) & 0x0F) + 8;
            shift_right = (*src & 0x0F) + 8;
            src++;

            for (count2 = 0; count2 < 28; count2++) {
                next_left_sample = (((*src & 0xF0) << 24) >> shift_left);
                next_right_sample = (((*src & 0x0F) << 28) >> shift_right);
                src++;

                next_left_sample = (next_left_sample + 
                    (current_left_sample * coeff1l) + 
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
                next_right_sample = (next_right_sample + 
                    (current_right_sample * coeff1r) + 
                    (previous_right_sample * coeff2r) + 0x80) >> 8;
                CLAMP_TO_SHORT(next_left_sample);
                CLAMP_TO_SHORT(next_right_sample);

                previous_left_sample = current_left_sample;
                current_left_sample = next_left_sample;
                previous_right_sample = current_right_sample;
                current_right_sample = next_right_sample;
                *samples++ = (unsigned short)current_left_sample;
                *samples++ = (unsigned short)current_right_sample;
            }
        }
        break;
    case CODEC_ID_ADPCM_IMA_SMJPEG:
        c->status[0].predictor = *src;
        src += 2;
        c->status[0].step_index = *src++;
        src++;  /* skip another byte before getting to the meat */
        while (src < buf + buf_size) {
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
                *src & 0x0F, 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
                (*src >> 4) & 0x0F, 3);
            src++;
        }
        break;
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
    case CODEC_ID_ADPCM_CT:
	while (src < buf + buf_size) {
            if (st) {
                *samples++ = adpcm_ct_expand_nibble(&c->status[0], 
                    (src[0] >> 4) & 0x0F);
                *samples++ = adpcm_ct_expand_nibble(&c->status[1], 
                    src[0] & 0x0F);
            } else {
                *samples++ = adpcm_ct_expand_nibble(&c->status[0], 
                    (src[0] >> 4) & 0x0F);
                *samples++ = adpcm_ct_expand_nibble(&c->status[0], 
                    src[0] & 0x0F);
            }
	    src++;
        }
        break;
898 899 900
    default:
        return -1;
    }
901
    *data_size = (uint8_t *)samples - (uint8_t *)data;
902 903 904
    return src - buf;
}

905 906 907 908


#ifdef CONFIG_ENCODERS
#define ADPCM_ENCODER(id,name)                  \
909 910 911 912 913 914 915 916 917
AVCodec name ## _encoder = {                    \
    #name,                                      \
    CODEC_TYPE_AUDIO,                           \
    id,                                         \
    sizeof(ADPCMContext),                       \
    adpcm_encode_init,                          \
    adpcm_encode_frame,                         \
    adpcm_encode_close,                         \
    NULL,                                       \
918 919 920 921 922 923 924
};
#else
#define ADPCM_ENCODER(id,name)
#endif

#ifdef CONFIG_DECODERS
#define ADPCM_DECODER(id,name)                  \
925 926 927 928 929 930 931 932 933 934
AVCodec name ## _decoder = {                    \
    #name,                                      \
    CODEC_TYPE_AUDIO,                           \
    id,                                         \
    sizeof(ADPCMContext),                       \
    adpcm_decode_init,                          \
    NULL,                                       \
    NULL,                                       \
    adpcm_decode_frame,                         \
};
935 936 937 938 939 940
#else
#define ADPCM_DECODER(id,name)
#endif

#define ADPCM_CODEC(id, name)                   \
ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
941 942 943

ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
944 945
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
946
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
947
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
948
ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
Michael Niedermayer's avatar
Michael Niedermayer committed
949
ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
950 951
ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
ADPCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx);
952
ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea);
953
ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct);
954 955

#undef ADPCM_CODEC