alacenc.c 21.2 KB
Newer Older
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * ALAC audio encoder
 * Copyright (c) 2008  Jaikrishnan Menon <realityman@gmx.net>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg 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.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "avcodec.h"
23
#include "put_bits.h"
24
#include "internal.h"
25
#include "lpc.h"
Benoit Fouet's avatar
Benoit Fouet committed
26
#include "mathops.h"
27
#include "alac_data.h"
28 29 30 31 32 33 34 35

#define DEFAULT_FRAME_SIZE        4096
#define ALAC_EXTRADATA_SIZE       36
#define ALAC_FRAME_HEADER_SIZE    55
#define ALAC_FRAME_FOOTER_SIZE    3

#define ALAC_ESCAPE_CODE          0x1FF
#define ALAC_MAX_LPC_ORDER        30
36 37 38 39 40
#define DEFAULT_MAX_PRED_ORDER    6
#define DEFAULT_MIN_PRED_ORDER    4
#define ALAC_MAX_LPC_PRECISION    9
#define ALAC_MAX_LPC_SHIFT        9

41 42 43 44 45
#define ALAC_CHMODE_LEFT_RIGHT    0
#define ALAC_CHMODE_LEFT_SIDE     1
#define ALAC_CHMODE_RIGHT_SIDE    2
#define ALAC_CHMODE_MID_SIDE      3

46 47 48 49 50 51 52
typedef struct RiceContext {
    int history_mult;
    int initial_history;
    int k_modifier;
    int rice_modifier;
} RiceContext;

53
typedef struct AlacLPCContext {
54 55 56
    int lpc_order;
    int lpc_coeff[ALAC_MAX_LPC_ORDER+1];
    int lpc_quant;
57
} AlacLPCContext;
58 59

typedef struct AlacEncodeContext {
60
    int frame_size;                     /**< current frame size               */
61
    int verbatim;                       /**< current frame verbatim mode flag */
62
    int compression_level;
63 64
    int min_prediction_order;
    int max_prediction_order;
65 66
    int max_coded_frame_size;
    int write_sample_size;
67
    int extra_bits;
68
    int32_t sample_buf[2][DEFAULT_FRAME_SIZE];
69
    int32_t predictor_buf[2][DEFAULT_FRAME_SIZE];
70 71 72
    int interlacing_shift;
    int interlacing_leftweight;
    PutBitContext pbctx;
73
    RiceContext rc;
74
    AlacLPCContext lpc[2];
75
    LPCContext lpc_ctx;
76 77 78 79
    AVCodecContext *avctx;
} AlacEncodeContext;


80 81
static void init_sample_buffers(AlacEncodeContext *s, int channels,
                                uint8_t const *samples[2])
82 83
{
    int ch, i;
84 85 86 87
    int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -
                s->avctx->bits_per_raw_sample;

#define COPY_SAMPLES(type) do {                             \
88
        for (ch = 0; ch < channels; ch++) {                 \
89 90 91 92 93 94 95 96 97 98 99
            int32_t       *bptr = s->sample_buf[ch];        \
            const type *sptr = (const type *)samples[ch];   \
            for (i = 0; i < s->frame_size; i++)             \
                bptr[i] = sptr[i] >> shift;                 \
        }                                                   \
    } while (0)

    if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S32P)
        COPY_SAMPLES(int32_t);
    else
        COPY_SAMPLES(int16_t);
100 101
}

102 103
static void encode_scalar(AlacEncodeContext *s, int x,
                          int k, int write_sample_size)
104 105 106 107 108 109 110 111
{
    int divisor, q, r;

    k = FFMIN(k, s->rc.k_modifier);
    divisor = (1<<k) - 1;
    q = x / divisor;
    r = x % divisor;

112
    if (q > 8) {
113 114 115 116
        // write escape code and sample value directly
        put_bits(&s->pbctx, 9, ALAC_ESCAPE_CODE);
        put_bits(&s->pbctx, write_sample_size, x);
    } else {
117
        if (q)
118 119 120
            put_bits(&s->pbctx, q, (1<<q) - 1);
        put_bits(&s->pbctx, 1, 0);

121 122
        if (k != 1) {
            if (r > 0)
123 124 125 126 127 128 129
                put_bits(&s->pbctx, k, r+1);
            else
                put_bits(&s->pbctx, k-1, 0);
        }
    }
}

