alac.c 22.7 KB
Newer Older
1 2 3 4
/*
 * ALAC (Apple Lossless Audio Codec) decoder
 * Copyright (c) 2005 David Hammerton
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * 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
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 21 22
 */

/**
23
 * @file
24 25 26 27 28 29 30 31 32 33 34 35
 * ALAC (Apple Lossless Audio Codec) decoder
 * @author 2005 David Hammerton
 *
 * For more information on the ALAC format, visit:
 *  http://crazney.net/programs/itunes/alac.html
 *
 * Note: This decoder expects a 36- (0x24-)byte QuickTime atom to be
 * passed through the extradata[_size] fields. This atom is tacked onto
 * the end of an 'alac' stsd atom and has the following format:
 *  bytes 0-3   atom size (0x24), big-endian
 *  bytes 4-7   atom type ('alac', not the 'alac' tag from start of stsd)
 *  bytes 8-35  data bytes needed by decoder
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
 *
 * Extradata:
 * 32bit  size
 * 32bit  tag (=alac)
 * 32bit  zero?
 * 32bit  max sample per frame
 *  8bit  ?? (zero?)
 *  8bit  sample size
 *  8bit  history mult
 *  8bit  initial history
 *  8bit  kmodifier
 *  8bit  channels?
 * 16bit  ??
 * 32bit  max coded frame size
 * 32bit  bitrate?
 * 32bit  samplerate
52 53 54 55
 */


#include "avcodec.h"
56
#include "get_bits.h"
57
#include "bytestream.h"
58
#include "unary.h"
59
#include "mathops.h"
60 61

#define ALAC_EXTRADATA_SIZE 36
62
#define MAX_CHANNELS 2
63

64 65 66 67
typedef struct {

    AVCodecContext *avctx;
    GetBitContext gb;
68 69 70 71 72

    int numchannels;
    int bytespersample;

    /* buffers */
73
    int32_t *predicterror_buffer[MAX_CHANNELS];
74

75
    int32_t *outputsamples_buffer[MAX_CHANNELS];
76

77 78
    int32_t *wasted_bits_buffer[MAX_CHANNELS];

79 80 81 82 83 84 85 86
    /* stuff from setinfo */
    uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */    /* max samples per frame? */
    uint8_t setinfo_sample_size; /* 0x10 */
    uint8_t setinfo_rice_historymult; /* 0x28 */
    uint8_t setinfo_rice_initialhistory; /* 0x0a */
    uint8_t setinfo_rice_kmodifier; /* 0x0e */
    /* end setinfo stuff */

87
    int wasted_bits;
88 89
} ALACContext;

90
static void allocate_buffers(ALACContext *alac)
91
{
92 93 94 95
    int chan;
    for (chan = 0; chan < MAX_CHANNELS; chan++) {
        alac->predicterror_buffer[chan] =
            av_malloc(alac->setinfo_max_samples_per_frame * 4);
96

97 98
        alac->outputsamples_buffer[chan] =
            av_malloc(alac->setinfo_max_samples_per_frame * 4);
99 100

        alac->wasted_bits_buffer[chan] = av_malloc(alac->setinfo_max_samples_per_frame * 4);
101
    }
102 103
}

104
static int alac_set_info(ALACContext *alac)
105
{
Michael Niedermayer's avatar
Michael Niedermayer committed
106
    const unsigned char *ptr = alac->avctx->extradata;
107 108 109 110 111

    ptr += 4; /* size */
    ptr += 4; /* alac */
    ptr += 4; /* 0 ? */

112
    if(AV_RB32(ptr) >= UINT_MAX/4){
113 114 115
        av_log(alac->avctx, AV_LOG_ERROR, "setinfo_max_samples_per_frame too large\n");
        return -1;
    }
116 117 118

    /* buffer size / 2 ? */
    alac->setinfo_max_samples_per_frame = bytestream_get_be32(&ptr);
119
    ptr++;                          /* ??? */
Vitor Sessak's avatar
Vitor Sessak committed
120
    alac->setinfo_sample_size           = *ptr++;
121 122 123 124
    if (alac->setinfo_sample_size > 32) {
        av_log(alac->avctx, AV_LOG_ERROR, "setinfo_sample_size too large\n");
        return -1;
    }
Vitor Sessak's avatar
Vitor Sessak committed
125 126 127
    alac->setinfo_rice_historymult      = *ptr++;
    alac->setinfo_rice_initialhistory   = *ptr++;
    alac->setinfo_rice_kmodifier        = *ptr++;
128
    ptr++;                         /* channels? */
129 130 131
    bytestream_get_be16(&ptr);      /* ??? */
    bytestream_get_be32(&ptr);      /* max coded frame size */
    bytestream_get_be32(&ptr);      /* bitrate ? */
132
    bytestream_get_be32(&ptr);      /* samplerate */
133 134

    allocate_buffers(alac);
135 136

    return 0;
137 138
}

