Statistics
| Branch: | Revision:

ffmpeg / libavcodec / alacenc.c @ 3d5e1bfb

History | View | Annotate | Download (15.4 KB)

1
/**
2
 * ALAC audio encoder
3
 * Copyright (c) 2008  Jaikrishnan Menon <realityman@gmx.net>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "avcodec.h"
23
#include "bitstream.h"
24
#include "dsputil.h"
25
#include "lpc.h"
26

    
27
#define DEFAULT_FRAME_SIZE        4096
28
#define DEFAULT_SAMPLE_SIZE       16
29
#define MAX_CHANNELS              8
30
#define ALAC_EXTRADATA_SIZE       36
31
#define ALAC_FRAME_HEADER_SIZE    55
32
#define ALAC_FRAME_FOOTER_SIZE    3
33

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

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

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

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

    
59
typedef struct AlacEncodeContext {
60
    int compression_level;
61
    int min_prediction_order;
62
    int max_prediction_order;
63
    int max_coded_frame_size;
64
    int write_sample_size;
65
    int32_t sample_buf[MAX_CHANNELS][DEFAULT_FRAME_SIZE];
66
    int32_t predictor_buf[DEFAULT_FRAME_SIZE];
67
    int interlacing_shift;
68
    int interlacing_leftweight;
69
    PutBitContext pbctx;
70
    RiceContext rc;
71
    LPCContext lpc[MAX_CHANNELS];
72
    DSPContext dspctx;
73
    AVCodecContext *avctx;
74
} AlacEncodeContext;
75

    
76

    
77
static void init_sample_buffers(AlacEncodeContext *s, int16_t *input_samples)
78
{
79
    int ch, i;
80

    
81
    for(ch=0;ch<s->avctx->channels;ch++) {
82
        int16_t *sptr = input_samples + ch;
83
        for(i=0;i<s->avctx->frame_size;i++) {
84
            s->sample_buf[ch][i] = *sptr;
85
            sptr += s->avctx->channels;
86
        }
87
    }
88
}
89

    
90
static void encode_scalar(AlacEncodeContext *s, int x, int k, int write_sample_size)
91
{
92
    int divisor, q, r;
93

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

    
99
    if(q > 8) {
100
        // write escape code and sample value directly
101
        put_bits(&s->pbctx, 9, ALAC_ESCAPE_CODE);
102
        put_bits(&s->pbctx, write_sample_size, x);
103
    } else {
104
        if(q)
105
            put_bits(&s->pbctx, q, (1<<q) - 1);
106
        put_bits(&s->pbctx, 1, 0);
107

    
108
        if(k != 1) {
109
            if(r > 0)
110
                put_bits(&s->pbctx, k, r+1);
111
            else
112
                put_bits(&s->pbctx, k-1, 0);
113
        }
114
    }
115
}
116

    
117
static void write_frame_header(AlacEncodeContext *s, int is_verbatim)
118
{
119
    put_bits(&s->pbctx, 3,  s->avctx->channels-1);          // No. of channels -1
120
    put_bits(&s->pbctx, 16, 0);                             // Seems to be zero
121
    put_bits(&s->pbctx, 1,  1);                             // Sample count is in the header
122
    put_bits(&s->pbctx, 2,  0);                             // FIXME: Wasted bytes field
123
    put_bits(&s->pbctx, 1,  is_verbatim);                   // Audio block is verbatim
124
    put_bits(&s->pbctx, 32, s->avctx->frame_size);          // No. of samples in the frame
125
}
126

    
127
static void calc_predictor_params(AlacEncodeContext *s, int ch)
128
{
129
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
130
    int shift[MAX_LPC_ORDER];
131
    int opt_order;
132

    
133
    opt_order = ff_lpc_calc_coefs(&s->dspctx, s->sample_buf[ch], s->avctx->frame_size, s->min_prediction_order, s->max_prediction_order,
134
                                   ALAC_MAX_LPC_PRECISION, coefs, shift, 1, ORDER_METHOD_EST, ALAC_MAX_LPC_SHIFT, 1);
135

    
136
    s->lpc[ch].lpc_order = opt_order;
137
    s->lpc[ch].lpc_quant = shift[opt_order-1];
138
    memcpy(s->lpc[ch].lpc_coeff, coefs[opt_order-1], opt_order*sizeof(int));
139
}
140

    
141
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
142
{
143
    int i, best;
144
    int32_t lt, rt;
145
    uint64_t sum[4];
146
    uint64_t score[4];
147

    
148
    /* calculate sum of 2nd order residual for each channel */