130 131 132
static void write_element_header(AlacEncodeContext *s,
                                 enum AlacRawDataBlockType element,
                                 int instance)
133
{
134 135 136 137 138
    int encode_fs = 0;

    if (s->frame_size < DEFAULT_FRAME_SIZE)
        encode_fs = 1;

139 140 141
    put_bits(&s->pbctx, 3,  element);               // element type
    put_bits(&s->pbctx, 4,  instance);              // element instance
    put_bits(&s->pbctx, 12, 0);                     // unused header bits
142
    put_bits(&s->pbctx, 1,  encode_fs);             // Sample count is in the header
143
    put_bits(&s->pbctx, 2,  s->extra_bits >> 3);    // Extra bytes (for 24-bit)
144
    put_bits(&s->pbctx, 1,  s->verbatim);           // Audio block is verbatim
145 146
    if (encode_fs)
        put_bits32(&s->pbctx, s->frame_size);       // No. of samples in the frame
147 148
}

149 150 151 152 153 154
static void calc_predictor_params(AlacEncodeContext *s, int ch)
{
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
    int shift[MAX_LPC_ORDER];
    int opt_order;

155
    if (s->compression_level == 1) {
156 157 158 159 160 161 162 163 164
        s->lpc[ch].lpc_order = 6;
        s->lpc[ch].lpc_quant = 6;
        s->lpc[ch].lpc_coeff[0] =  160;
        s->lpc[ch].lpc_coeff[1] = -190;
        s->lpc[ch].lpc_coeff[2] =  170;
        s->lpc[ch].lpc_coeff[3] = -130;
        s->lpc[ch].lpc_coeff[4] =   80;
        s->lpc[ch].lpc_coeff[5] =  -25;
    } else {
165
        opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, s->sample_buf[ch],
166
                                      s->frame_size,
167 168
                                      s->min_prediction_order,
                                      s->max_prediction_order,
169
                                      ALAC_MAX_LPC_PRECISION, coefs, shift,
170
                                      FF_LPC_TYPE_LEVINSON, 0,
171 172 173 174 175
                                      ORDER_METHOD_EST, ALAC_MAX_LPC_SHIFT, 1);

        s->lpc[ch].lpc_order = opt_order;
        s->lpc[ch].lpc_quant = shift[opt_order-1];
        memcpy(s->lpc[ch].lpc_coeff, coefs[opt_order-1], opt_order*sizeof(int));
176
    }
177 178
}

179 180 181 182 183 184 185 186 187
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
{
    int i, best;
    int32_t lt, rt;
    uint64_t sum[4];
    uint64_t score[4];

    /* calculate sum of 2nd order residual for each channel */
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
188
    for (i = 2; i < n; i++) {
189 190
        lt =  left_ch[i] - 2 *  left_ch[i - 1] +  left_ch[i - 2];
        rt = right_ch[i] - 2 * right_ch[i - 1] + right_ch[i - 2];
191 192 193 194 195 196 197 198 199 200 201 202 203 204
        sum[2] += FFABS((lt + rt) >> 1);
        sum[3] += FFABS(lt - rt);
        sum[0] += FFABS(lt);
        sum[1] += FFABS(rt);
    }

    /* calculate score for each mode */
    score[0] = sum[0] + sum[1];
    score[1] = sum[0] + sum[3];
    score[2] = sum[1] + sum[3];
    score[3] = sum[2] + sum[3];

    /* return mode with lowest score */
    best = 0;
205
    for (i = 1; i < 4; i++) {
206
        if (score[i] < score[best])
207 208
            best = i;
    }
209 210 211 212 213 214
    return best;
}

