alacenc.c 21.5 KB
Newer Older
1
/*
2 3 4
 * ALAC audio encoder
 * Copyright (c) 2008  Jaikrishnan Menon <realityman@gmx.net>
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9 10 11
 * 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.
 *
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 20 21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22 23
#include "libavutil/opt.h"

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

#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
38 39 40 41 42
#define DEFAULT_MAX_PRED_ORDER    6
#define DEFAULT_MIN_PRED_ORDER    4
#define ALAC_MAX_LPC_PRECISION    9
#define ALAC_MAX_LPC_SHIFT        9

43 44 45 46 47
#define ALAC_CHMODE_LEFT_RIGHT    0
#define ALAC_CHMODE_LEFT_SIDE     1
#define ALAC_CHMODE_RIGHT_SIDE    2
#define ALAC_CHMODE_MID_SIDE      3

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

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

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


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

#define COPY_SAMPLES(type) do {                             \
91
        for (ch = 0; ch < channels; ch++) {                 \
92 93 94 95 96 97 98 99 100 101 102
            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);
103 104
}

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

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

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

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

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

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

142 143 144
    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
145
    put_bits(&s->pbctx, 1,  encode_fs);             // Sample count is in the header
146
    put_bits(&s->pbctx, 2,  s->extra_bits >> 3);    // Extra bytes (for 24-bit)
147
    put_bits(&s->pbctx, 1,  s->verbatim);           // Audio block is verbatim
148 149
    if (encode_fs)
        put_bits32(&s->pbctx, s->frame_size);       // No. of samples in the frame
150 151
}

152 153 154 155 156 157
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;

158
    if (s->compression_level == 1) {
159 160 161 162 163 164 165 166 167
        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 {
168
        opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, s->sample_buf[ch],
169
                                      s->frame_size,
170 171
                                      s->min_prediction_order,
                                      s->max_prediction_order,
172
                                      ALAC_MAX_LPC_PRECISION, coefs, shift,
173
                                      FF_LPC_TYPE_LEVINSON, 0,
174 175 176 177 178
                                      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));
179
    }
180 181
}

182 183 184 185 186 187 188 189 190
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;
191
    for (i = 2; i < n; i++) {
192 193
        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];
194 195 196 197 198 199 200 201 202 203 204 205 206 207
        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;
208
    for (i = 1; i < 4; i++) {
209
        if (score[i] < score[best])
210 211
            best = i;
    }
212 213 214 215 216 217
    return best;
}

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

    mode = estimate_stereo_mode(left, right, n);

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 249 250 251
    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;
252 253
    }
}
254

255 256 257
static void alac_linear_predictor(AlacEncodeContext *s, int ch)
{
    int i;
258
    AlacLPCContext lpc = s->lpc[ch];
259

260
    if (lpc.lpc_order == 31) {
261 262
        s->predictor_buf[0] = s->sample_buf[ch][0];

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

        return;
    }

    // generalised linear predictor

273
    if (lpc.lpc_order > 0) {
274 275 276 277 278
        int32_t *samples  = s->sample_buf[ch];
        int32_t *residual = s->predictor_buf;

        // generate warm-up samples
        residual[0] = samples[0];
279
        for (i = 1; i <= lpc.lpc_order; i++)
280 281 282
            residual[i] = samples[i] - samples[i-1];

        // perform lpc on remaining samples
283
        for (i = lpc.lpc_order + 1; i < s->frame_size; i++) {
284 285 286 287
            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]) *
288
                       lpc.lpc_coeff[j];
289 290 291 292
            }

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

297
            if (res_val) {
298 299 300
                int index = lpc.lpc_order - 1;
                int neg = (res_val < 0);

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

305 306
                    if (neg)
                        sign *= -1;
307 308 309

                    lpc.lpc_coeff[index] -= sign;
                    val *= sign;
310
                    res_val -= (val >> lpc.lpc_quant) * (lpc.lpc_order - index);
311 312 313 314 315 316 317 318 319 320 321 322 323 324
                    index--;
                }
            }
            samples++;
        }
    }
}

static void alac_entropy_coder(AlacEncodeContext *s)
{
    unsigned int history = s->rc.initial_history;
    int sign_modifier = 0, i, k;
    int32_t *samples = s->predictor_buf;

325
    for (i = 0; i < s->frame_size;) {
326 327 328 329
        int x;

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

330 331
        x  = -2 * (*samples) -1;
        x ^= x >> 31;
332 333 334 335 336 337

        samples++;
        i++;

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

338 339
        history += x * s->rc.history_mult -
                   ((history * s->rc.history_mult) >> 9);
340 341

        sign_modifier = 0;
342
        if (x > 0xFFFF)
343 344
            history = 0xFFFF;

345
        if (history < 128 && i < s->frame_size) {
346 347 348 349
            unsigned int block_size = 0;

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

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

    }
}

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

372
    channels = element == TYPE_CPE ? 2 : 1;
373 374

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

397 398 399 400
        init_sample_buffers(s, channels, samples);
        write_element_header(s, element, instance);

        if (channels == 2)
401
            alac_stereo_decorrelation(s);
402 403
        else
            s->interlacing_shift = s->interlacing_leftweight = 0;
404 405
        put_bits(pb, 8, s->interlacing_shift);
        put_bits(pb, 8, s->interlacing_leftweight);
406

407
        for (i = 0; i < channels; i++) {
408
            calc_predictor_params(s, i);
409

410 411
            put_bits(pb, 4, prediction_type);
            put_bits(pb, 4, s->lpc[i].lpc_quant);
412

413 414 415 416 417 418
            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]);
        }
419

420 421 422 423
        // write extra bits if needed
        if (s->extra_bits) {
            uint32_t mask = (1 << s->extra_bits) - 1;
            for (i = 0; i < s->frame_size; i++) {
424
                for (j = 0; j < channels; j++) {
425 426 427 428 429 430
                    put_bits(pb, s->extra_bits, s->sample_buf[j][i] & mask);
                    s->sample_buf[j][i] >>= s->extra_bits;
                }
            }
        }

431
        // apply lpc and entropy coding to audio samples
432
        for (i = 0; i < channels; i++) {
433
            alac_linear_predictor(s, i);
434

435 436 437 438 439 440 441 442
            // TODO: determine when this will actually help. for now it's not used.
            if (prediction_type == 15) {
                // 2nd pass 1st order filter
                for (j = s->frame_size - 1; j > 0; j--)
                    s->predictor_buf[j] -= s->predictor_buf[j - 1];
            }
            alac_entropy_coder(s);
        }
443
    }
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
}

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);
472
    flush_put_bits(pb);
473

474
    return put_bits_count(pb) >> 3;
475 476
}

477 478
static av_always_inline int get_max_frame_size(int frame_size, int ch, int bps)
{
479 480
    int header_bits = 23 + 32 * (frame_size < DEFAULT_FRAME_SIZE);
    return FFALIGN(header_bits + bps * ch * frame_size + 3, 8) / 8;
481 482
}

483 484 485 486 487 488 489 490 491
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;
}

492 493
static av_cold int alac_encode_init(AVCodecContext *avctx)
{
494
    AlacEncodeContext *s = avctx->priv_data;
495
    int ret;
496
    uint8_t *alac_extradata;
497

498
    avctx->frame_size = s->frame_size = DEFAULT_FRAME_SIZE;
499

500 501 502 503 504 505 506 507 508
    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;
    }

509
    // Set default compression level
510
    if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
511
        s->compression_level = 2;
512
    else
513
        s->compression_level = av_clip(avctx->compression_level, 0, 2);
514 515 516 517 518 519 520

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

521 522
    s->max_coded_frame_size = get_max_frame_size(avctx->frame_size,
                                                 avctx->channels,
523
                                                 avctx->bits_per_raw_sample);
524

525
    avctx->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE);
526 527 528 529 530 531 532
    if (!avctx->extradata) {
        ret = AVERROR(ENOMEM);
        goto error;
    }
    avctx->extradata_size = ALAC_EXTRADATA_SIZE;

    alac_extradata = avctx->extradata;
533 534 535
    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);
536
    AV_WB8 (alac_extradata+17, avctx->bits_per_raw_sample);
537
    AV_WB8 (alac_extradata+21, avctx->channels);
538
    AV_WB32(alac_extradata+24, s->max_coded_frame_size);
539
    AV_WB32(alac_extradata+28,
540
            avctx->sample_rate * avctx->channels * avctx->bits_per_raw_sample); // average bitrate
541
    AV_WB32(alac_extradata+32, avctx->sample_rate);
542 543

    // Set relevant extradata fields
544
    if (s->compression_level > 0) {
545 546 547 548 549
        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);
    }

550 551
#if FF_API_PRIVATE_OPT
FF_DISABLE_DEPRECATION_WARNINGS
552 553
    if (avctx->min_prediction_order >= 0) {
        if (avctx->min_prediction_order < MIN_LPC_ORDER ||
554
           avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
555 556
            av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
                   avctx->min_prediction_order);
557 558
            ret = AVERROR(EINVAL);
            goto error;
559 560 561 562 563
        }

        s->min_prediction_order = avctx->min_prediction_order;
    }

564 565 566 567 568
    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);
569 570
            ret = AVERROR(EINVAL);
            goto error;
571 572 573 574
        }

        s->max_prediction_order = avctx->max_prediction_order;
    }
575 576
FF_ENABLE_DEPRECATION_WARNINGS
#endif
577

578 579 580
    if (s->max_prediction_order < s->min_prediction_order) {
        av_log(avctx, AV_LOG_ERROR,
               "invalid prediction orders: min=%d max=%d\n",
581
               s->min_prediction_order, s->max_prediction_order);
582 583
        ret = AVERROR(EINVAL);
        goto error;
584 585
    }

586 587
    s->avctx = avctx;

588 589 590 591 592 593 594 595 596
    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);
597
    return ret;
598 599
}

600 601
static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
                             const AVFrame *frame, int *got_packet_ptr)
602 603
{
    AlacEncodeContext *s = avctx->priv_data;
604
    int out_bytes, max_frame_size, ret;
605

606
    s->frame_size = frame->nb_samples;
607

608
    if (frame->nb_samples < DEFAULT_FRAME_SIZE)
609
        max_frame_size = get_max_frame_size(s->frame_size, avctx->channels,
610
                                            avctx->bits_per_raw_sample);
611 612
    else
        max_frame_size = s->max_coded_frame_size;
613

614 615 616
    if ((ret = ff_alloc_packet(avpkt, 2 * max_frame_size))) {
        av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
        return ret;
617 618
    }

619
    /* use verbatim mode for compression_level 0 */
