alac.c 21.2 KB
Newer Older
1 2 3 4
/*
 * ALAC (Apple Lossless Audio Codec) decoder
 * Copyright (c) 2005 David Hammerton
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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
 * ALAC (Apple Lossless Audio Codec) decoder
 * @author 2005 David Hammerton
26
 * @see http://crazney.net/programs/itunes/alac.html
27 28 29 30 31 32 33
 *
 * 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
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
 *
 * 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
50 51 52 53
 */


#include "avcodec.h"
54
#include "get_bits.h"
55
#include "bytestream.h"
56
#include "unary.h"
57
#include "mathops.h"
58 59

#define ALAC_EXTRADATA_SIZE 36
60
#define MAX_CHANNELS 2
61

62 63 64 65
typedef struct {

    AVCodecContext *avctx;
    GetBitContext gb;
66 67 68 69 70

    int numchannels;
    int bytespersample;

    /* buffers */
71
    int32_t *predicterror_buffer[MAX_CHANNELS];
72

73
    int32_t *outputsamples_buffer[MAX_CHANNELS];
74

75
    int32_t *extra_bits_buffer[MAX_CHANNELS];
76

77 78 79 80 81 82 83 84
    /* 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 */

85
    int extra_bits;                         /**< number of extra bits beyond 16-bit */
86 87
} ALACContext;

88 89 90 91 92 93 94 95
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
96 97
        if (k >= limit)
            k = limit;
98

Michael Niedermayer's avatar
Michael Niedermayer committed
99 100
        if (k != 1) {
            int extrabits = show_bits(gb, k);
101

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

Michael Niedermayer's avatar
Michael Niedermayer committed
105 106 107 108 109 110
            if (extrabits > 1) {
                x += extrabits - 1;
                skip_bits(gb, k);
            } else
                skip_bits(gb, k - 1);
        }
111
    }
112 113 114
    return x;
}

115
static void bastardized_rice_decompress(ALACContext *alac,
116 117 118 119 120 121 122 123 124 125 126 127 128 129
                                 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++) {
130
        int32_t x;
131 132 133
        int32_t x_modified;
        int32_t final_val;

Michael Niedermayer's avatar
Michael Niedermayer committed
134 135
        /* standard rice encoding */
        int k; /* size of extra bits */
136

Michael Niedermayer's avatar
Michael Niedermayer committed
137
        /* read k, that is bits as is */
138
        k = av_log2((history >> 9) + 3);
Michael Niedermayer's avatar
Michael Niedermayer committed
139
        x= decode_scalar(&alac->gb, k, rice_kmodifier, readsamplesize);
140 141 142 143 144 145 146 147 148 149

        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
150 151
        history += x_modified * rice_historymult
                   - ((history * rice_historymult) >> 9);
152 153 154 155 156 157

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

        /* special case: there may be compressed blocks of 0 */
        if ((history < 128) && (output_count+1 < output_size)) {
158 159
            int k;
            unsigned int block_size;
160 161 162

            sign_modifier = 1;

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

Michael Niedermayer's avatar
Michael Niedermayer committed
165
            block_size= decode_scalar(&alac->gb, k, rice_kmodifier, 16);
166 167

            if (block_size > 0) {
168 169 170 171
                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;
                }
172 173 174 175 176 177 178 179 180 181 182 183
                memset(&output_buffer[output_count+1], 0, block_size * 4);
                output_count += block_size;
            }

            if (block_size > 0xffff)
                sign_modifier = 0;

            history = 0;
        }
    }
}

184 185 186 187
static inline int sign_only(int v)
{
    return v ? FFSIGN(v) : 0;
}
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202

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
203 204 205
        if (output_size <= 1)
            return;

206 207 208 209 210 211 212 213
        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
214 215
        if (output_size <= 1)
            return;
216 217 218 219 220 221
        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
222
            buffer_out[i+1] =
223
                sign_extend((prev_value + error_value), readsamplesize);
224 225 226 227 228
        }
        return;
    }

    /* read warm-up samples */
Vitor Sessak's avatar
Vitor Sessak committed
229
    if (predictor_coef_num > 0)