static void alac_stereo_decorrelation(AlacEncodeContext *s)
{
    int32_t *left = s->sample_buf[0], *right = s->sample_buf[1];
215
    int i, mode, n = s->frame_size;
216 217 218 219
    int32_t tmp;

    mode = estimate_stereo_mode(left, right, n);

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
    switch (mode) {
    case ALAC_CHMODE_LEFT_RIGHT:
        s->interlacing_leftweight = 0;
        s->interlacing_shift      = 0;
        break;
    case ALAC_CHMODE_LEFT_SIDE:
        for (i = 0; i < n; i++)
            right[i] = left[i] - right[i];
        s->interlacing_leftweight = 1;
        s->interlacing_shift      = 0;
        break;
    case ALAC_CHMODE_RIGHT_SIDE:
        for (i = 0; i < n; i++) {
            tmp = right[i];
            right[i] = left[i] - right[i];
            left[i]  = tmp + (right[i] >> 31);
        }
        s->interlacing_leftweight = 1;
        s->interlacing_shift      = 31;
        break;
    default:
        for (i = 0; i < n; i++) {
            tmp = left[i];
            left[i]  = (tmp + right[i]) >> 1;
            right[i] =  tmp - right[i];
        }
        s->interlacing_leftweight = 1;
        s->interlacing_shift      = 1;
        break;
249 250
    }
}
251

252 253 254
static void alac_linear_predictor(AlacEncodeContext *s, int ch)
{
    int i;
255
    AlacLPCContext lpc = s->lpc[ch];
256
    int32_t *residual = s->predictor_buf[ch];
257

258
    if (lpc.lpc_order == 31) {
259
        residual[0] = s->sample_buf[ch][0];
260

261
        for (i = 1; i < s->frame_size; i++) {
262 263
            residual[i] = s->sample_buf[ch][i    ] -
                          s->sample_buf[ch][i - 1];
264
        }
265 266 267 268 269 270

        return;
    }

    // generalised linear predictor

271
    if (lpc.lpc_order > 0) {
272 273 274 275
        int32_t *samples  = s->sample_buf[ch];

        // generate warm-up samples
        residual[0] = samples[0];
276
        for (i = 1; i <= lpc.lpc_order; i++)
277
            residual[i] = sign_extend(samples[i] - samples[i-1], s->write_sample_size);
278 279

        // perform lpc on remaining samples
280
        for (i = lpc.lpc_order + 1; i < s->frame_size; i++) {
281 282 283 284
            int sum = 1 << (lpc.lpc_quant - 1), res_val, j;

            for (j = 0; j < lpc.lpc_order; j++) {
                sum += (samples[lpc.lpc_order-j] - samples[0]) *
285
                       lpc.lpc_coeff[j];
286 287 288 289
            }

            sum >>= lpc.lpc_quant;
            sum += samples[0];
Benoit Fouet's avatar
Benoit Fouet committed
290 291
            residual[i] = sign_extend(samples[lpc.lpc_order+1] - sum,
                                      s->write_sample_size);
292 293
            res_val = residual[i];

294
            if (res_val) {
295 296 297
                int index = lpc.lpc_order - 1;
                int neg = (res_val < 0);

298 299
                while (index >= 0 && (neg ? (res_val < 0) : (res_val > 0))) {
                    int val  = samples[0] - samples[lpc.lpc_order - index];
300 301
                    int sign = (val ? FFSIGN(val) : 0);

302 303
                    if (neg)
                        sign *= -1;
304 305 306

                    lpc.lpc_coeff[index] -= sign;
                    val *= sign;
307
                    res_val -= (val >> lpc.lpc_quant) * (lpc.lpc_order - index);
308 309 310 311 312 313 314 315
                    index--;
                }
            }
            samples++;
        }
    }
}

316
static void alac_entropy_coder(AlacEncodeContext *s, int ch)
317 318 319
{
    unsigned int history = s->rc.initial_history;
    int sign_modifier = 0, i, k;
320
    int32_t *samples = s->predictor_buf[ch];
321

322
    for (i = 0; i < s->frame_size;) {
323 324 325 326
        int x;

        k = av_log2((history >> 9) + 3);

327 328
        x  = -2 * (*samples) -1;
        x ^= x >> 31;
329 330 331 332 333 334

        samples++;
        i++;

        encode_scalar(s, x - sign_modifier, k, s->write_sample_size);

335 336
        history += x * s->rc.history_mult -
                   ((history * s->rc.history_mult) >> 9);
337 338

        sign_modifier = 0;
339
        if (x > 0xFFFF)
340 341
            history = 0xFFFF;

342
        if (history < 128 && i < s->frame_size) {
343 344 345 346
            unsigned int block_size = 0;

            k = 7 - av_log2(history) + ((history + 16) >> 6);

347
            while (*samples == 0 && i < s->frame_size) {
348 349 350 351 352 353 354 355 356 357 358 359
                samples++;
                i++;
                block_size++;
            }
            encode_scalar(s, block_size, k, 16);
            sign_modifier = (block_size <= 0xFFFF);
            history = 0;
        }

    }
}