139 140 141 142 143 144 145 146
static inline int decode_scalar(GetBitContext *gb, int k, int limit, int readsamplesize){
    /* read x - number of 1s before 0 represent the rice */
    int x = get_unary_0_9(gb);

    if (x > 8) { /* RICE THRESHOLD */
        /* use alternative encoding */
        x = get_bits(gb, readsamplesize);
    } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
147 148
        if (k >= limit)
            k = limit;
149

Michael Niedermayer's avatar
Michael Niedermayer committed
150 151
        if (k != 1) {
            int extrabits = show_bits(gb, k);
152

Michael Niedermayer's avatar
Michael Niedermayer committed
153 154
            /* multiply x by 2^k - 1, as part of their strange algorithm */
            x = (x << k) - x;
155

Michael Niedermayer's avatar
Michael Niedermayer committed
156 157 158 159 160 161
            if (extrabits > 1) {
                x += extrabits - 1;
                skip_bits(gb, k);
            } else
                skip_bits(gb, k - 1);
        }
162
    }
163 164 165
    return x;
}

166
static void bastardized_rice_decompress(ALACContext *alac,
167 168 169 170 171 172 173 174 175 176 177 178 179 180
                                 int32_t *output_buffer,
                                 int output_size,
                                 int readsamplesize, /* arg_10 */
                                 int rice_initialhistory, /* arg424->b */
                                 int rice_kmodifier, /* arg424->d */
                                 int rice_historymult, /* arg424->c */
                                 int rice_kmodifier_mask /* arg424->e */
        )
{
    int output_count;
    unsigned int history = rice_initialhistory;
    int sign_modifier = 0;

    for (output_count = 0; output_count < output_size; output_count++) {
181
        int32_t x;
182 183 184
        int32_t x_modified;
        int32_t final_val;

Michael Niedermayer's avatar
Michael Niedermayer committed
185 186
        /* standard rice encoding */
        int k; /* size of extra bits */
187

Michael Niedermayer's avatar
Michael Niedermayer committed
188
        /* read k, that is bits as is */
189
        k = av_log2((history >> 9) + 3);
Michael Niedermayer's avatar
Michael Niedermayer committed
190
        x= decode_scalar(&alac->gb, k, rice_kmodifier, readsamplesize);
191 192 193 194 195 196 197 198 199 200

        x_modified = sign_modifier + x;
        final_val = (x_modified + 1) / 2;
        if (x_modified & 1) final_val *= -1;

        output_buffer[output_count] = final_val;

        sign_modifier = 0;

        /* now update the history */
Vitor Sessak's avatar
Vitor Sessak committed
201 202
        history += x_modified * rice_historymult
                   - ((history * rice_historymult) >> 9);
203 204 205 206 207 208

        if (x_modified > 0xffff)
            history = 0xffff;

        /* special case: there may be compressed blocks of 0 */
        if ((history < 128) && (output_count+1 < output_size)) {
209 210
            int k;
            unsigned int block_size;
211 212 213

            sign_modifier = 1;

214
            k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */);
215

Michael Niedermayer's avatar
Michael Niedermayer committed
216
            block_size= decode_scalar(&alac->gb, k, rice_kmodifier, 16);
217 218

            if (block_size > 0) {
219 220 221 222
                if(block_size >= output_size - output_count){
                    av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);
                    block_size= output_size - output_count - 1;
                }
223 224 225 226 227 228 229 230 231 232 233 234
                memset(&output_buffer[output_count+1], 0, block_size * 4);
                output_count += block_size;
            }

            if (block_size > 0xffff)
                sign_modifier = 0;

            history = 0;
        }
    }
}

235 236 237 238
static inline int sign_only(int v)
{
    return v ? FFSIGN(v) : 0;
}
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253