149
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
150
    for(i=2; i<n; i++) {
151
        lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
152
        rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
153
        sum[2] += FFABS((lt + rt) >> 1);
154
        sum[3] += FFABS(lt - rt);
155
        sum[0] += FFABS(lt);
156
        sum[1] += FFABS(rt);
157
    }
158

    
159
    /* calculate score for each mode */
160
    score[0] = sum[0] + sum[1];
161
    score[1] = sum[0] + sum[3];
162
    score[2] = sum[1] + sum[3];
163
    score[3] = sum[2] + sum[3];
164

    
165
    /* return mode with lowest score */
166
    best = 0;
167
    for(i=1; i<4; i++) {
168
        if(score[i] < score[best]) {
169
            best = i;
170
        }
171
    }
172
    return best;
173
}
174

    
175
static void alac_stereo_decorrelation(AlacEncodeContext *s)
176
{
177
    int32_t *left = s->sample_buf[0], *right = s->sample_buf[1];
178
    int i, mode, n = s->avctx->frame_size;
179
    int32_t tmp;
180

    
181
    mode = estimate_stereo_mode(left, right, n);
182

    
183
    switch(mode)
184
    {
185
        case ALAC_CHMODE_LEFT_RIGHT:
186
            s->interlacing_leftweight = 0;
187
            s->interlacing_shift = 0;
188
            break;
189

    
190
        case ALAC_CHMODE_LEFT_SIDE:
191
            for(i=0; i<n; i++) {
192
                right[i] = left[i] - right[i];
193
            }
194
            s->interlacing_leftweight = 1;
195
            s->interlacing_shift = 0;
196
            break;
197

    
198
        case ALAC_CHMODE_RIGHT_SIDE:
199
            for(i=0; i<n; i++) {
200
                tmp = right[i];
201
                right[i] = left[i] - right[i];
202
                left[i] = tmp + (right[i] >> 31);
203
            }
204
            s->interlacing_leftweight = 1;
205
            s->interlacing_shift = 31;
206
            break;
207

    
208
        default:
209
            for(i=0; i<n; i++) {
210
                tmp = left[i];
211
                left[i] = (tmp + right[i]) >> 1;
212
                right[i] = tmp - right[i];
213
            }
214
            s->interlacing_leftweight = 1;
215
            s->interlacing_shift = 1;
216
            break;
217
    }
218
}
219

    
220
static void alac_linear_predictor(AlacEncodeContext *s, int ch)
221
{
222
    int i;
223
    LPCContext lpc = s->lpc[ch];
224

    
225
    if(lpc.lpc_order == 31) {
226
        s->predictor_buf[0] = s->sample_buf[ch][0];
227

    
228
        for(i=1; i<s->avctx->frame_size; i++)
229
            s->predictor_buf[i] = s->sample_buf[ch][i] - s->sample_buf[ch][i-1];
230

    
231
        return;
232
    }
233

    
234
    // generalised linear predictor
235

    
236
    if(lpc.lpc_order > 0) {
237
        int32_t *samples  = s->sample_buf[ch];
238
        int32_t *residual = s->predictor_buf;
239

    
240
        // generate warm-up samples
241
        residual[0] = samples[0];
242
        for(i=1;i<=lpc.lpc_order;i++)
243
            residual[i] = samples[i] - samples[i-1];
244

    
245
        // perform lpc on remaining samples
246
        for(i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) {
247
            int sum = 1 << (lpc.lpc_quant - 1), res_val, j;
248

    
249
            for (j = 0; j < lpc.lpc_order; j++) {
250
                sum += (samples[lpc.lpc_order-j] - samples[0]) *
251
                        lpc.lpc_coeff[j];
252
            }
253

    
254
            sum >>= lpc.lpc_quant;
255
            sum += samples[0];
256
            residual[i] = (samples[lpc.lpc_order+1] - sum) << (32 - s->write_sample_size) >>
257
                          (32 - s->write_sample_size);
258
            res_val = residual[i];
259

    
260
            if(res_val) {
261
                int index = lpc.lpc_order - 1;
262
                int neg = (res_val < 0);
263

    
264
                while(index >= 0 && (neg ? (res_val < 0):(res_val > 0))) {
265
                    int val = samples[0] - samples[lpc.lpc_order - index];
266
                    int sign = (val ? FFSIGN(val) : 0);
267

    
268
                    if(neg)
269
                        sign*=-1;
270

    
271
                    lpc.lpc_coeff[index] -= sign;
272
                    val *= sign;
273
                    res_val -= ((val >> lpc.lpc_quant) *
274
                            (lpc.lpc_order - index));
275
                    index--;
276
                }
277
            }
278
            samples++;
279
        }
280
    }
281
}
282

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

    
289
    for(i=0;i < s->avctx->frame_size;) {
290
        int x;
291

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

    
294
        x = -2*(*samples)-1;
295
        x ^= (x>>31);
296

    
297
        samples++;
298
        i++;
299

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

    
302
        history += x * s->rc.history_mult
303
                   - ((history * s->rc.history_mult) >> 9);
304

    
305
        sign_modifier = 0;
306
        if(x > 0xFFFF)
307
            history = 0xFFFF;
308

    
309
        if((history < 128) && (i < s->avctx->frame_size)) {
310
            unsigned int block_size = 0;
311

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

    
314
            while((*samples == 0) && (i < s->avctx->frame_size)) {
315
                samples++;
316
                i++;
317
                block_size++;
318
            }
319
            encode_scalar(s, block_size, k, 16);
320

    
321
            sign_modifier = (block_size <= 0xFFFF);
322

    
323
            history = 0;
324
        }
325

    
326
    }