360 361 362
static void write_element(AlacEncodeContext *s,
                          enum AlacRawDataBlockType element, int instance,
                          const uint8_t *samples0, const uint8_t *samples1)
363
{
364 365
    uint8_t const *samples[2] = { samples0, samples1 };
    int i, j, channels;
366
    int prediction_type = 0;
367
    PutBitContext *pb = &s->pbctx;
368

369
    channels = element == TYPE_CPE ? 2 : 1;
370 371

    if (s->verbatim) {
372
        write_element_header(s, element, instance);
373
        /* samples are channel-interleaved in verbatim mode */
374 375
        if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S32P) {
            int shift = 32 - s->avctx->bits_per_raw_sample;
376 377
            int32_t const *samples_s32[2] = { (const int32_t *)samples0,
                                              (const int32_t *)samples1 };
378
            for (i = 0; i < s->frame_size; i++)
379
                for (j = 0; j < channels; j++)
380 381 382
                    put_sbits(pb, s->avctx->bits_per_raw_sample,
                              samples_s32[j][i] >> shift);
        } else {
383 384
            int16_t const *samples_s16[2] = { (const int16_t *)samples0,
                                              (const int16_t *)samples1 };
385
            for (i = 0; i < s->frame_size; i++)
386
                for (j = 0; j < channels; j++)
387 388 389
                    put_sbits(pb, s->avctx->bits_per_raw_sample,
                              samples_s16[j][i]);
        }
390
    } else {
391 392
        s->write_sample_size = s->avctx->bits_per_raw_sample - s->extra_bits +
                               channels - 1;
393

394 395 396
        init_sample_buffers(s, channels, samples);
        write_element_header(s, element, instance);

397 398 399 400 401 402 403 404 405 406 407 408 409
        // extract extra bits if needed
        if (s->extra_bits) {
            uint32_t mask = (1 << s->extra_bits) - 1;
            for (j = 0; j < channels; j++) {
                int32_t *extra = s->predictor_buf[j];
                int32_t *smp   = s->sample_buf[j];
                for (i = 0; i < s->frame_size; i++) {
                    extra[i] = smp[i] & mask;
                    smp[i] >>= s->extra_bits;
                }
            }
        }

410
        if (channels == 2)
411
            alac_stereo_decorrelation(s);
412 413
        else
            s->interlacing_shift = s->interlacing_leftweight = 0;
414 415
        put_bits(pb, 8, s->interlacing_shift);
        put_bits(pb, 8, s->interlacing_leftweight);
416

417
        for (i = 0; i < channels; i++) {
418
            calc_predictor_params(s, i);
419

420 421
            put_bits(pb, 4, prediction_type);
            put_bits(pb, 4, s->lpc[i].lpc_quant);
422

423 424 425 426 427
            put_bits(pb, 3, s->rc.rice_modifier);
            put_bits(pb, 5, s->lpc[i].lpc_order);
            // predictor coeff. table
            for (j = 0; j < s->lpc[i].lpc_order; j++)
                put_sbits(pb, 16, s->lpc[i].lpc_coeff[j]);
428 429
        }

430 431 432
        // write extra bits if needed
        if (s->extra_bits) {
            for (i = 0; i < s->frame_size; i++) {
433
                for (j = 0; j < channels; j++) {
434
                    put_bits(pb, s->extra_bits, s->predictor_buf[j][i]);
435 436 437 438
                }
            }
        }

439
        // apply lpc and entropy coding to audio samples
440
        for (i = 0; i < channels; i++) {
441
            alac_linear_predictor(s, i);
442

443 444 445
            // TODO: determine when this will actually help. for now it's not used.
            if (prediction_type == 15) {
                // 2nd pass 1st order filter
446
                int32_t *residual = s->predictor_buf[i];
447
                for (j = s->frame_size - 1; j > 0; j--)
448
                    residual[j] -= residual[j - 1];
449
            }
450
            alac_entropy_coder(s, i);
451
        }
452
    }
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
}