230 231 232 233
        for (i = 0; i < predictor_coef_num; i++) {
            int32_t val;

            val = buffer_out[i] + error_buffer[i+1];
234
            val = sign_extend(val, readsamplesize);
235 236 237 238
            buffer_out[i+1] = val;
        }

    /* 4 and 8 are very common cases (the only ones i've seen). these
Vitor Sessak's avatar
Vitor Sessak committed
239
     * should be unrolled and optimized
240 241 242 243
     */

    /* general case */
    if (predictor_coef_num > 0) {
Vitor Sessak's avatar
Vitor Sessak committed
244
        for (i = predictor_coef_num + 1; i < output_size; i++) {
245 246 247 248 249 250 251 252 253 254 255 256 257
            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;
258
            outval = sign_extend(outval, readsamplesize);
259 260 261 262 263 264 265 266

            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];
267
                    int sign = sign_only(val);
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282

                    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];
283
                    int sign = - sign_only(val);
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300

                    predictor_coef_table[predictor_num] -= sign;

                    val *= sign; /* neg value */

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

                    predictor_num--;
                }
            }

            buffer_out++;
        }
    }
}

301
static void decorrelate_stereo(int32_t *buffer[MAX_CHANNELS],
302
                               int numsamples, uint8_t interlacing_shift,
303
                               uint8_t interlacing_leftweight)
304
{
305 306
    int i;

307 308
    for (i = 0; i < numsamples; i++) {
        int32_t a, b;
309

310 311
        a = buffer[0][i];
        b = buffer[1][i];
312

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

316 317
        buffer[0][i] = b;
        buffer[1][i] = a;
318
    }
319 320
}

321 322 323 324 325 326 327 328 329 330 331
static void append_extra_bits(int32_t *buffer[MAX_CHANNELS],
                              int32_t *extra_bits_buffer[MAX_CHANNELS],
                              int extra_bits, int numchannels, int numsamples)
{
    int i, ch;

    for (ch = 0; ch < numchannels; ch++)
        for (i = 0; i < numsamples; i++)
            buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i];
}

332
static void interleave_stereo_16(int32_t *buffer[MAX_CHANNELS],
333
                                 int16_t *buffer_out, int numsamples)
334 335
{
    int i;
336 337

    for (i = 0; i < numsamples; i++) {
338 339
        *buffer_out++ = buffer[0][i];
        *buffer_out++ = buffer[1][i];
340 341 342
    }
}

343
static void interleave_stereo_24(int32_t *buffer[MAX_CHANNELS],
344
                                 int32_t *buffer_out, int numsamples)
345 346 347
{
    int i;

348 349 350 351
    for (i = 0; i < numsamples; i++) {
        *buffer_out++ = buffer[0][i] << 8;
        *buffer_out++ = buffer[1][i] << 8;
    }
352 353
}

354 355
static int alac_decode_frame(AVCodecContext *avctx,
                             void *outbuffer, int *outputsize,
356
                             AVPacket *avpkt)
357
{
358 359
    const uint8_t *inbuffer = avpkt->data;
    int input_buffer_size = avpkt->size;
360
    ALACContext *alac = avctx->priv_data;
361

362
    int channels;
363
    unsigned int outputsamples;
364
    int hassize;
365
    unsigned int readsamplesize;
366
    int isnotcompressed;
367 368
    uint8_t interlacing_shift;
    uint8_t interlacing_leftweight;
369
    int i, ch;
370

371
    init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
372

373
    channels = get_bits(&alac->gb, 3) + 1;
374 375 376
    if (channels != avctx->channels) {
        av_log(avctx, AV_LOG_ERROR, "frame header channel count mismatch\n");
        return AVERROR_INVALIDDATA;
377
    }
378

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

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

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

389
    alac->extra_bits = get_bits(&alac->gb, 2) << 3;
390

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

Vitor Sessak's avatar
Vitor Sessak committed
394 395
    if (hassize) {
        /* now read the number of samples as a 32bit integer */
396
        outputsamples = get_bits_long(&alac->gb, 32);
397 398 399 400
        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
401 402
    } else
        outputsamples = alac->setinfo_max_samples_per_frame;
403

404
    alac->bytespersample = channels * av_get_bytes_per_sample(avctx->sample_fmt);
405

406 407 408 409 410
    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
411
    *outputsize = outputsamples * alac->bytespersample;
412
    readsamplesize = alac->setinfo_sample_size - alac->extra_bits + channels - 1;
413 414 415 416
    if (readsamplesize > MIN_CACHE_BITS) {
        av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);
        return -1;
    }
417

Vitor Sessak's avatar
Vitor Sessak committed
418 419
    if (!isnotcompressed) {
        /* so it is compressed */
420 421 422 423 424
        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];
425