327
}
328

    
329
static void write_compressed_frame(AlacEncodeContext *s)
330
{
331
    int i, j;
332

    
333
    /* only simple mid/side decorrelation supported as of now */
334
    if(s->avctx->channels == 2)
335
        alac_stereo_decorrelation(s);
336
    put_bits(&s->pbctx, 8, s->interlacing_shift);
337
    put_bits(&s->pbctx, 8, s->interlacing_leftweight);
338

    
339
    for(i=0;i<s->avctx->channels;i++) {
340

    
341
        calc_predictor_params(s, i);
342

    
343
        put_bits(&s->pbctx, 4, 0);  // prediction type : currently only type 0 has been RE'd
344
        put_bits(&s->pbctx, 4, s->lpc[i].lpc_quant);
345

    
346
        put_bits(&s->pbctx, 3, s->rc.rice_modifier);
347
        put_bits(&s->pbctx, 5, s->lpc[i].lpc_order);
348
        // predictor coeff. table
349
        for(j=0;j<s->lpc[i].lpc_order;j++) {
350
            put_sbits(&s->pbctx, 16, s->lpc[i].lpc_coeff[j]);
351
        }
352
    }
353

    
354
    // apply lpc and entropy coding to audio samples
355

    
356
    for(i=0;i<s->avctx->channels;i++) {
357
        alac_linear_predictor(s, i);
358
        alac_entropy_coder(s);
359
    }
360
}
361

    
362
static av_cold int alac_encode_init(AVCodecContext *avctx)
363
{
364
    AlacEncodeContext *s    = avctx->priv_data;
365
    uint8_t *alac_extradata = av_mallocz(ALAC_EXTRADATA_SIZE+1);
366

    
367
    avctx->frame_size      = DEFAULT_FRAME_SIZE;
368
    avctx->bits_per_coded_sample = DEFAULT_SAMPLE_SIZE;
369

    
370
    if(avctx->sample_fmt != SAMPLE_FMT_S16) {
371
        av_log(avctx, AV_LOG_ERROR, "only pcm_s16 input samples are supported\n");
372
        return -1;
373
    }
374

    
375
    // Set default compression level
376
    if(avctx->compression_level == FF_COMPRESSION_DEFAULT)
377
        s->compression_level = 1;
378
    else
379
        s->compression_level = av_clip(avctx->compression_level, 0, 1);
380

    
381
    // Initialize default Rice parameters
382
    s->rc.history_mult    = 40;
383
    s->rc.initial_history = 10;
384
    s->rc.k_modifier      = 14;
385
    s->rc.rice_modifier   = 4;
386

    
387
    s->max_coded_frame_size = (ALAC_FRAME_HEADER_SIZE + ALAC_FRAME_FOOTER_SIZE +
388
                               avctx->frame_size*avctx->channels*avctx->bits_per_coded_sample)>>3;
389

    
390
    s->write_sample_size  = avctx->bits_per_coded_sample + avctx->channels - 1; // FIXME: consider wasted_bytes
391

    
392
    AV_WB32(alac_extradata,    ALAC_EXTRADATA_SIZE);
393
    AV_WB32(alac_extradata+4,  MKBETAG('a','l','a','c'));
394
    AV_WB32(alac_extradata+12, avctx->frame_size);
395
    AV_WB8 (alac_extradata+17, avctx->bits_per_coded_sample);
396
    AV_WB8 (alac_extradata+21, avctx->channels);
397
    AV_WB32(alac_extradata+24, s->max_coded_frame_size);
398
    AV_WB32(alac_extradata+28, avctx->sample_rate*avctx->channels*avctx->bits_per_coded_sample); // average bitrate
399
    AV_WB32(alac_extradata+32, avctx->sample_rate);
400

    
401
    // Set relevant extradata fields
402
    if(s->compression_level > 0) {
403
        AV_WB8(alac_extradata+18, s->rc.history_mult);
404
        AV_WB8(alac_extradata+19, s->rc.initial_history);
405
        AV_WB8(alac_extradata+20, s->rc.k_modifier);
406
    }
407

    
408
    s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
409
    if(avctx->min_prediction_order >= 0) {
410
        if(avctx->min_prediction_order < MIN_LPC_ORDER ||
411
           avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
412
            av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", avctx->min_prediction_order);
413
                return -1;
414
        }
415

    
416
        s->min_prediction_order = avctx->min_prediction_order;
417
    }
418

    
419
    s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
420
    if(avctx->max_prediction_order >= 0) {
421
        if(avctx->max_prediction_order < MIN_LPC_ORDER ||
422
           avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) {
423
            av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", avctx->max_prediction_order);
424
                return -1;
425
        }
426

    
427
        s->max_prediction_order = avctx->max_prediction_order;
428
    }
429

    
430
    if(s->max_prediction_order < s->min_prediction_order) {
431
        av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
432
               s->min_prediction_order, s->max_prediction_order);
433
        return -1;
434
    }
