Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavcodec / sonic.c
1 /*
2  * Simple free lossless/lossy audio codec
3  * Copyright (c) 2004 Alex Beregszaszi
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 #include "avcodec.h"
22 #include "get_bits.h"
23 #include "golomb.h"
24
25 /**
26  * @file
27  * Simple free lossless/lossy audio codec
28  * Based on Paul Francis Harrison's Bonk (http://www.logarithmic.net/pfh/bonk)
29  * Written and designed by Alex Beregszaszi
30  *
31  * TODO:
32  *  - CABAC put/get_symbol
33  *  - independent quantizer for channels
34  *  - >2 channels support
35  *  - more decorrelation types
36  *  - more tap_quant tests
37  *  - selectable intlist writers/readers (bonk-style, golomb, cabac)
38  */
39
40 #define MAX_CHANNELS 2
41
42 #define MID_SIDE 0
43 #define LEFT_SIDE 1
44 #define RIGHT_SIDE 2
45
46 typedef struct SonicContext {
47     AVFrame frame;
48     int lossless, decorrelation;
49
50     int num_taps, downsampling;
51     double quantization;
52
53     int channels, samplerate, block_align, frame_size;
54
55     int *tap_quant;
56     int *int_samples;
57     int *coded_samples[MAX_CHANNELS];
58
59     // for encoding
60     int *tail;
61     int tail_size;
62     int *window;
63     int window_size;
64
65     // for decoding
66     int *predictor_k;
67     int *predictor_state[MAX_CHANNELS];
68 } SonicContext;
69
70 #define LATTICE_SHIFT   10
71 #define SAMPLE_SHIFT    4
72 #define LATTICE_FACTOR  (1 << LATTICE_SHIFT)
73 #define SAMPLE_FACTOR   (1 << SAMPLE_SHIFT)
74
75 #define BASE_QUANT      0.6
76 #define RATE_VARIATION  3.0
77
78 static inline int divide(int a, int b)
79 {
80     if (a < 0)
81         return -( (-a + b/2)/b );
82     else
83         return (a + b/2)/b;
84 }
85
86 static inline int shift(int a,int b)
87 {
88     return (a+(1<<(b-1))) >> b;
89 }
90
91 static inline int shift_down(int a,int b)
92 {
93     return (a>>b)+((a<0)?1:0);
94 }
95
96 #if 1
97 static inline int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part)
98 {
99     int i;
100
101     for (i = 0; i < entries; i++)
102         set_se_golomb(pb, buf[i]);
103
104     return 1;
105 }
106
107 static inline int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part)
108 {
109     int i;
110
111     for (i = 0; i < entries; i++)
112         buf[i] = get_se_golomb(gb);
113
114     return 1;
115 }
116
117 #else
118
119 #define ADAPT_LEVEL 8
120
121 static int bits_to_store(uint64_t x)
122 {
123     int res = 0;
124
125     while(x)
126     {
127         res++;
128         x >>= 1;
129     }
130     return res;
131 }
132
133 static void write_uint_max(PutBitContext *pb, unsigned int value, unsigned int max)
134 {
135     int i, bits;
136
137     if (!max)
138         return;
139
140     bits = bits_to_store(max);
141
142     for (i = 0; i < bits-1; i++)
143         put_bits(pb, 1, value & (1 << i));
144
145     if ( (value | (1 << (bits-1))) <= max)
146         put_bits(pb, 1, value & (1 << (bits-1)));
147 }
148
149 static unsigned int read_uint_max(GetBitContext *gb, int max)
150 {
151     int i, bits, value = 0;
152
153     if (!max)
154         return 0;
155
156     bits = bits_to_store(max);
157
158     for (i = 0; i < bits-1; i++)
159         if (get_bits1(gb))
160             value += 1 << i;
161
162     if ( (value | (1<<(bits-1))) <= max)
163         if (get_bits1(gb))
164             value += 1 << (bits-1);
165
166     return value;
167 }
168
169 static int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part)
170 {
171     int i, j, x = 0, low_bits = 0, max = 0;
172     int step = 256, pos = 0, dominant = 0, any = 0;
173     int *copy, *bits;
174
175     copy = av_mallocz(4* entries);
176     if (!copy)
177         return -1;
178
179     if (base_2_part)
180     {
181         int energy = 0;
182
183         for (i = 0; i < entries; i++)
184             energy += abs(buf[i]);
185
186         low_bits = bits_to_store(energy / (entries * 2));
187         if (low_bits > 15)
188             low_bits = 15;
189
190         put_bits(pb, 4, low_bits);
191     }
192
193     for (i = 0; i < entries; i++)
194     {
195         put_bits(pb, low_bits, abs(buf[i]));
196         copy[i] = abs(buf[i]) >> low_bits;
197         if (copy[i] > max)
198             max = abs(copy[i]);
199     }
200
201     bits = av_mallocz(4* entries*max);
202     if (!bits)
203     {
204 //        av_free(copy);
205         return -1;
206     }
207
208     for (i = 0; i <= max; i++)
209     {
210         for (j = 0; j < entries; j++)
211             if (copy[j] >= i)
212                 bits[x++] = copy[j] > i;
213     }
214
215     // store bitstream
216     while (pos < x)
217     {
218         int steplet = step >> 8;
219
220         if (pos + steplet > x)
221             steplet = x - pos;
222
223         for (i = 0; i < steplet; i++)
224             if (bits[i+pos] != dominant)
225                 any = 1;
226
227         put_bits(pb, 1, any);
228
229         if (!any)
230         {
231             pos += steplet;
232             step += step / ADAPT_LEVEL;
233         }
234         else
235         {
236             int interloper = 0;
237
238             while (((pos + interloper) < x) && (bits[pos + interloper] == dominant))
239                 interloper++;
240
241             // note change
242             write_uint_max(pb, interloper, (step >> 8) - 1);
243
244             pos += interloper + 1;
245             step -= step / ADAPT_LEVEL;
246         }
247
248         if (step < 256)
249         {
250             step = 65536 / step;
251             dominant = !dominant;
252         }
253     }
254
255     // store signs
256     for (i = 0; i < entries; i++)
257         if (buf[i])
258             put_bits(pb, 1, buf[i] < 0);
259
260 //    av_free(bits);
261 //    av_free(copy);
262
263     return 0;
264 }
265
266 static int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part)
267 {
268     int i, low_bits = 0, x = 0;
269     int n_zeros = 0, step = 256, dominant = 0;
270     int pos = 0, level = 0;
271     int *bits = av_mallocz(4* entries);
272
273     if (!bits)
274         return -1;
275
276     if (base_2_part)
277     {
278         low_bits = get_bits(gb, 4);
279
280         if (low_bits)
281             for (i = 0; i < entries; i++)
282                 buf[i] = get_bits(gb, low_bits);
283     }
284
285 //    av_log(NULL, AV_LOG_INFO, "entries: %d, low bits: %d\n", entries, low_bits);
286
287     while (n_zeros < entries)
288     {
289         int steplet = step >> 8;
290
291         if (!get_bits1(gb))
292         {
293             for (i = 0; i < steplet; i++)
294                 bits[x++] = dominant;
295
296             if (!dominant)
297                 n_zeros += steplet;
298
299             step += step / ADAPT_LEVEL;
300         }
301         else
302         {
303             int actual_run = read_uint_max(gb, steplet-1);
304
305 //            av_log(NULL, AV_LOG_INFO, "actual run: %d\n", actual_run);
306
307             for (i = 0; i < actual_run; i++)
308                 bits[x++] = dominant;
309
310             bits[x++] = !dominant;
311
312             if (!dominant)
313                 n_zeros += actual_run;
314             else
315                 n_zeros++;
316
317             step -= step / ADAPT_LEVEL;
318         }
319
320         if (step < 256)
321         {
322             step = 65536 / step;
323             dominant = !dominant;
324         }
325     }
326
327     // reconstruct unsigned values
328     n_zeros = 0;
329     for (i = 0; n_zeros < entries; i++)
330     {
331         while(1)
332         {
333             if (pos >= entries)
334             {
335                 pos = 0;
336                 level += 1 << low_bits;
337             }
338
339             if (buf[pos] >= level)
340                 break;
341
342             pos++;
343         }
344
345         if (bits[i])
346             buf[pos] += 1 << low_bits;
347         else
348             n_zeros++;
349
350         pos++;
351     }
352 //    av_free(bits);
353
354     // read signs
355     for (i = 0; i < entries; i++)
356         if (buf[i] && get_bits1(gb))
357             buf[i] = -buf[i];
358
359 //    av_log(NULL, AV_LOG_INFO, "zeros: %d pos: %d\n", n_zeros, pos);
360
361     return 0;
362 }
363 #endif
364
365 static void predictor_init_state(int *k, int *state, int order)
366 {
367     int i;
368
369     for (i = order-2; i >= 0; i--)
370     {
371         int j, p, x = state[i];
372
373         for (j = 0, p = i+1; p < order; j++,p++)
374             {
375             int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT);
376             state[p] += shift_down(k[j]*x, LATTICE_SHIFT);
377             x = tmp;
378         }
379     }
380 }
381
382 static int predictor_calc_error(int *k, int *state, int order, int error)
383 {
384     int i, x = error - shift_down(k[order-1] * state[order-1], LATTICE_SHIFT);
385
386 #if 1
387     int *k_ptr = &(k[order-2]),
388         *state_ptr = &(state[order-2]);
389     for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--)
390     {
391         int k_value = *k_ptr, state_value = *state_ptr;
392         x -= shift_down(k_value * state_value, LATTICE_SHIFT);
393         state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT);
394     }
395 #else
396     for (i = order-2; i >= 0; i--)
397     {
398         x -= shift_down(k[i] * state[i], LATTICE_SHIFT);
399         state[i+1] = state[i] + shift_down(k[i] * x, LATTICE_SHIFT);
400     }
401 #endif
402
403     // don't drift too far, to avoid overflows
404     if (x >  (SAMPLE_FACTOR<<16)) x =  (SAMPLE_FACTOR<<16);
405     if (x < -(SAMPLE_FACTOR<<16)) x = -(SAMPLE_FACTOR<<16);
406
407     state[0] = x;
408
409     return x;
410 }
411
412 #if CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER
413 // Heavily modified Levinson-Durbin algorithm which
414 // copes better with quantization, and calculates the
415 // actual whitened result as it goes.
416
417 static void modified_levinson_durbin(int *window, int window_entries,
418         int *out, int out_entries, int channels, int *tap_quant)
419 {
420     int i;
421     int *state = av_mallocz(4* window_entries);
422
423     memcpy(state, window, 4* window_entries);
424
425     for (i = 0; i < out_entries; i++)
426     {
427         int step = (i+1)*channels, k, j;
428         double xx = 0.0, xy = 0.0;
429 #if 1
430         int *x_ptr = &(window[step]), *state_ptr = &(state[0]);
431         j = window_entries - step;
432         for (;j>=0;j--,x_ptr++,state_ptr++)
433         {
434             double x_value = *x_ptr, state_value = *state_ptr;
435             xx += state_value*state_value;
436             xy += x_value*state_value;
437         }
438 #else
439         for (j = 0; j <= (window_entries - step); j++);
440         {
441             double stepval = window[step+j], stateval = window[j];
442 //            xx += (double)window[j]*(double)window[j];
443 //            xy += (double)window[step+j]*(double)window[j];
444             xx += stateval*stateval;
445             xy += stepval*stateval;
446         }
447 #endif
448         if (xx == 0.0)
449             k = 0;
450         else
451             k = (int)(floor(-xy/xx * (double)LATTICE_FACTOR / (double)(tap_quant[i]) + 0.5));
452
453         if (k > (LATTICE_FACTOR/tap_quant[i]))
454             k = LATTICE_FACTOR/tap_quant[i];
455         if (-k > (LATTICE_FACTOR/tap_quant[i]))
456             k = -(LATTICE_FACTOR/tap_quant[i]);
457
458         out[i] = k;
459         k *= tap_quant[i];
460
461 #if 1
462         x_ptr = &(window[step]);
463         state_ptr = &(state[0]);
464         j = window_entries - step;
465         for (;j>=0;j--,x_ptr++,state_ptr++)
466         {
467             int x_value = *x_ptr, state_value = *state_ptr;
468             *x_ptr = x_value + shift_down(k*state_value,LATTICE_SHIFT);
469             *state_ptr = state_value + shift_down(k*x_value, LATTICE_SHIFT);
470         }
471 #else
472         for (j=0; j <= (window_entries - step); j++)
473         {
474             int stepval = window[step+j], stateval=state[j];
475             window[step+j] += shift_down(k * stateval, LATTICE_SHIFT);
476             state[j] += shift_down(k * stepval, LATTICE_SHIFT);
477         }
478 #endif
479     }
480
481     av_free(state);
482 }
483
484 static inline int code_samplerate(int samplerate)
485 {
486     switch (samplerate)
487     {
488         case 44100: return 0;
489         case 22050: return 1;
490         case 11025: return 2;
491         case 96000: return 3;
492         case 48000: return 4;
493         case 32000: return 5;
494         case 24000: return 6;
495         case 16000: return 7;
496         case 8000: return 8;
497     }
498     return -1;
499 }
500
501 static av_cold int sonic_encode_init(AVCodecContext *avctx)
502 {
503     SonicContext *s = avctx->priv_data;
504     PutBitContext pb;
505     int i, version = 0;
506
507     if (avctx->channels > MAX_CHANNELS)
508     {
509         av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
510         return -1; /* only stereo or mono for now */
511     }
512
513     if (avctx->channels == 2)
514         s->decorrelation = MID_SIDE;
515
516     if (avctx->codec->id == CODEC_ID_SONIC_LS)
517     {
518         s->lossless = 1;
519         s->num_taps = 32;
520         s->downsampling = 1;
521         s->quantization = 0.0;
522     }
523     else
524     {
525         s->num_taps = 128;
526         s->downsampling = 2;
527         s->quantization = 1.0;
528     }
529
530     // max tap 2048
531     if ((s->num_taps < 32) || (s->num_taps > 1024) ||
532         ((s->num_taps>>5)<<5 != s->num_taps))
533     {
534         av_log(avctx, AV_LOG_ERROR, "Invalid number of taps\n");
535         return -1;
536     }
537
538     // generate taps
539     s->tap_quant = av_mallocz(4* s->num_taps);
540     for (i = 0; i < s->num_taps; i++)
541         s->tap_quant[i] = (int)(sqrt(i+1));
542
543     s->channels = avctx->channels;
544     s->samplerate = avctx->sample_rate;
545
546     s->block_align = (int)(2048.0*s->samplerate/44100)/s->downsampling;
547     s->frame_size = s->channels*s->block_align*s->downsampling;
548
549     s->tail = av_mallocz(4* s->num_taps*s->channels);
550     if (!s->tail)
551         return -1;
552     s->tail_size = s->num_taps*s->channels;
553
554     s->predictor_k = av_mallocz(4 * s->num_taps);
555     if (!s->predictor_k)
556         return -1;
557
558     for (i = 0; i < s->channels; i++)
559     {
560         s->coded_samples[i] = av_mallocz(4* s->block_align);
561         if (!s->coded_samples[i])
562             return -1;
563     }
564
565     s->int_samples = av_mallocz(4* s->frame_size);
566
567     s->window_size = ((2*s->tail_size)+s->frame_size);
568     s->window = av_mallocz(4* s->window_size);
569     if (!s->window)
570         return -1;
571
572     avctx->extradata = av_mallocz(16);
573     if (!avctx->extradata)
574         return -1;
575     init_put_bits(&pb, avctx->extradata, 16*8);
576
577     put_bits(&pb, 2, version); // version
578     if (version == 1)
579     {
580         put_bits(&pb, 2, s->channels);
581         put_bits(&pb, 4, code_samplerate(s->samplerate));
582     }
583     put_bits(&pb, 1, s->lossless);
584     if (!s->lossless)
585         put_bits(&pb, 3, SAMPLE_SHIFT); // XXX FIXME: sample precision
586     put_bits(&pb, 2, s->decorrelation);
587     put_bits(&pb, 2, s->downsampling);
588     put_bits(&pb, 5, (s->num_taps >> 5)-1); // 32..1024
589     put_bits(&pb, 1, 0); // XXX FIXME: no custom tap quant table
590
591     flush_put_bits(&pb);
592     avctx->extradata_size = put_bits_count(&pb)/8;
593
594     av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
595         version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
596
597     avctx->coded_frame = avcodec_alloc_frame();
598     if (!avctx->coded_frame)
599         return AVERROR(ENOMEM);
600     avctx->coded_frame->key_frame = 1;
601     avctx->frame_size = s->block_align*s->downsampling;
602
603     return 0;
604 }
605
606 static av_cold int sonic_encode_close(AVCodecContext *avctx)
607 {
608     SonicContext *s = avctx->priv_data;
609     int i;
610
611     av_freep(&avctx->coded_frame);
612
613     for (i = 0; i < s->channels; i++)
614         av_free(s->coded_samples[i]);
615
616     av_free(s->predictor_k);
617     av_free(s->tail);
618     av_free(s->tap_quant);
619     av_free(s->window);
620     av_free(s->int_samples);
621
622     return 0;
623 }
624
625 static int sonic_encode_frame(AVCodecContext *avctx,
626                             uint8_t *buf, int buf_size, void *data)
627 {
628     SonicContext *s = avctx->priv_data;
629     PutBitContext pb;
630     int i, j, ch, quant = 0, x = 0;
631     short *samples = data;
632
633     init_put_bits(&pb, buf, buf_size*8);
634
635     // short -> internal
636     for (i = 0; i < s->frame_size; i++)
637         s->int_samples[i] = samples[i];
638
639     if (!s->lossless)
640         for (i = 0; i < s->frame_size; i++)
641             s->int_samples[i] = s->int_samples[i] << SAMPLE_SHIFT;
642
643     switch(s->decorrelation)
644     {
645         case MID_SIDE:
646             for (i = 0; i < s->frame_size; i += s->channels)
647             {
648                 s->int_samples[i] += s->int_samples[i+1];
649                 s->int_samples[i+1] -= shift(s->int_samples[i], 1);
650             }
651             break;
652         case LEFT_SIDE:
653             for (i = 0; i < s->frame_size; i += s->channels)
654                 s->int_samples[i+1] -= s->int_samples[i];
655             break;
656         case RIGHT_SIDE:
657             for (i = 0; i < s->frame_size; i += s->channels)
658                 s->int_samples[i] -= s->int_samples[i+1];
659             break;
660     }
661
662     memset(s->window, 0, 4* s->window_size);
663
664     for (i = 0; i < s->tail_size; i++)
665         s->window[x++] = s->tail[i];
666
667     for (i = 0; i < s->frame_size; i++)
668         s->window[x++] = s->int_samples[i];
669
670     for (i = 0; i < s->tail_size; i++)
671         s->window[x++] = 0;
672
673     for (i = 0; i < s->tail_size; i++)
674         s->tail[i] = s->int_samples[s->frame_size - s->tail_size + i];
675
676     // generate taps
677     modified_levinson_durbin(s->window, s->window_size,
678                 s->predictor_k, s->num_taps, s->channels, s->tap_quant);
679     if (intlist_write(&pb, s->predictor_k, s->num_taps, 0) < 0)
680         return -1;
681
682     for (ch = 0; ch < s->channels; ch++)
683     {
684         x = s->tail_size+ch;
685         for (i = 0; i < s->block_align; i++)
686         {
687             int sum = 0;
688             for (j = 0; j < s->downsampling; j++, x += s->channels)
689                 sum += s->window[x];
690             s->coded_samples[ch][i] = sum;
691         }
692     }
693
694     // simple rate control code
695     if (!s->lossless)
696     {
697         double energy1 = 0.0, energy2 = 0.0;
698         for (ch = 0; ch < s->channels; ch++)
699         {
700             for (i = 0; i < s->block_align; i++)
701             {
702                 double sample = s->coded_samples[ch][i];
703                 energy2 += sample*sample;
704                 energy1 += fabs(sample);
705             }
706         }
707
708         energy2 = sqrt(energy2/(s->channels*s->block_align));
709         energy1 = sqrt(2.0)*energy1/(s->channels*s->block_align);
710
711         // increase bitrate when samples are like a gaussian distribution
712         // reduce bitrate when samples are like a two-tailed exponential distribution
713
714         if (energy2 > energy1)
715             energy2 += (energy2-energy1)*RATE_VARIATION;
716
717         quant = (int)(BASE_QUANT*s->quantization*energy2/SAMPLE_FACTOR);
718 //        av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2);
719
720         if (quant < 1)
721             quant = 1;
722         if (quant > 65535)
723             quant = 65535;
724
725         set_ue_golomb(&pb, quant);
726
727         quant *= SAMPLE_FACTOR;
728     }
729
730     // write out coded samples
731     for (ch = 0; ch < s->channels; ch++)
732     {
733         if (!s->lossless)
734             for (i = 0; i < s->block_align; i++)
735                 s->coded_samples[ch][i] = divide(s->coded_samples[ch][i], quant);
736
737         if (intlist_write(&pb, s->coded_samples[ch], s->block_align, 1) < 0)
738             return -1;
739     }
740
741 //    av_log(avctx, AV_LOG_DEBUG, "used bytes: %d\n", (put_bits_count(&pb)+7)/8);
742
743     flush_put_bits(&pb);
744     return (put_bits_count(&pb)+7)/8;
745 }
746 #endif /* CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER */
747
748 #if CONFIG_SONIC_DECODER
749 static const int samplerate_table[] =
750     { 44100, 22050, 11025, 96000, 48000, 32000, 24000, 16000, 8000 };
751
752 static av_cold int sonic_decode_init(AVCodecContext *avctx)
753 {
754     SonicContext *s = avctx->priv_data;
755     GetBitContext gb;
756     int i, version;
757
758     s->channels = avctx->channels;
759     s->samplerate = avctx->sample_rate;
760
761     avcodec_get_frame_defaults(&s->frame);
762     avctx->coded_frame = &s->frame;
763
764     if (!avctx->extradata)
765     {
766         av_log(avctx, AV_LOG_ERROR, "No mandatory headers present\n");
767         return -1;
768     }
769
770     init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
771
772     version = get_bits(&gb, 2);
773     if (version > 1)
774     {
775         av_log(avctx, AV_LOG_ERROR, "Unsupported Sonic version, please report\n");
776         return -1;
777     }
778
779     if (version == 1)
780     {
781         s->channels = get_bits(&gb, 2);
782         s->samplerate = samplerate_table[get_bits(&gb, 4)];
783         av_log(avctx, AV_LOG_INFO, "Sonicv2 chans: %d samprate: %d\n",
784             s->channels, s->samplerate);
785     }
786
787     if (s->channels > MAX_CHANNELS)
788     {
789         av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
790         return -1;
791     }
792
793     s->lossless = get_bits1(&gb);
794     if (!s->lossless)
795         skip_bits(&gb, 3); // XXX FIXME
796     s->decorrelation = get_bits(&gb, 2);
797
798     s->downsampling = get_bits(&gb, 2);
799     s->num_taps = (get_bits(&gb, 5)+1)<<5;
800     if (get_bits1(&gb)) // XXX FIXME
801         av_log(avctx, AV_LOG_INFO, "Custom quant table\n");
802
803     s->block_align = (int)(2048.0*s->samplerate/44100)/s->downsampling;
804     s->frame_size = s->channels*s->block_align*s->downsampling;
805 //    avctx->frame_size = s->block_align;
806
807     av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
808         version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
809
810     // generate taps
811     s->tap_quant = av_mallocz(4* s->num_taps);
812     for (i = 0; i < s->num_taps; i++)
813         s->tap_quant[i] = (int)(sqrt(i+1));
814
815     s->predictor_k = av_mallocz(4* s->num_taps);
816
817     for (i = 0; i < s->channels; i++)
818     {
819         s->predictor_state[i] = av_mallocz(4* s->num_taps);
820         if (!s->predictor_state[i])
821             return -1;
822     }
823
824     for (i = 0; i < s->channels; i++)
825     {
826         s->coded_samples[i] = av_mallocz(4* s->block_align);
827         if (!s->coded_samples[i])
828             return -1;
829     }
830     s->int_samples = av_mallocz(4* s->frame_size);
831
832     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
833     return 0;
834 }
835
836 static av_cold int sonic_decode_close(AVCodecContext *avctx)
837 {
838     SonicContext *s = avctx->priv_data;
839     int i;
840
841     av_free(s->int_samples);
842     av_free(s->tap_quant);
843     av_free(s->predictor_k);
844
845     for (i = 0; i < s->channels; i++)
846     {
847         av_free(s->predictor_state[i]);
848         av_free(s->coded_samples[i]);
849     }
850
851     return 0;
852 }
853
854 static int sonic_decode_frame(AVCodecContext *avctx,
855                             void *data, int *got_frame_ptr,
856                             AVPacket *avpkt)
857 {
858     const uint8_t *buf = avpkt->data;
859     int buf_size = avpkt->size;
860     SonicContext *s = avctx->priv_data;
861     GetBitContext gb;
862     int i, quant, ch, j, ret;
863     int16_t *samples;
864
865     if (buf_size == 0) return 0;
866
867     s->frame.nb_samples = s->frame_size;
868     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
869         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
870         return ret;
871     }
872     samples = (int16_t *)s->frame.data[0];
873
874 //    av_log(NULL, AV_LOG_INFO, "buf_size: %d\n", buf_size);
875
876     init_get_bits(&gb, buf, buf_size*8);
877
878     intlist_read(&gb, s->predictor_k, s->num_taps, 0);
879
880     // dequantize
881     for (i = 0; i < s->num_taps; i++)
882         s->predictor_k[i] *= s->tap_quant[i];
883
884     if (s->lossless)
885         quant = 1;
886     else
887         quant = get_ue_golomb(&gb) * SAMPLE_FACTOR;
888
889 //    av_log(NULL, AV_LOG_INFO, "quant: %d\n", quant);
890
891     for (ch = 0; ch < s->channels; ch++)
892     {
893         int x = ch;
894
895         predictor_init_state(s->predictor_k, s->predictor_state[ch], s->num_taps);
896
897         intlist_read(&gb, s->coded_samples[ch], s->block_align, 1);
898
899         for (i = 0; i < s->block_align; i++)
900         {
901             for (j = 0; j < s->downsampling - 1; j++)
902             {
903                 s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, 0);
904                 x += s->channels;
905             }
906
907             s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, s->coded_samples[ch][i] * quant);
908             x += s->channels;
909         }
910
911         for (i = 0; i < s->num_taps; i++)
912             s->predictor_state[ch][i] = s->int_samples[s->frame_size - s->channels + ch - i*s->channels];
913     }
914
915     switch(s->decorrelation)
916     {
917         case MID_SIDE:
918             for (i = 0; i < s->frame_size; i += s->channels)
919             {
920                 s->int_samples[i+1] += shift(s->int_samples[i], 1);
921                 s->int_samples[i] -= s->int_samples[i+1];
922             }
923             break;
924         case LEFT_SIDE:
925             for (i = 0; i < s->frame_size; i += s->channels)
926                 s->int_samples[i+1] += s->int_samples[i];
927             break;
928         case RIGHT_SIDE:
929             for (i = 0; i < s->frame_size; i += s->channels)
930                 s->int_samples[i] += s->int_samples[i+1];
931             break;
932     }
933
934     if (!s->lossless)
935         for (i = 0; i < s->frame_size; i++)
936             s->int_samples[i] = shift(s->int_samples[i], SAMPLE_SHIFT);
937
938     // internal -> short
939     for (i = 0; i < s->frame_size; i++)
940         samples[i] = av_clip_int16(s->int_samples[i]);
941
942     align_get_bits(&gb);
943
944     *got_frame_ptr = 1;
945     *(AVFrame*)data = s->frame;
946
947     return (get_bits_count(&gb)+7)/8;
948 }
949
950 AVCodec ff_sonic_decoder = {
951     .name           = "sonic",
952     .type           = AVMEDIA_TYPE_AUDIO,
953     .id             = CODEC_ID_SONIC,
954     .priv_data_size = sizeof(SonicContext),
955     .init           = sonic_decode_init,
956     .close          = sonic_decode_close,
957     .decode         = sonic_decode_frame,
958     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,
959     .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
960 };
961 #endif /* CONFIG_SONIC_DECODER */
962
963 #if CONFIG_SONIC_ENCODER
964 AVCodec ff_sonic_encoder = {
965     .name           = "sonic",
966     .type           = AVMEDIA_TYPE_AUDIO,
967     .id             = CODEC_ID_SONIC,
968     .priv_data_size = sizeof(SonicContext),
969     .init           = sonic_encode_init,
970     .encode         = sonic_encode_frame,
971     .capabilities   = CODEC_CAP_EXPERIMENTAL,
972     .close          = sonic_encode_close,
973     .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
974 };
975 #endif
976
977 #if CONFIG_SONIC_LS_ENCODER
978 AVCodec ff_sonic_ls_encoder = {
979     .name           = "sonicls",
980     .type           = AVMEDIA_TYPE_AUDIO,
981     .id             = CODEC_ID_SONIC_LS,
982     .priv_data_size = sizeof(SonicContext),
983     .init           = sonic_encode_init,
984     .encode         = sonic_encode_frame,
985     .capabilities   = CODEC_CAP_EXPERIMENTAL,
986     .close          = sonic_encode_close,
987     .long_name = NULL_IF_CONFIG_SMALL("Sonic lossless"),
988 };
989 #endif