static void predictor_decompress_fir_adapt(int32_t *error_buffer,
                                           int32_t *buffer_out,
                                           int output_size,
                                           int readsamplesize,
                                           int16_t *predictor_coef_table,
                                           int predictor_coef_num,
                                           int predictor_quantitization)
{
    int i;

    /* first sample always copies */
    *buffer_out = *error_buffer;

    if (!predictor_coef_num) {
Vitor Sessak's avatar
Vitor Sessak committed
254 255 256
        if (output_size <= 1)
            return;

257 258 259 260 261 262 263 264
        memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4);
        return;
    }

    if (predictor_coef_num == 0x1f) { /* 11111 - max value of predictor_coef_num */
      /* second-best case scenario for fir decompression,
       * error describes a small difference from the previous sample only
       */
Vitor Sessak's avatar
Vitor Sessak committed
265 266
        if (output_size <= 1)
            return;
267 268 269 270 271 272
        for (i = 0; i < output_size - 1; i++) {
            int32_t prev_value;
            int32_t error_value;

            prev_value = buffer_out[i];
            error_value = error_buffer[i+1];
Vitor Sessak's avatar
Vitor Sessak committed
273
            buffer_out[i+1] =
274
                sign_extend((prev_value + error_value), readsamplesize);
275 276 277 278 279
        }
        return;
    }

    /* read warm-up samples */
Vitor Sessak's avatar
Vitor Sessak committed
280
    if (predictor_coef_num > 0)
281 282 283 284
        for (i = 0; i < predictor_coef_num; i++) {
            int32_t val;

            val = buffer_out[i] + error_buffer[i+1];
285
            val = sign_extend(val, readsamplesize);
286 287 288 289 290
            buffer_out[i+1] = val;
        }

#if 0
    /* 4 and 8 are very common cases (the only ones i've seen). these
Vitor Sessak's avatar
Vitor Sessak committed
291
     * should be unrolled and optimized
292 293
     */
    if (predictor_coef_num == 4) {
Vitor Sessak's avatar
Vitor Sessak committed
294
        /* FIXME: optimized general case */
295 296 297 298
        return;
    }

    if (predictor_coef_table == 8) {
Vitor Sessak's avatar
Vitor Sessak committed
299
        /* FIXME: optimized general case */
300 301 302 303 304 305
        return;
    }
#endif

    /* general case */
    if (predictor_coef_num > 0) {
Vitor Sessak's avatar
Vitor Sessak committed
306
        for (i = predictor_coef_num + 1; i < output_size; i++) {
307 308 309 310 311 312 313 314 315 316 317 318 319
            int j;
            int sum = 0;
            int outval;
            int error_val = error_buffer[i];

            for (j = 0; j < predictor_coef_num; j++) {
                sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) *
                       predictor_coef_table[j];
            }

            outval = (1 << (predictor_quantitization-1)) + sum;
            outval = outval >> predictor_quantitization;
            outval = outval + buffer_out[0] + error_val;
320
            outval = sign_extend(outval, readsamplesize);
321 322 323 324 325 326 327 328

            buffer_out[predictor_coef_num+1] = outval;

            if (error_val > 0) {
                int predictor_num = predictor_coef_num - 1;

                while (predictor_num >= 0 && error_val > 0) {
                    int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
329
                    int sign = sign_only(val);
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344

                    predictor_coef_table[predictor_num] -= sign;

                    val *= sign; /* absolute value */

                    error_val -= ((val >> predictor_quantitization) *
                                  (predictor_coef_num - predictor_num));

                    predictor_num--;
                }
            } else if (error_val < 0) {
                int predictor_num = predictor_coef_num - 1;

                while (predictor_num >= 0 && error_val < 0) {
                    int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
345
                    int sign = - sign_only(val);
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362

                    predictor_coef_table[predictor_num] -= sign;

                    val *= sign; /* neg value */

                    error_val -= ((val >> predictor_quantitization) *
                                  (predictor_coef_num - predictor_num));

                    predictor_num--;
                }
            }

            buffer_out++;
        }
    }
}

Vitor Sessak's avatar
Vitor Sessak committed
363
static void reconstruct_stereo_16(int32_t *buffer[MAX_CHANNELS],
Vitor Sessak's avatar
Vitor Sessak committed
364 365 366 367
                                  int16_t *buffer_out,
                                  int numchannels, int numsamples,
                                  uint8_t interlacing_shift,
                                  uint8_t interlacing_leftweight)
