alacenc.c 20.8 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[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

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

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

        return;
    }

    // generalised linear predictor

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

        // 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 316 317 318 319 320 321
                    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;

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 397
        init_sample_buffers(s, channels, samples);
        write_element_header(s, element, instance);

        if (channels == 2)
398
            alac_stereo_decorrelation(s);
399 400
        else
            s->interlacing_shift = s->interlacing_leftweight = 0;
401 402
        put_bits(pb, 8, s->interlacing_shift);
        put_bits(pb, 8, s->interlacing_leftweight);
403

404
        for (i = 0; i < channels; i++) {
405
            calc_predictor_params(s, i);
406

407 408
            put_bits(pb, 4, prediction_type);
            put_bits(pb, 4, s->lpc[i].lpc_quant);
409

410 411 412 413 414
            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]);
415 416
        }

417 418 419 420
        // 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++) {
421
                for (j = 0; j < channels; j++) {
422 423 424 425 426 427
                    put_bits(pb, s->extra_bits, s->sample_buf[j][i] & mask);
                    s->sample_buf[j][i] >>= s->extra_bits;
                }
            }
        }

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

432 433 434 435 436 437 438 439
            // 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);
        }
440
    }
441 442 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
}

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);
469
    flush_put_bits(pb);
470

471
    return put_bits_count(pb) >> 3;
472 473
}

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

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

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

495
    avctx->frame_size = s->frame_size = DEFAULT_FRAME_SIZE;
496

497 498 499 500 501 502 503 504 505
    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;
    }

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

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

518 519
    s->max_coded_frame_size = get_max_frame_size(avctx->frame_size,
                                                 avctx->channels,
520
                                                 avctx->bits_per_raw_sample);
521

522 523 524 525 526 527 528 529
    avctx->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
    if (!avctx->extradata) {
        ret = AVERROR(ENOMEM);
        goto error;
    }
    avctx->extradata_size = ALAC_EXTRADATA_SIZE;

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

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

547
    s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
548 549
    if (avctx->min_prediction_order >= 0) {
        if (avctx->min_prediction_order < MIN_LPC_ORDER ||
550
           avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
551 552
            av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
                   avctx->min_prediction_order);
553 554
            ret = AVERROR(EINVAL);
            goto error;
555 556 557 558 559
        }

        s->min_prediction_order = avctx->min_prediction_order;
    }

560
    s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
561 562 563 564 565
    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);
566 567
            ret = AVERROR(EINVAL);
            goto error;
568 569 570 571 572
        }

        s->max_prediction_order = avctx->max_prediction_order;
    }

573 574 575
    if (s->max_prediction_order < s->min_prediction_order) {
        av_log(avctx, AV_LOG_ERROR,
               "invalid prediction orders: min=%d max=%d\n",
576
               s->min_prediction_order, s->max_prediction_order);
577 578
        ret = AVERROR(EINVAL);
        goto error;
579 580
    }

581 582
    s->avctx = avctx;

583 584 585 586 587 588 589 590 591
    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);
592
    return ret;
593 594
}

595 596
static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
                             const AVFrame *frame, int *got_packet_ptr)
597 598
{
    AlacEncodeContext *s = avctx->priv_data;
599
    int out_bytes, max_frame_size, ret;
600

601
    s->frame_size = frame->nb_samples;
602

603
    if (frame->nb_samples < DEFAULT_FRAME_SIZE)
604
        max_frame_size = get_max_frame_size(s->frame_size, avctx->channels,
605
                                            avctx->bits_per_raw_sample);
606 607
    else
        max_frame_size = s->max_coded_frame_size;
608

609
    if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * max_frame_size)) < 0)
610
        return ret;
611

612
    /* use verbatim mode for compression_level 0 */
613 614 615 616 617 618 619
    if (s->compression_level) {
        s->verbatim   = 0;
        s->extra_bits = avctx->bits_per_raw_sample - 16;
    } else {
        s->verbatim   = 1;
        s->extra_bits = 0;
    }
620

621
    out_bytes = write_frame(s, avpkt, frame->extended_data);
622

623
    if (out_bytes > max_frame_size) {
624
        /* frame too large. use verbatim mode */
625
        s->verbatim = 1;
626 627
        s->extra_bits = 0;
        out_bytes = write_frame(s, avpkt, frame->extended_data);
628 629
    }

630 631
    avpkt->size = out_bytes;
    *got_packet_ptr = 1;
632 633 634
    return 0;
}

635
AVCodec ff_alac_encoder = {
636
    .name           = "alac",
637
    .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
638
    .type           = AVMEDIA_TYPE_AUDIO,
639
    .id             = AV_CODEC_ID_ALAC,
640 641
    .priv_data_size = sizeof(AlacEncodeContext),
    .init           = alac_encode_init,
642
    .encode2        = alac_encode_frame,
643
    .close          = alac_encode_close,
644
    .capabilities   = CODEC_CAP_SMALL_LAST_FRAME,
645
    .channel_layouts = ff_alac_channel_layouts,
646 647
    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32P,
                                                     AV_SAMPLE_FMT_S16P,
648
                                                     AV_SAMPLE_FMT_NONE },
649
};