alacenc: last few hunks approved by michael
[ffmpeg.git] / libavcodec / alacenc.c
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;
257             res_val = residual[i];
258
259             if(res_val) {
260                 int index = lpc.lpc_order - 1;
261                 int neg = (res_val < 0);
262
263                 while(index >= 0 && (neg ? (res_val < 0):(res_val > 0))) {
264                     int val = samples[0] - samples[lpc.lpc_order - index];
265                     int sign = (val ? FFSIGN(val) : 0);
266
267                     if(neg)
268                         sign*=-1;
269
270                     lpc.lpc_coeff[index] -= sign;
271                     val *= sign;
272                     res_val -= ((val >> lpc.lpc_quant) *
273                             (lpc.lpc_order - index));
274                     index--;
275                 }
276             }
277             samples++;
278         }
279     }
280 }
281
282 static void alac_entropy_coder(AlacEncodeContext *s)
283 {
284     unsigned int history = s->rc.initial_history;
285     int sign_modifier = 0, i, k;
286     int32_t *samples = s->predictor_buf;
287
288     for(i=0;i < s->avctx->frame_size;) {
289         int x;
290
291         k = av_log2((history >> 9) + 3);
292
293         x = -2*(*samples)-1;
294         x ^= (x>>31);
295
296         samples++;
297         i++;
298
299         encode_scalar(s, x - sign_modifier, k, s->write_sample_size);
300
301         history += x * s->rc.history_mult
302                    - ((history * s->rc.history_mult) >> 9);
303
304         sign_modifier = 0;
305         if(x > 0xFFFF)
306             history = 0xFFFF;
307
308         if((history < 128) && (i < s->avctx->frame_size)) {
309             unsigned int block_size = 0;
310
311             k = 7 - av_log2(history) + ((history + 16) >> 6);
312
313             while((*samples == 0) && (i < s->avctx->frame_size)) {
314                 samples++;
315                 i++;
316                 block_size++;
317             }
318             encode_scalar(s, block_size, k, 16);
319
320             sign_modifier = (block_size <= 0xFFFF);
321
322             history = 0;
323         }
324
325     }
326 }
327
328 static void write_compressed_frame(AlacEncodeContext *s)
329 {
330     int i, j;
331
332     /* only simple mid/side decorrelation supported as of now */
333     alac_stereo_decorrelation(s);
334     put_bits(&s->pbctx, 8, s->interlacing_shift);
335     put_bits(&s->pbctx, 8, s->interlacing_leftweight);
336
337     for(i=0;i<s->avctx->channels;i++) {
338
339         calc_predictor_params(s, i);
340
341         put_bits(&s->pbctx, 4, 0);  // prediction type : currently only type 0 has been RE'd
342         put_bits(&s->pbctx, 4, s->lpc[i].lpc_quant);
343
344         put_bits(&s->pbctx, 3, s->rc.rice_modifier);
345         put_bits(&s->pbctx, 5, s->lpc[i].lpc_order);
346         // predictor coeff. table
347         for(j=0;j<s->lpc[i].lpc_order;j++) {
348             put_sbits(&s->pbctx, 16, s->lpc[i].lpc_coeff[j]);
349         }
350     }
351
352     // apply lpc and entropy coding to audio samples
353
354     for(i=0;i<s->avctx->channels;i++) {
355         alac_linear_predictor(s, i);
356         alac_entropy_coder(s);
357     }
358 }
359
360 static av_cold int alac_encode_init(AVCodecContext *avctx)
361 {
362     AlacEncodeContext *s    = avctx->priv_data;
363     uint8_t *alac_extradata = av_mallocz(ALAC_EXTRADATA_SIZE+1);
364
365     avctx->frame_size      = DEFAULT_FRAME_SIZE;
366     avctx->bits_per_sample = DEFAULT_SAMPLE_SIZE;
367
368     if(avctx->sample_fmt != SAMPLE_FMT_S16) {
369         av_log(avctx, AV_LOG_ERROR, "only pcm_s16 input samples are supported\n");
370         return -1;
371     }
372
373     // Set default compression level
374     if(avctx->compression_level == FF_COMPRESSION_DEFAULT)
375         s->compression_level = 1;
376     else
377         s->compression_level = av_clip(avctx->compression_level, 0, 1);
378
379     // Initialize default Rice parameters
380     s->rc.history_mult    = 40;
381     s->rc.initial_history = 10;
382     s->rc.k_modifier      = 14;
383     s->rc.rice_modifier   = 4;
384
385     s->max_coded_frame_size = (ALAC_FRAME_HEADER_SIZE + ALAC_FRAME_FOOTER_SIZE +
386                                avctx->frame_size*avctx->channels*avctx->bits_per_sample)>>3;
387
388     s->write_sample_size  = avctx->bits_per_sample + avctx->channels - 1; // FIXME: consider wasted_bytes
389
390     AV_WB32(alac_extradata,    ALAC_EXTRADATA_SIZE);
391     AV_WB32(alac_extradata+4,  MKBETAG('a','l','a','c'));
392     AV_WB32(alac_extradata+12, avctx->frame_size);
393     AV_WB8 (alac_extradata+17, avctx->bits_per_sample);
394     AV_WB8 (alac_extradata+21, avctx->channels);
395     AV_WB32(alac_extradata+24, s->max_coded_frame_size);
396     AV_WB32(alac_extradata+28, avctx->sample_rate*avctx->channels*avctx->bits_per_sample); // average bitrate
397     AV_WB32(alac_extradata+32, avctx->sample_rate);
398
399     // Set relevant extradata fields
400     if(s->compression_level > 0) {
401         AV_WB8(alac_extradata+18, s->rc.history_mult);
402         AV_WB8(alac_extradata+19, s->rc.initial_history);
403         AV_WB8(alac_extradata+20, s->rc.k_modifier);
404     }
405
406     s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
407     if(avctx->min_prediction_order >= 0) {
408         if(avctx->min_prediction_order < MIN_LPC_ORDER ||
409             avctx->min_prediction_order > MAX_LPC_ORDER) {
410             av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", avctx->min_prediction_order);
411                 return -1;
412         }
413
414         s->min_prediction_order = avctx->min_prediction_order;
415     }
416
417     s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
418     if(avctx->max_prediction_order >= 0) {
419         if(avctx->max_prediction_order < MIN_LPC_ORDER ||
420            avctx->max_prediction_order > MAX_LPC_ORDER) {
421             av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", avctx->max_prediction_order);
422                 return -1;
423         }
424
425         s->max_prediction_order = avctx->max_prediction_order;
426     }
427
428     if(s->max_prediction_order < s->min_prediction_order) {
429         av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
430                s->min_prediction_order, s->max_prediction_order);
431         return -1;
432     }
433
434     avctx->extradata = alac_extradata;
435     avctx->extradata_size = ALAC_EXTRADATA_SIZE;
436
437     avctx->coded_frame = avcodec_alloc_frame();
438     avctx->coded_frame->key_frame = 1;
439
440     s->avctx = avctx;
441     dsputil_init(&s->dspctx, avctx);
442
443     return 0;
444 }
445
446 static int alac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
447                              int buf_size, void *data)
448 {
449     AlacEncodeContext *s = avctx->priv_data;
450     PutBitContext *pb = &s->pbctx;
451     int i, out_bytes, verbatim_flag = 0;
452
453     if(avctx->frame_size > DEFAULT_FRAME_SIZE) {
454         av_log(avctx, AV_LOG_ERROR, "input frame size exceeded\n");
455         return -1;
456     }
457
458     if(buf_size < 2*s->max_coded_frame_size) {
459         av_log(avctx, AV_LOG_ERROR, "buffer size is too small\n");
460         return -1;
461     }
462
463 verbatim:
464     init_put_bits(pb, frame, buf_size);
465
466     if((s->compression_level == 0) || verbatim_flag) {
467         // Verbatim mode
468         int16_t *samples = data;
469         write_frame_header(s, 1);
470         for(i=0; i<avctx->frame_size*avctx->channels; i++) {
471             put_sbits(pb, 16, *samples++);
472         }
473     } else {
474         init_sample_buffers(s, data);
475         write_frame_header(s, 0);
476         write_compressed_frame(s);
477     }
478
479     put_bits(pb, 3, 7);
480     flush_put_bits(pb);
481     out_bytes = put_bits_count(pb) >> 3;
482
483     if(out_bytes > s->max_coded_frame_size) {
484         /* frame too large. use verbatim mode */
485         if(verbatim_flag || (s->compression_level == 0)) {
486             /* still too large. must be an error. */
487             av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
488             return -1;
489         }
490         verbatim_flag = 1;
491         goto verbatim;
492     }
493
494     return out_bytes;
495 }
496
497 static av_cold int alac_encode_close(AVCodecContext *avctx)
498 {
499     av_freep(&avctx->extradata);
500     avctx->extradata_size = 0;
501     av_freep(&avctx->coded_frame);
502     return 0;
503 }
504
505 AVCodec alac_encoder = {
506     "alac",
507     CODEC_TYPE_AUDIO,
508     CODEC_ID_ALAC,
509     sizeof(AlacEncodeContext),
510     alac_encode_init,
511     alac_encode_frame,
512     alac_encode_close,
513     .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
514     .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
515 };