alacenc : perform decorrelation only for stereo samples
[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     if(s->avctx->channels == 2)
334         alac_stereo_decorrelation(s);
335     put_bits(&s->pbctx, 8, s->interlacing_shift);
336     put_bits(&s->pbctx, 8, s->interlacing_leftweight);
337
338     for(i=0;i<s->avctx->channels;i++) {
339
340         calc_predictor_params(s, i);
341
342         put_bits(&s->pbctx, 4, 0);  // prediction type : currently only type 0 has been RE'd
343         put_bits(&s->pbctx, 4, s->lpc[i].lpc_quant);
344
345         put_bits(&s->pbctx, 3, s->rc.rice_modifier);
346         put_bits(&s->pbctx, 5, s->lpc[i].lpc_order);
347         // predictor coeff. table
348         for(j=0;j<s->lpc[i].lpc_order;j++) {
349             put_sbits(&s->pbctx, 16, s->lpc[i].lpc_coeff[j]);
350         }
351     }
352
353     // apply lpc and entropy coding to audio samples
354
355     for(i=0;i<s->avctx->channels;i++) {
356         alac_linear_predictor(s, i);
357         alac_entropy_coder(s);
358     }
359 }
360
361 static av_cold int alac_encode_init(AVCodecContext *avctx)
362 {
363     AlacEncodeContext *s    = avctx->priv_data;
364     uint8_t *alac_extradata = av_mallocz(ALAC_EXTRADATA_SIZE+1);
365
366     avctx->frame_size      = DEFAULT_FRAME_SIZE;
367     avctx->bits_per_sample = DEFAULT_SAMPLE_SIZE;
368
369     if(avctx->sample_fmt != SAMPLE_FMT_S16) {
370         av_log(avctx, AV_LOG_ERROR, "only pcm_s16 input samples are supported\n");
371         return -1;
372     }
373
374     // Set default compression level
375     if(avctx->compression_level == FF_COMPRESSION_DEFAULT)
376         s->compression_level = 1;
377     else
378         s->compression_level = av_clip(avctx->compression_level, 0, 1);
379
380     // Initialize default Rice parameters
381     s->rc.history_mult    = 40;
382     s->rc.initial_history = 10;
383     s->rc.k_modifier      = 14;
384     s->rc.rice_modifier   = 4;
385
386     s->max_coded_frame_size = (ALAC_FRAME_HEADER_SIZE + ALAC_FRAME_FOOTER_SIZE +
387                                avctx->frame_size*avctx->channels*avctx->bits_per_sample)>>3;
388
389     s->write_sample_size  = avctx->bits_per_sample + avctx->channels - 1; // FIXME: consider wasted_bytes
390
391     AV_WB32(alac_extradata,    ALAC_EXTRADATA_SIZE);
392     AV_WB32(alac_extradata+4,  MKBETAG('a','l','a','c'));
393     AV_WB32(alac_extradata+12, avctx->frame_size);
394     AV_WB8 (alac_extradata+17, avctx->bits_per_sample);
395     AV_WB8 (alac_extradata+21, avctx->channels);
396     AV_WB32(alac_extradata+24, s->max_coded_frame_size);
397     AV_WB32(alac_extradata+28, avctx->sample_rate*avctx->channels*avctx->bits_per_sample); // average bitrate
398     AV_WB32(alac_extradata+32, avctx->sample_rate);
399
400     // Set relevant extradata fields
401     if(s->compression_level > 0) {
402         AV_WB8(alac_extradata+18, s->rc.history_mult);
403         AV_WB8(alac_extradata+19, s->rc.initial_history);
404         AV_WB8(alac_extradata+20, s->rc.k_modifier);
405     }
406
407     s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
408     if(avctx->min_prediction_order >= 0) {
409         if(avctx->min_prediction_order < MIN_LPC_ORDER ||
410            avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
411             av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", avctx->min_prediction_order);
412                 return -1;
413         }
414
415         s->min_prediction_order = avctx->min_prediction_order;
416     }
417
418     s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
419     if(avctx->max_prediction_order >= 0) {
420         if(avctx->max_prediction_order < MIN_LPC_ORDER ||
421            avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) {
422             av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", avctx->max_prediction_order);
423                 return -1;
424         }
425
426         s->max_prediction_order = avctx->max_prediction_order;
427     }
428
429     if(s->max_prediction_order < s->min_prediction_order) {
430         av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
431                s->min_prediction_order, s->max_prediction_order);
432         return -1;
433     }
434
435     avctx->extradata = alac_extradata;
436     avctx->extradata_size = ALAC_EXTRADATA_SIZE;
437
438     avctx->coded_frame = avcodec_alloc_frame();
439     avctx->coded_frame->key_frame = 1;
440
441     s->avctx = avctx;
442     dsputil_init(&s->dspctx, avctx);
443
444     return 0;
445 }
446
447 static int alac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
448                              int buf_size, void *data)
449 {
450     AlacEncodeContext *s = avctx->priv_data;
451     PutBitContext *pb = &s->pbctx;
452     int i, out_bytes, verbatim_flag = 0;
453
454     if(avctx->frame_size > DEFAULT_FRAME_SIZE) {
455         av_log(avctx, AV_LOG_ERROR, "input frame size exceeded\n");
456         return -1;
457     }
458
459     if(buf_size < 2*s->max_coded_frame_size) {
460         av_log(avctx, AV_LOG_ERROR, "buffer size is too small\n");
461         return -1;
462     }
463
464 verbatim:
465     init_put_bits(pb, frame, buf_size);
466
467     if((s->compression_level == 0) || verbatim_flag) {
468         // Verbatim mode
469         int16_t *samples = data;
470         write_frame_header(s, 1);
471         for(i=0; i<avctx->frame_size*avctx->channels; i++) {
472             put_sbits(pb, 16, *samples++);
473         }
474     } else {
475         init_sample_buffers(s, data);
476         write_frame_header(s, 0);
477         write_compressed_frame(s);
478     }
479
480     put_bits(pb, 3, 7);
481     flush_put_bits(pb);
482     out_bytes = put_bits_count(pb) >> 3;
483
484     if(out_bytes > s->max_coded_frame_size) {
485         /* frame too large. use verbatim mode */
486         if(verbatim_flag || (s->compression_level == 0)) {
487             /* still too large. must be an error. */
488             av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
489             return -1;
490         }
491         verbatim_flag = 1;
492         goto verbatim;
493     }
494
495     return out_bytes;
496 }
497
498 static av_cold int alac_encode_close(AVCodecContext *avctx)
499 {
500     av_freep(&avctx->extradata);
501     avctx->extradata_size = 0;
502     av_freep(&avctx->coded_frame);
503     return 0;
504 }
505
506 AVCodec alac_encoder = {
507     "alac",
508     CODEC_TYPE_AUDIO,
509     CODEC_ID_ALAC,
510     sizeof(AlacEncodeContext),
511     alac_encode_init,
512     alac_encode_frame,
513     alac_encode_close,
514     .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
515     .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
516 };