static int write_frame(AlacEncodeContext *s, AVPacket *avpkt,
                       uint8_t * const *samples)
{
    PutBitContext *pb = &s->pbctx;
    const enum AlacRawDataBlockType *ch_elements = ff_alac_channel_elements[s->avctx->channels - 1];
    const uint8_t *ch_map = ff_alac_channel_layout_offsets[s->avctx->channels - 1];
    int ch, element, sce, cpe;

    init_put_bits(pb, avpkt->data, avpkt->size);

    ch = element = sce = cpe = 0;
    while (ch < s->avctx->channels) {
        if (ch_elements[element] == TYPE_CPE) {
            write_element(s, TYPE_CPE, cpe, samples[ch_map[ch]],
                          samples[ch_map[ch + 1]]);
            cpe++;
            ch += 2;
        } else {
            write_element(s, TYPE_SCE, sce, samples[ch_map[ch]], NULL);
            sce++;
            ch++;
        }
        element++;
    }

    put_bits(pb, 3, TYPE_END);
481
    flush_put_bits(pb);
482

483
    return put_bits_count(pb) >> 3;
484 485
}

486 487
static av_always_inline int get_max_frame_size(int frame_size, int ch, int bps)
{
488 489
    int header_bits = 23 + 32 * (frame_size < DEFAULT_FRAME_SIZE);
    return FFALIGN(header_bits + bps * ch * frame_size + 3, 8) / 8;
490 491
}

492 493 494 495 496 497 498
static av_cold int alac_encode_close(AVCodecContext *avctx)
{
    AlacEncodeContext *s = avctx->priv_data;
    ff_lpc_end(&s->lpc_ctx);
    av_freep(&avctx->extradata);
    avctx->extradata_size = 0;
    return 0;
499 500 501 502
}

static av_cold int alac_encode_init(AVCodecContext *avctx)
{
503
    AlacEncodeContext *s = avctx->priv_data;
504
    int ret;
505
    uint8_t *alac_extradata;
506

507
    avctx->frame_size = s->frame_size = DEFAULT_FRAME_SIZE;
508

509 510 511 512 513 514 515 516 517
    if (avctx->sample_fmt == AV_SAMPLE_FMT_S32P) {
        if (avctx->bits_per_raw_sample != 24)
            av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");
        avctx->bits_per_raw_sample = 24;
    } else {
        avctx->bits_per_raw_sample = 16;
        s->extra_bits              = 0;
    }

518
    // Set default compression level
519
    if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
520
        s->compression_level = 2;
521
    else
522
        s->compression_level = av_clip(avctx->compression_level, 0, 2);
523 524 525 526 527 528 529

    // Initialize default Rice parameters
    s->rc.history_mult    = 40;
    s->rc.initial_history = 10;
    s->rc.k_modifier      = 14;
    s->rc.rice_modifier   = 4;

530 531
    s->max_coded_frame_size = get_max_frame_size(avctx->frame_size,
                                                 avctx->channels,
532
                                                 avctx->bits_per_raw_sample);
533

534
    avctx->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE);
535 536 537 538 539 540 541
    if (!avctx->extradata) {
        ret = AVERROR(ENOMEM);
        goto error;
    }
    avctx->extradata_size = ALAC_EXTRADATA_SIZE;

    alac_extradata = avctx->extradata;
542 543 544
    AV_WB32(alac_extradata,    ALAC_EXTRADATA_SIZE);
    AV_WB32(alac_extradata+4,  MKBETAG('a','l','a','c'));
    AV_WB32(alac_extradata+12, avctx->frame_size);
545
    AV_WB8 (alac_extradata+17, avctx->bits_per_raw_sample);
546
    AV_WB8 (alac_extradata+21, avctx->channels);