435

    
436
    avctx->extradata = alac_extradata;
437
    avctx->extradata_size = ALAC_EXTRADATA_SIZE;
438

    
439
    avctx->coded_frame = avcodec_alloc_frame();
440
    avctx->coded_frame->key_frame = 1;
441

    
442
    s->avctx = avctx;
443
    dsputil_init(&s->dspctx, avctx);
444

    
445
    return 0;
446
}
447

    
448
static int alac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
449
                             int buf_size, void *data)
450
{
451
    AlacEncodeContext *s = avctx->priv_data;
452
    PutBitContext *pb = &s->pbctx;
453
    int i, out_bytes, verbatim_flag = 0;
454

    
455
    if(avctx->frame_size > DEFAULT_FRAME_SIZE) {
456
        av_log(avctx, AV_LOG_ERROR, "input frame size exceeded\n");
457
        return -1;
458
    }
459

    
460
    if(buf_size < 2*s->max_coded_frame_size) {
461
        av_log(avctx, AV_LOG_ERROR, "buffer size is too small\n");
462
        return -1;
463
    }
464

    
465
verbatim:
466
    init_put_bits(pb, frame, buf_size);
467

    
468
    if((s->compression_level == 0) || verbatim_flag) {
469
        // Verbatim mode
470
        int16_t *samples = data;
471
        write_frame_header(s, 1);
472
        for(i=0; i<avctx->frame_size*avctx->channels; i++) {
473
            put_sbits(pb, 16, *samples++);
474
        }
475
    } else {
476
        init_sample_buffers(s, data);
477
        write_frame_header(s, 0);
478
        write_compressed_frame(s);
479
    }
480

    
481
    put_bits(pb, 3, 7);
482
    flush_put_bits(pb);
483
    out_bytes = put_bits_count(pb) >> 3;
484

    
485
    if(out_bytes > s->max_coded_frame_size) {
486
        /* frame too large. use verbatim mode */
487
        if(verbatim_flag || (s->compression_level == 0)) {
488
            /* still too large. must be an error. */
489
            av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
490
            return -1;
491
        }
492
        verbatim_flag = 1;
493
        goto verbatim;
494
    }
495

    
496
    return out_bytes;
497
}
498

    
499
static av_cold int alac_encode_close(AVCodecContext *avctx)
500
{
501
    av_freep(&avctx->extradata);
502
    avctx->extradata_size = 0;
503
    av_freep(&avctx->coded_frame);
504
    return 0;
505
}
506

    
507
AVCodec alac_encoder = {
508
    "alac",
509
    CODEC_TYPE_AUDIO,
510
    CODEC_ID_ALAC,
511
    sizeof(AlacEncodeContext),
512
    alac_encode_init,
513
    alac_encode_frame,
514
    alac_encode_close,
515
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
516
    .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
517
};