368
{
369
    int i;
Vitor Sessak's avatar
Vitor Sessak committed
370 371
    if (numsamples <= 0)
        return;
372 373 374 375

    /* weighted interlacing */
    if (interlacing_leftweight) {
        for (i = 0; i < numsamples; i++) {
376
            int32_t a, b;
377

378 379
            a = buffer[0][i];
            b = buffer[1][i];
380

381 382
            a -= (b * interlacing_leftweight) >> interlacing_shift;
            b += a;
383

384 385
            buffer_out[i*numchannels] = b;
            buffer_out[i*numchannels + 1] = a;
386 387 388 389 390 391 392 393 394
        }

        return;
    }

    /* otherwise basic interlacing took place */
    for (i = 0; i < numsamples; i++) {
        int16_t left, right;

395 396
        left = buffer[0][i];
        right = buffer[1][i];
397 398 399 400 401 402

        buffer_out[i*numchannels] = left;
        buffer_out[i*numchannels + 1] = right;
    }
}

403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 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 void decorrelate_stereo_24(int32_t *buffer[MAX_CHANNELS],
                                  int32_t *buffer_out,
                                  int32_t *wasted_bits_buffer[MAX_CHANNELS],
                                  int wasted_bits,
                                  int numchannels, int numsamples,
                                  uint8_t interlacing_shift,
                                  uint8_t interlacing_leftweight)
{
    int i;

    if (numsamples <= 0)
        return;

    /* weighted interlacing */
    if (interlacing_leftweight) {
        for (i = 0; i < numsamples; i++) {
            int32_t a, b;

            a = buffer[0][i];
            b = buffer[1][i];

            a -= (b * interlacing_leftweight) >> interlacing_shift;
            b += a;

            if (wasted_bits) {
                b  = (b  << wasted_bits) | wasted_bits_buffer[0][i];
                a  = (a  << wasted_bits) | wasted_bits_buffer[1][i];
            }

            buffer_out[i * numchannels]     = b << 8;
            buffer_out[i * numchannels + 1] = a << 8;
        }
    } else {
        for (i = 0; i < numsamples; i++) {
            int32_t left, right;

            left  = buffer[0][i];
            right = buffer[1][i];

            if (wasted_bits) {
                left   = (left   << wasted_bits) | wasted_bits_buffer[0][i];
                right  = (right  << wasted_bits) | wasted_bits_buffer[1][i];
            }

            buffer_out[i * numchannels]     = left  << 8;
            buffer_out[i * numchannels + 1] = right << 8;
        }
    }
}

453 454
static int alac_decode_frame(AVCodecContext *avctx,
                             void *outbuffer, int *outputsize,
455
                             AVPacket *avpkt)
456
{
457 458
    const uint8_t *inbuffer = avpkt->data;
    int input_buffer_size = avpkt->size;
459
    ALACContext *alac = avctx->priv_data;
460

461
    int channels;
462
    unsigned int outputsamples;
463
    int hassize;
464
    unsigned int readsamplesize;
465
    int isnotcompressed;
466 467
    uint8_t interlacing_shift;
    uint8_t interlacing_leftweight;
468

469 470
    /* short-circuit null buffers */
    if (!inbuffer || !input_buffer_size)
Jason Garrett-Glaser's avatar
Jason Garrett-Glaser committed
471
        return -1;
472

473
    init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
474

475
    channels = get_bits(&alac->gb, 3) + 1;
476 477 478
    if (channels > MAX_CHANNELS) {
        av_log(avctx, AV_LOG_ERROR, "channels > %d not supported\n",
               MAX_CHANNELS);
Jason Garrett-Glaser's avatar
Jason Garrett-Glaser committed
479
        return -1;
480
    }
481

Vitor Sessak's avatar
Vitor Sessak committed
482 483 484
    /* 2^result = something to do with output waiting.
     * perhaps matters if we read > 1 frame in a pass?
     */
485
    skip_bits(&alac->gb, 4);
486

487
    skip_bits(&alac->gb, 12); /* unknown, skip 12 bits */
488

Vitor Sessak's avatar
Vitor Sessak committed
489
    /* the output sample size is stored soon */
490
    hassize = get_bits1(&alac->gb);
491

492
    alac->wasted_bits = get_bits(&alac->gb, 2) << 3;
493

Vitor Sessak's avatar
Vitor Sessak committed
494
    /* whether the frame is compressed */
495
    isnotcompressed = get_bits1(&alac->gb);
496

Vitor Sessak's avatar
Vitor Sessak committed
497 498
    if (hassize) {
        /* now read the number of samples as a 32bit integer */
499
        outputsamples = get_bits_long(&alac->gb, 32);
500 501 502 503
        if(outputsamples > alac->setinfo_max_samples_per_frame){
            av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac->setinfo_max_samples_per_frame);
            return -1;
        }
Vitor Sessak's avatar
Vitor Sessak committed
504 505
    } else
        outputsamples = alac->setinfo_max_samples_per_frame;