620 621 622 623 624 625 626
    if (s->compression_level) {
        s->verbatim   = 0;
        s->extra_bits = avctx->bits_per_raw_sample - 16;
    } else {
        s->verbatim   = 1;
        s->extra_bits = 0;
    }
627

628
    out_bytes = write_frame(s, avpkt, frame->extended_data);
629

630
    if (out_bytes > max_frame_size) {
631
        /* frame too large. use verbatim mode */
632
        s->verbatim = 1;
633 634
        s->extra_bits = 0;
        out_bytes = write_frame(s, avpkt, frame->extended_data);
635 636
    }

637 638 639
    avpkt->size = out_bytes;
    *got_packet_ptr = 1;
    return 0;
640 641
}

642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
#define OFFSET(x) offsetof(AlacEncodeContext, x)
#define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
    { "min_prediction_order", NULL, OFFSET(min_prediction_order), AV_OPT_TYPE_INT, { .i64 = DEFAULT_MIN_PRED_ORDER }, MIN_LPC_ORDER, ALAC_MAX_LPC_ORDER, AE },
    { "max_prediction_order", NULL, OFFSET(max_prediction_order), AV_OPT_TYPE_INT, { .i64 = DEFAULT_MAX_PRED_ORDER }, MIN_LPC_ORDER, ALAC_MAX_LPC_ORDER, AE },

    { NULL },
};

static const AVClass alacenc_class = {
    .class_name = "alacenc",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

658
AVCodec ff_alac_encoder = {
659
    .name           = "alac",
660
    .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
661
    .type           = AVMEDIA_TYPE_AUDIO,
662
    .id             = AV_CODEC_ID_ALAC,
663
    .priv_data_size = sizeof(AlacEncodeContext),
664
    .priv_class     = &alacenc_class,
665
    .init           = alac_encode_init,
666
    .encode2        = alac_encode_frame,
667
    .close          = alac_encode_close,
668
    .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME,
669
    .channel_layouts = ff_alac_channel_layouts,
670 671
    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32P,
                                                     AV_SAMPLE_FMT_S16P,
672
                                                     AV_SAMPLE_FMT_NONE },
673
};