547
    AV_WB32(alac_extradata+24, s->max_coded_frame_size);
548
    AV_WB32(alac_extradata+28,
549
            avctx->sample_rate * avctx->channels * avctx->bits_per_raw_sample); // average bitrate
550
    AV_WB32(alac_extradata+32, avctx->sample_rate);
551 552

    // Set relevant extradata fields
553
    if (s->compression_level > 0) {
554 555 556 557 558
        AV_WB8(alac_extradata+18, s->rc.history_mult);
        AV_WB8(alac_extradata+19, s->rc.initial_history);
        AV_WB8(alac_extradata+20, s->rc.k_modifier);
    }

559
    s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
560 561
    if (avctx->min_prediction_order >= 0) {
        if (avctx->min_prediction_order < MIN_LPC_ORDER ||
562
           avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
563 564
            av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
                   avctx->min_prediction_order);
565 566
            ret = AVERROR(EINVAL);
            goto error;
567 568 569 570 571
        }

        s->min_prediction_order = avctx->min_prediction_order;
    }

572
    s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
573 574 575 576 577
    if (avctx->max_prediction_order >= 0) {
        if (avctx->max_prediction_order < MIN_LPC_ORDER ||
            avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) {
            av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
                   avctx->max_prediction_order);
578 579
            ret = AVERROR(EINVAL);
            goto error;
580 581 582 583 584
        }

        s->max_prediction_order = avctx->max_prediction_order;
    }

585 586 587
    if (s->max_prediction_order < s->min_prediction_order) {
        av_log(avctx, AV_LOG_ERROR,
               "invalid prediction orders: min=%d max=%d\n",
588
               s->min_prediction_order, s->max_prediction_order);
589 590
        ret = AVERROR(EINVAL);
        goto error;
591 592
    }

593 594
    s->avctx = avctx;

595 596 597 598 599 600 601 602 603
    if ((ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,
                           s->max_prediction_order,
                           FF_LPC_TYPE_LEVINSON)) < 0) {
        goto error;
    }

    return 0;
error:
    alac_encode_close(avctx);
604
    return ret;
605 606
}

607 608
static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
                             const AVFrame *frame, int *got_packet_ptr)
609 610
{
    AlacEncodeContext *s = avctx->priv_data;
611
    int out_bytes, max_frame_size, ret;
612

613
    s->frame_size = frame->nb_samples;
614

615
    if (frame->nb_samples < DEFAULT_FRAME_SIZE)
616
        max_frame_size = get_max_frame_size(s->frame_size, avctx->channels,
617
                                            avctx->bits_per_raw_sample);
618 619
    else
        max_frame_size = s->max_coded_frame_size;
620

621
    if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * max_frame_size, 0)) < 0)
622
        return ret;
623

624
    /* use verbatim mode for compression_level 0 */
625 626 627 628 629 630 631
    if (s->compression_level) {
        s->verbatim   = 0;
        s->extra_bits = avctx->bits_per_raw_sample - 16;
    } else {
        s->verbatim   = 1;
        s->extra_bits = 0;
    }
632

633
    out_bytes = write_frame(s, avpkt, frame->extended_data);
634

635
    if (out_bytes > max_frame_size) {
636
        /* frame too large. use verbatim mode */
637
        s->verbatim = 1;
638 639
        s->extra_bits = 0;
        out_bytes = write_frame(s, avpkt, frame->extended_data);
640 641
    }

642 643
    avpkt->size = out_bytes;
    *got_packet_ptr = 1;
644 645 646
    return 0;
}

647
AVCodec ff_alac_encoder = {
648
    .name           = "alac",
649
    .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
650
    .type           = AVMEDIA_TYPE_AUDIO,
651
    .id             = AV_CODEC_ID_ALAC,
652 653
    .priv_data_size = sizeof(AlacEncodeContext),
    .init           = alac_encode_init,
654
    .encode2        = alac_encode_frame,
655
    .close          = alac_encode_close,
656
    .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME,
657
    .channel_layouts = ff_alac_channel_layouts,
658 659
    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32P,
                                                     AV_SAMPLE_FMT_S16P,
660
                                                     AV_SAMPLE_FMT_NONE },
661
};