506

507
    switch (alac->setinfo_sample_size) {
508
    case 16: avctx->sample_fmt    = AV_SAMPLE_FMT_S16;
509 510
             alac->bytespersample = channels << 1;
             break;
511
    case 24: avctx->sample_fmt    = AV_SAMPLE_FMT_S32;
512 513 514 515 516 517 518
             alac->bytespersample = channels << 2;
             break;
    default: av_log(avctx, AV_LOG_ERROR, "Sample depth %d is not supported.\n",
                    alac->setinfo_sample_size);
             return -1;
    }

519 520 521 522 523
    if(outputsamples > *outputsize / alac->bytespersample){
        av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");
        return -1;
    }

Vitor Sessak's avatar
Vitor Sessak committed
524
    *outputsize = outputsamples * alac->bytespersample;
525
    readsamplesize = alac->setinfo_sample_size - (alac->wasted_bits) + channels - 1;
526 527 528 529
    if (readsamplesize > MIN_CACHE_BITS) {
        av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);
        return -1;
    }
530

Vitor Sessak's avatar
Vitor Sessak committed
531 532
    if (!isnotcompressed) {
        /* so it is compressed */
533 534 535 536 537
        int16_t predictor_coef_table[MAX_CHANNELS][32];
        int predictor_coef_num[MAX_CHANNELS];
        int prediction_type[MAX_CHANNELS];
        int prediction_quantitization[MAX_CHANNELS];
        int ricemodifier[MAX_CHANNELS];
Vitor Sessak's avatar
Vitor Sessak committed
538
        int i, chan;
539

Vitor Sessak's avatar
Vitor Sessak committed
540 541
        interlacing_shift = get_bits(&alac->gb, 8);
        interlacing_leftweight = get_bits(&alac->gb, 8);
542

Vitor Sessak's avatar
Vitor Sessak committed
543
        for (chan = 0; chan < channels; chan++) {
544 545
            prediction_type[chan] = get_bits(&alac->gb, 4);
            prediction_quantitization[chan] = get_bits(&alac->gb, 4);
546

547 548
            ricemodifier[chan] = get_bits(&alac->gb, 3);
            predictor_coef_num[chan] = get_bits(&alac->gb, 5);
549 550

            /* read the predictor table */
Vitor Sessak's avatar
Vitor Sessak committed
551
            for (i = 0; i < predictor_coef_num[chan]; i++)
552
                predictor_coef_table[chan][i] = (int16_t)get_bits(&alac->gb, 16);
Vitor Sessak's avatar
Vitor Sessak committed
553
        }
554

555 556 557 558 559 560 561
        if (alac->wasted_bits) {
            int i, ch;
            for (i = 0; i < outputsamples; i++) {
                for (ch = 0; ch < channels; ch++)
                    alac->wasted_bits_buffer[ch][i] = get_bits(&alac->gb, alac->wasted_bits);
            }
        }
Vitor Sessak's avatar
Vitor Sessak committed
562
        for (chan = 0; chan < channels; chan++) {
563
            bastardized_rice_decompress(alac,
564
                                        alac->predicterror_buffer[chan],
565 566 567 568
                                        outputsamples,
                                        readsamplesize,
                                        alac->setinfo_rice_initialhistory,
                                        alac->setinfo_rice_kmodifier,
569
                                        ricemodifier[chan] * alac->setinfo_rice_historymult / 4,
570 571
                                        (1 << alac->setinfo_rice_kmodifier) - 1);

572
            if (prediction_type[chan] == 0) {
Vitor Sessak's avatar
Vitor Sessak committed
573
                /* adaptive fir */
574 575
                predictor_decompress_fir_adapt(alac->predicterror_buffer[chan],
                                               alac->outputsamples_buffer[chan],
576 577
                                               outputsamples,
                                               readsamplesize,
578 579 580
                                               predictor_coef_table[chan],
                                               predictor_coef_num[chan],
                                               prediction_quantitization[chan]);
581
            } else {
582
                av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[chan]);
Vitor Sessak's avatar
Vitor Sessak committed
583 584
                /* I think the only other prediction type (or perhaps this is
                 * just a boolean?) runs adaptive fir twice.. like:
585 586 587 588
                 * predictor_decompress_fir_adapt(predictor_error, tempout, ...)
                 * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)
                 * little strange..
                 */
589
            }
Vitor Sessak's avatar
Vitor Sessak committed
590 591 592
        }
    } else {
        /* not compressed, easy case */
593
        int i, chan;
594
        if (alac->setinfo_sample_size <= 16) {
595 596
        for (i = 0; i < outputsamples; i++)
            for (chan = 0; chan < channels; chan++) {
597
                int32_t audiobits;
598

599
                audiobits = get_sbits_long(&alac->gb, alac->setinfo_sample_size);
600

601 602
                alac->outputsamples_buffer[chan][i] = audiobits;
            }
603 604 605 606 607 608 609 610 611 612 613
        } else {
            for (i = 0; i < outputsamples; i++) {
                for (chan = 0; chan < channels; chan++) {
                    alac->outputsamples_buffer[chan][i] = get_bits(&alac->gb,
                                                          alac->setinfo_sample_size);
                    alac->outputsamples_buffer[chan][i] = sign_extend(alac->outputsamples_buffer[chan][i],
                                                                      alac->setinfo_sample_size);
                }
            }
        }
        alac->wasted_bits = 0;
Vitor Sessak's avatar
Vitor Sessak committed
614 615 616
        interlacing_shift = 0;
        interlacing_leftweight = 0;
    }