Vitor Sessak's avatar
Vitor Sessak committed
426 427
        interlacing_shift = get_bits(&alac->gb, 8);
        interlacing_leftweight = get_bits(&alac->gb, 8);
428

429 430 431
        for (ch = 0; ch < channels; ch++) {
            prediction_type[ch] = get_bits(&alac->gb, 4);
            prediction_quantitization[ch] = get_bits(&alac->gb, 4);
432

433 434
            ricemodifier[ch] = get_bits(&alac->gb, 3);
            predictor_coef_num[ch] = get_bits(&alac->gb, 5);
435 436

            /* read the predictor table */
437 438
            for (i = 0; i < predictor_coef_num[ch]; i++)
                predictor_coef_table[ch][i] = (int16_t)get_bits(&alac->gb, 16);
Vitor Sessak's avatar
Vitor Sessak committed
439
        }
440

441
        if (alac->extra_bits) {
442 443
            for (i = 0; i < outputsamples; i++) {
                for (ch = 0; ch < channels; ch++)
444
                    alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits);
445 446
            }
        }
447
        for (ch = 0; ch < channels; ch++) {
448
            bastardized_rice_decompress(alac,
449
                                        alac->predicterror_buffer[ch],
450 451 452 453
                                        outputsamples,
                                        readsamplesize,
                                        alac->setinfo_rice_initialhistory,
                                        alac->setinfo_rice_kmodifier,
454
                                        ricemodifier[ch] * alac->setinfo_rice_historymult / 4,
455 456
                                        (1 << alac->setinfo_rice_kmodifier) - 1);

457
            if (prediction_type[ch] == 0) {
Vitor Sessak's avatar
Vitor Sessak committed
458
                /* adaptive fir */
459 460
                predictor_decompress_fir_adapt(alac->predicterror_buffer[ch],
                                               alac->outputsamples_buffer[ch],
461 462
                                               outputsamples,
                                               readsamplesize,
463 464 465
                                               predictor_coef_table[ch],
                                               predictor_coef_num[ch],
                                               prediction_quantitization[ch]);
466
            } else {
467
                av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[ch]);
Vitor Sessak's avatar
Vitor Sessak committed
468 469
                /* I think the only other prediction type (or perhaps this is
                 * just a boolean?) runs adaptive fir twice.. like:
470 471 472 473
                 * predictor_decompress_fir_adapt(predictor_error, tempout, ...)
                 * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)
                 * little strange..
                 */
474
            }
Vitor Sessak's avatar
Vitor Sessak committed
475 476 477
        }
    } else {
        /* not compressed, easy case */
478
        for (i = 0; i < outputsamples; i++) {
479 480 481
            for (ch = 0; ch < channels; ch++) {
                alac->outputsamples_buffer[ch][i] = get_sbits_long(&alac->gb,
                                                                   alac->setinfo_sample_size);
482
            }
483
        }
484
        alac->extra_bits = 0;
Vitor Sessak's avatar
Vitor Sessak committed
485 486 487
        interlacing_shift = 0;
        interlacing_leftweight = 0;
    }
Matthieu Castet's avatar
Matthieu Castet committed
488 489
    if (get_bits(&alac->gb, 3) != 7)
        av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");
490

491
    if (channels == 2 && interlacing_leftweight) {
492 493
        decorrelate_stereo(alac->outputsamples_buffer, outputsamples,
                           interlacing_shift, interlacing_leftweight);
494 495
    }

496 497 498 499 500
    if (alac->extra_bits) {
        append_extra_bits(alac->outputsamples_buffer, alac->extra_bits_buffer,
                          alac->extra_bits, alac->numchannels, outputsamples);
    }

Vitor Sessak's avatar
Vitor Sessak committed
501
    switch(alac->setinfo_sample_size) {
Vitor Sessak's avatar
Vitor Sessak committed
502
    case 16:
Vitor Sessak's avatar
Vitor Sessak committed
503
        if (channels == 2) {
504
            interleave_stereo_16(alac->outputsamples_buffer, outbuffer,
505
                                 outputsamples);
Vitor Sessak's avatar
Vitor Sessak committed
506 507
        } else {
            for (i = 0; i < outputsamples; i++) {
508
                ((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];
Vitor Sessak's avatar
Vitor Sessak committed
509
            }
510
        }
Vitor Sessak's avatar
Vitor Sessak committed
511 512
        break;
    case 24:
513
        if (channels == 2) {
514
            interleave_stereo_24(alac->outputsamples_buffer, outbuffer,
515
                                 outputsamples);
516 517 518 519
        } else {
            for (i = 0; i < outputsamples; i++)
                ((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;
        }
Vitor Sessak's avatar
Vitor Sessak committed
520 521
        break;
    }
522

Matthieu Castet's avatar
Matthieu Castet committed
523 524 525
    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));

526
    return input_buffer_size;
527 528
}