Matthieu Castet's avatar
Matthieu Castet committed
617 618
    if (get_bits(&alac->gb, 3) != 7)
        av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");
619

Vitor Sessak's avatar
Vitor Sessak committed
620
    switch(alac->setinfo_sample_size) {
Vitor Sessak's avatar
Vitor Sessak committed
621
    case 16:
Vitor Sessak's avatar
Vitor Sessak committed
622
        if (channels == 2) {
Vitor Sessak's avatar
Vitor Sessak committed
623
            reconstruct_stereo_16(alac->outputsamples_buffer,
Vitor Sessak's avatar
Vitor Sessak committed
624 625 626 627 628
                                  (int16_t*)outbuffer,
                                  alac->numchannels,
                                  outputsamples,
                                  interlacing_shift,
                                  interlacing_leftweight);
Vitor Sessak's avatar
Vitor Sessak committed
629 630 631
        } else {
            int i;
            for (i = 0; i < outputsamples; i++) {
632
                ((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];
Vitor Sessak's avatar
Vitor Sessak committed
633
            }
634
        }
Vitor Sessak's avatar
Vitor Sessak committed
635 636
        break;
    case 24:
637 638 639 640 641 642 643 644 645 646 647 648 649 650
        if (channels == 2) {
            decorrelate_stereo_24(alac->outputsamples_buffer,
                                  outbuffer,
                                  alac->wasted_bits_buffer,
                                  alac->wasted_bits,
                                  alac->numchannels,
                                  outputsamples,
                                  interlacing_shift,
                                  interlacing_leftweight);
        } else {
            int i;
            for (i = 0; i < outputsamples; i++)
                ((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;
        }
Vitor Sessak's avatar
Vitor Sessak committed
651 652
        break;
    }
653

Matthieu Castet's avatar
Matthieu Castet committed
654 655 656
    if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)
        av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));

657
    return input_buffer_size;
658 659
}

660
static av_cold int alac_decode_init(AVCodecContext * avctx)
661
{
662 663 664
    ALACContext *alac = avctx->priv_data;
    alac->avctx = avctx;
    alac->numchannels = alac->avctx->channels;
665

Jason Garrett-Glaser's avatar
Jason Garrett-Glaser committed
666 667 668 669 670 671 672 673 674 675 676
    /* initialize from the extradata */
    if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {
        av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
            ALAC_EXTRADATA_SIZE);
        return -1;
    }
    if (alac_set_info(alac)) {
        av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");
        return -1;
    }

677 678 679
    return 0;
}

680
static av_cold int alac_decode_close(AVCodecContext *avctx)
681
{
682
    ALACContext *alac = avctx->priv_data;
683

684 685
    int chan;
    for (chan = 0; chan < MAX_CHANNELS; chan++) {
686 687
        av_freep(&alac->predicterror_buffer[chan]);
        av_freep(&alac->outputsamples_buffer[chan]);
688
        av_freep(&alac->wasted_bits_buffer[chan]);
689
    }
690 691 692 693

    return 0;
}

694
AVCodec ff_alac_decoder = {
695
    "alac",
696
    AVMEDIA_TYPE_AUDIO,
697 698 699 700 701 702
    CODEC_ID_ALAC,
    sizeof(ALACContext),
    alac_decode_init,
    NULL,
    alac_decode_close,
    alac_decode_frame,
703
    .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
704
};