529 530 531 532
static av_cold int alac_decode_close(AVCodecContext *avctx)
{
    ALACContext *alac = avctx->priv_data;

533 534 535 536 537
    int ch;
    for (ch = 0; ch < alac->numchannels; ch++) {
        av_freep(&alac->predicterror_buffer[ch]);
        av_freep(&alac->outputsamples_buffer[ch]);
        av_freep(&alac->extra_bits_buffer[ch]);
538 539 540 541 542 543 544
    }

    return 0;
}

static int allocate_buffers(ALACContext *alac)
{
545 546
    int ch;
    for (ch = 0; ch < alac->numchannels; ch++) {
547
        int buf_size = alac->setinfo_max_samples_per_frame * sizeof(int32_t);
548

549 550
        FF_ALLOC_OR_GOTO(alac->avctx, alac->predicterror_buffer[ch],
                         buf_size, buf_alloc_fail);
551

552 553
        FF_ALLOC_OR_GOTO(alac->avctx, alac->outputsamples_buffer[ch],
                         buf_size, buf_alloc_fail);
554

555 556
        FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch],
                         buf_size, buf_alloc_fail);
557 558
    }
    return 0;
559 560 561
buf_alloc_fail:
    alac_decode_close(alac->avctx);
    return AVERROR(ENOMEM);
562 563 564 565 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 591 592
}

static int alac_set_info(ALACContext *alac)
{
    const unsigned char *ptr = alac->avctx->extradata;

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

    if(AV_RB32(ptr) >= UINT_MAX/4){
        av_log(alac->avctx, AV_LOG_ERROR, "setinfo_max_samples_per_frame too large\n");
        return -1;
    }

    /* buffer size / 2 ? */
    alac->setinfo_max_samples_per_frame = bytestream_get_be32(&ptr);
    ptr++;                          /* ??? */
    alac->setinfo_sample_size           = *ptr++;
    alac->setinfo_rice_historymult      = *ptr++;
    alac->setinfo_rice_initialhistory   = *ptr++;
    alac->setinfo_rice_kmodifier        = *ptr++;
    alac->numchannels                   = *ptr++;
    bytestream_get_be16(&ptr);      /* ??? */
    bytestream_get_be32(&ptr);      /* max coded frame size */
    bytestream_get_be32(&ptr);      /* bitrate ? */
    bytestream_get_be32(&ptr);      /* samplerate */

    return 0;
}

593
static av_cold int alac_decode_init(AVCodecContext * avctx)
594
{
595
    int ret;
596 597
    ALACContext *alac = avctx->priv_data;
    alac->avctx = avctx;
598

Jason Garrett-Glaser's avatar
Jason Garrett-Glaser committed
599 600 601 602 603 604 605 606 607 608 609
    /* 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;
    }

610 611 612 613 614
    switch (alac->setinfo_sample_size) {
    case 16: avctx->sample_fmt    = AV_SAMPLE_FMT_S16;
             break;
    case 24: avctx->sample_fmt    = AV_SAMPLE_FMT_S32;
             break;
615 616 617
    default: av_log_ask_for_sample(avctx, "Sample depth %d is not supported.\n",
                                   alac->setinfo_sample_size);
             return AVERROR_PATCHWELCOME;
618 619
    }

620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
    if (alac->numchannels < 1) {
        av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n");
        alac->numchannels = avctx->channels;
    } else {
        if (alac->numchannels > MAX_CHANNELS)
            alac->numchannels = avctx->channels;
        else
            avctx->channels = alac->numchannels;
    }
    if (avctx->channels > MAX_CHANNELS) {
        av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n",
               avctx->channels);
        return AVERROR_PATCHWELCOME;
    }

635 636 637
    if ((ret = allocate_buffers(alac)) < 0) {
        av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n");
        return ret;
638
    }
639 640 641 642

    return 0;
}

643
AVCodec ff_alac_decoder = {
644 645 646 647 648 649 650
    .name           = "alac",
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = CODEC_ID_ALAC,
    .priv_data_size = sizeof(ALACContext),
    .init           = alac_decode_init,
    .close          = alac_decode_close,
    .decode         = alac_decode_frame,
651
    .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
652
};