sonic: Improve error codes
[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 #include "internal.h"
25
26 /**
27  * @file
28  * Simple free lossless/lossy audio codec
29  * Based on Paul Francis Harrison's Bonk (http://www.logarithmic.net/pfh/bonk)
30  * Written and designed by Alex Beregszaszi
31  *
32  * TODO:
33  *  - CABAC put/get_symbol
34  *  - independent quantizer for channels
35  *  - >2 channels support
36  *  - more decorrelation types
37  *  - more tap_quant tests
38  *  - selectable intlist writers/readers (bonk-style, golomb, cabac)
39  */
40
41 #define MAX_CHANNELS 2
42
43 #define MID_SIDE 0
44 #define LEFT_SIDE 1
45 #define RIGHT_SIDE 2
46
47 typedef struct SonicContext {
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);
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 AVERROR(ENOMEM);
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 AVERROR(ENOMEM);
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 AVERROR(ENOMEM);
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]);
431         int *state_ptr = &(state[0]);
432         j = window_entries - step;
433         for (;j>0;j--,x_ptr++,state_ptr++)
434         {
435             double x_value = *x_ptr;
436             double state_value = *state_ptr;
437             xx += state_value*state_value;
438             xy += x_value*state_value;
439         }
440 #else
441         for (j = 0; j <= (window_entries - step); j++);
442         {
443             double stepval = window[step+j];
444             double stateval = window[j];
445 //            xx += (double)window[j]*(double)window[j];
446 //            xy += (double)window[step+j]*(double)window[j];
447             xx += stateval*stateval;
448             xy += stepval*stateval;
449         }
450 #endif
451         if (xx == 0.0)
452             k = 0;
453         else
454             k = (int)(floor(-xy/xx * (double)LATTICE_FACTOR / (double)(tap_quant[i]) + 0.5));
455
456         if (k > (LATTICE_FACTOR/tap_quant[i]))
457             k = LATTICE_FACTOR/tap_quant[i];
458         if (-k > (LATTICE_FACTOR/tap_quant[i]))
459             k = -(LATTICE_FACTOR/tap_quant[i]);
460
461         out[i] = k;
462         k *= tap_quant[i];
463
464 #if 1
465         x_ptr = &(window[step]);
466         state_ptr = &(state[0]);
467         j = window_entries - step;
468         for (;j>0;j--,x_ptr++,state_ptr++)
469         {
470             int x_value = *x_ptr;
471             int state_value = *state_ptr;
472             *x_ptr = x_value + shift_down(k*state_value,LATTICE_SHIFT);
473             *state_ptr = state_value + shift_down(k*x_value, LATTICE_SHIFT);
474         }
475 #else
476         for (j=0; j <= (window_entries - step); j++)
477         {
478             int stepval = window[step+j];
479             int stateval=state[j];
480             window[step+j] += shift_down(k * stateval, LATTICE_SHIFT);
481             state[j] += shift_down(k * stepval, LATTICE_SHIFT);
482         }
483 #endif
484     }
485
486     av_free(state);
487 }
488
489 static inline int code_samplerate(int samplerate)
490 {
491     switch (samplerate)
492     {
493         case 44100: return 0;
494         case 22050: return 1;
495         case 11025: return 2;
496         case 96000: return 3;
497         case 48000: return 4;
498         case 32000: return 5;
499         case 24000: return 6;
500         case 16000: return 7;
501         case 8000: return 8;
502     }
503     return AVERROR(EINVAL);
504 }
505
506 static av_cold int sonic_encode_init(AVCodecContext *avctx)
507 {
508     SonicContext *s = avctx->priv_data;
509     PutBitContext pb;
510     int i, version = 0;
511
512     if (avctx->channels > MAX_CHANNELS)
513     {
514         av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
515         return AVERROR(EINVAL); /* only stereo or mono for now */
516     }
517
518     if (avctx->channels == 2)
519         s->decorrelation = MID_SIDE;
520     else
521         s->decorrelation = 3;
522
523     if (avctx->codec->id == AV_CODEC_ID_SONIC_LS)
524     {
525         s->lossless = 1;
526         s->num_taps = 32;
527         s->downsampling = 1;
528         s->quantization = 0.0;
529     }
530     else
531     {
532         s->num_taps = 128;
533         s->downsampling = 2;
534         s->quantization = 1.0;
535     }
536
537     // max tap 2048
538     if ((s->num_taps < 32) || (s->num_taps > 1024) ||
539         ((s->num_taps>>5)<<5 != s->num_taps))
540     {
541         av_log(avctx, AV_LOG_ERROR, "Invalid number of taps\n");
542         return AVERROR_INVALIDDATA;
543     }
544
545     // generate taps
546     s->tap_quant = av_mallocz(4* s->num_taps);
547     for (i = 0; i < s->num_taps; i++)
548         s->tap_quant[i] = (int)(sqrt(i+1));
549
550     s->channels = avctx->channels;
551     s->samplerate = avctx->sample_rate;
552
553     s->block_align = (int)(2048.0*s->samplerate/44100)/s->downsampling;
554     s->frame_size = s->channels*s->block_align*s->downsampling;
555
556     s->tail_size = s->num_taps*s->channels;
557     s->tail = av_mallocz(4 * s->tail_size);
558     if (!s->tail)
559         return AVERROR(ENOMEM);
560
561     s->predictor_k = av_mallocz(4 * s->num_taps);
562     if (!s->predictor_k)
563         return AVERROR(ENOMEM);
564
565     for (i = 0; i < s->channels; i++)
566     {
567         s->coded_samples[i] = av_mallocz(4* s->block_align);
568         if (!s->coded_samples[i])
569             return AVERROR(ENOMEM);
570     }
571
572     s->int_samples = av_mallocz(4* s->frame_size);
573
574     s->window_size = ((2*s->tail_size)+s->frame_size);
575     s->window = av_mallocz(4* s->window_size);
576     if (!s->window)
577         return AVERROR(ENOMEM);
578
579     avctx->extradata = av_mallocz(16);
580     if (!avctx->extradata)
581         return AVERROR(ENOMEM);
582     init_put_bits(&pb, avctx->extradata, 16*8);
583
584     put_bits(&pb, 2, version); // version
585     if (version == 1)
586     {
587         put_bits(&pb, 2, s->channels);
588         put_bits(&pb, 4, code_samplerate(s->samplerate));
589     }
590     put_bits(&pb, 1, s->lossless);
591     if (!s->lossless)
592         put_bits(&pb, 3, SAMPLE_SHIFT); // XXX FIXME: sample precision
593     put_bits(&pb, 2, s->decorrelation);
594     put_bits(&pb, 2, s->downsampling);
595     put_bits(&pb, 5, (s->num_taps >> 5)-1); // 32..1024
596     put_bits(&pb, 1, 0); // XXX FIXME: no custom tap quant table
597
598     flush_put_bits(&pb);
599     avctx->extradata_size = put_bits_count(&pb)/8;
600
601     av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
602         version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
603
604     avctx->frame_size = s->block_align*s->downsampling;
605
606     return 0;
607 }
608
609 static av_cold int sonic_encode_close(AVCodecContext *avctx)
610 {
611     SonicContext *s = avctx->priv_data;
612     int i;
613
614     for (i = 0; i < s->channels; i++)
615         av_free(s->coded_samples[i]);
616
617     av_free(s->predictor_k);
618     av_free(s->tail);
619     av_free(s->tap_quant);
620     av_free(s->window);
621     av_free(s->int_samples);
622
623     return 0;
624 }
625
626 static int sonic_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
627                               const AVFrame *frame, int *got_packet_ptr)
628 {
629     SonicContext *s = avctx->priv_data;
630     PutBitContext pb;
631     int i, j, ch, quant = 0, x = 0;
632     int ret;
633     const short *samples = (const int16_t*)frame->data[0];
634
635     if ((ret = ff_alloc_packet2(avctx, avpkt, s->frame_size * 5 + 1000)) < 0)
636         return ret;
637
638     init_put_bits(&pb, avpkt->data, avpkt->size);
639
640     // short -> internal
641     for (i = 0; i < s->frame_size; i++)
642         s->int_samples[i] = samples[i];
643
644     if (!s->lossless)
645         for (i = 0; i < s->frame_size; i++)
646             s->int_samples[i] = s->int_samples[i] << SAMPLE_SHIFT;
647
648     switch(s->decorrelation)
649     {
650         case MID_SIDE:
651             for (i = 0; i < s->frame_size; i += s->channels)
652             {
653                 s->int_samples[i] += s->int_samples[i+1];
654                 s->int_samples[i+1] -= shift(s->int_samples[i], 1);
655             }
656             break;
657         case LEFT_SIDE:
658             for (i = 0; i < s->frame_size; i += s->channels)
659                 s->int_samples[i+1] -= s->int_samples[i];
660             break;
661         case RIGHT_SIDE:
662             for (i = 0; i < s->frame_size; i += s->channels)
663                 s->int_samples[i] -= s->int_samples[i+1];
664             break;
665     }
666
667     memset(s->window, 0, 4* s->window_size);
668
669     for (i = 0; i < s->tail_size; i++)
670         s->window[x++] = s->tail[i];
671
672     for (i = 0; i < s->frame_size; i++)
673         s->window[x++] = s->int_samples[i];
674
675     for (i = 0; i < s->tail_size; i++)
676         s->window[x++] = 0;
677
678     for (i = 0; i < s->tail_size; i++)
679         s->tail[i] = s->int_samples[s->frame_size - s->tail_size + i];
680
681     // generate taps
682     modified_levinson_durbin(s->window, s->window_size,
683                 s->predictor_k, s->num_taps, s->channels, s->tap_quant);
684     if ((ret = intlist_write(&pb, s->predictor_k, s->num_taps, 0)) < 0)
685         return ret;
686
687     for (ch = 0; ch < s->channels; ch++)
688     {
689         x = s->tail_size+ch;
690         for (i = 0; i < s->block_align; i++)
691         {
692             int sum = 0;
693             for (j = 0; j < s->downsampling; j++, x += s->channels)
694                 sum += s->window[x];
695             s->coded_samples[ch][i] = sum;
696         }
697     }
698
699     // simple rate control code
700     if (!s->lossless)
701     {
702         double energy1 = 0.0, energy2 = 0.0;
703         for (ch = 0; ch < s->channels; ch++)
704         {
705             for (i = 0; i < s->block_align; i++)
706             {
707                 double sample = s->coded_samples[ch][i];
708                 energy2 += sample*sample;
709                 energy1 += fabs(sample);
710             }
711         }
712
713         energy2 = sqrt(energy2/(s->channels*s->block_align));
714         energy1 = sqrt(2.0)*energy1/(s->channels*s->block_align);
715
716         // increase bitrate when samples are like a gaussian distribution
717         // reduce bitrate when samples are like a two-tailed exponential distribution
718
719         if (energy2 > energy1)
720             energy2 += (energy2-energy1)*RATE_VARIATION;
721
722         quant = (int)(BASE_QUANT*s->quantization*energy2/SAMPLE_FACTOR);
723 //        av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2);
724
725         if (quant < 1)
726             quant = 1;
727         if (quant > 65534)
728             quant = 65534;
729
730         set_ue_golomb(&pb, quant);
731
732         quant *= SAMPLE_FACTOR;
733     }
734
735     // write out coded samples
736     for (ch = 0; ch < s->channels; ch++)
737     {
738         if (!s->lossless)
739             for (i = 0; i < s->block_align; i++)
740                 s->coded_samples[ch][i] = divide(s->coded_samples[ch][i], quant);
741
742         if ((ret = intlist_write(&pb, s->coded_samples[ch], s->block_align, 1)) < 0)
743             return ret;
744     }
745
746 //    av_log(avctx, AV_LOG_DEBUG, "used bytes: %d\n", (put_bits_count(&pb)+7)/8);
747
748     flush_put_bits(&pb);
749     avpkt->size = (put_bits_count(&pb)+7)/8;
750     *got_packet_ptr = 1;
751     return 0;
752 }
753 #endif /* CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER */
754
755 #if CONFIG_SONIC_DECODER
756 static const int samplerate_table[] =
757     { 44100, 22050, 11025, 96000, 48000, 32000, 24000, 16000, 8000 };
758
759 static av_cold int sonic_decode_init(AVCodecContext *avctx)
760 {
761     SonicContext *s = avctx->priv_data;
762     GetBitContext gb;
763     int i, version;
764
765     s->channels = avctx->channels;
766     s->samplerate = avctx->sample_rate;
767
768     if (!avctx->extradata)
769     {
770         av_log(avctx, AV_LOG_ERROR, "No mandatory headers present\n");
771         return AVERROR_INVALIDDATA;
772     }
773
774     init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
775
776     version = get_bits(&gb, 2);
777     if (version > 1)
778     {
779         av_log(avctx, AV_LOG_ERROR, "Unsupported Sonic version, please report\n");
780         return AVERROR_INVALIDDATA;
781     }
782
783     if (version == 1)
784     {
785         s->channels = get_bits(&gb, 2);
786         s->samplerate = samplerate_table[get_bits(&gb, 4)];
787         av_log(avctx, AV_LOG_INFO, "Sonicv2 chans: %d samprate: %d\n",
788             s->channels, s->samplerate);
789     }
790
791     if (s->channels > MAX_CHANNELS)
792     {
793         av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
794         return AVERROR_INVALIDDATA;
795     }
796
797     s->lossless = get_bits1(&gb);
798     if (!s->lossless)
799         skip_bits(&gb, 3); // XXX FIXME
800     s->decorrelation = get_bits(&gb, 2);
801     if (s->decorrelation != 3 && s->channels != 2) {
802         av_log(avctx, AV_LOG_ERROR, "invalid decorrelation %d\n", s->decorrelation);
803         return AVERROR_INVALIDDATA;
804     }
805
806     s->downsampling = get_bits(&gb, 2);
807     if (!s->downsampling) {
808         av_log(avctx, AV_LOG_ERROR, "invalid downsampling value\n");
809         return AVERROR_INVALIDDATA;
810     }
811
812     s->num_taps = (get_bits(&gb, 5)+1)<<5;
813     if (get_bits1(&gb)) // XXX FIXME
814         av_log(avctx, AV_LOG_INFO, "Custom quant table\n");
815
816     s->block_align = (int)(2048.0*s->samplerate/44100)/s->downsampling;
817     s->frame_size = s->channels*s->block_align*s->downsampling;
818 //    avctx->frame_size = s->block_align;
819
820     av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
821         version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
822
823     // generate taps
824     s->tap_quant = av_mallocz(4* s->num_taps);
825     for (i = 0; i < s->num_taps; i++)
826         s->tap_quant[i] = (int)(sqrt(i+1));
827
828     s->predictor_k = av_mallocz(4* s->num_taps);
829
830     for (i = 0; i < s->channels; i++)
831     {
832         s->predictor_state[i] = av_mallocz(4* s->num_taps);
833         if (!s->predictor_state[i])
834             return AVERROR(ENOMEM);
835     }
836
837     for (i = 0; i < s->channels; i++)
838     {
839         s->coded_samples[i] = av_mallocz(4* s->block_align);
840         if (!s->coded_samples[i])
841             return AVERROR(ENOMEM);
842     }
843     s->int_samples = av_mallocz(4* s->frame_size);
844
845     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
846     return 0;
847 }
848
849 static av_cold int sonic_decode_close(AVCodecContext *avctx)
850 {
851     SonicContext *s = avctx->priv_data;
852     int i;
853
854     av_free(s->int_samples);
855     av_free(s->tap_quant);
856     av_free(s->predictor_k);
857
858     for (i = 0; i < s->channels; i++)
859     {
860         av_free(s->predictor_state[i]);
861         av_free(s->coded_samples[i]);
862     }
863
864     return 0;
865 }
866
867 static int sonic_decode_frame(AVCodecContext *avctx,
868                             void *data, int *got_frame_ptr,
869                             AVPacket *avpkt)
870 {
871     const uint8_t *buf = avpkt->data;
872     int buf_size = avpkt->size;
873     SonicContext *s = avctx->priv_data;
874     GetBitContext gb;
875     int i, quant, ch, j, ret;
876     int16_t *samples;
877     AVFrame *frame = data;
878
879     if (buf_size == 0) return 0;
880
881     frame->nb_samples = s->frame_size / avctx->channels;
882     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
883         return ret;
884     samples = (int16_t *)frame->data[0];
885
886 //    av_log(NULL, AV_LOG_INFO, "buf_size: %d\n", buf_size);
887
888     init_get_bits(&gb, buf, buf_size*8);
889
890     intlist_read(&gb, s->predictor_k, s->num_taps, 0);
891
892     // dequantize
893     for (i = 0; i < s->num_taps; i++)
894         s->predictor_k[i] *= s->tap_quant[i];
895
896     if (s->lossless)
897         quant = 1;
898     else
899         quant = get_ue_golomb(&gb) * SAMPLE_FACTOR;
900
901 //    av_log(NULL, AV_LOG_INFO, "quant: %d\n", quant);
902
903     for (ch = 0; ch < s->channels; ch++)
904     {
905         int x = ch;
906
907         predictor_init_state(s->predictor_k, s->predictor_state[ch], s->num_taps);
908
909         intlist_read(&gb, s->coded_samples[ch], s->block_align, 1);
910
911         for (i = 0; i < s->block_align; i++)
912         {
913             for (j = 0; j < s->downsampling - 1; j++)
914             {
915                 s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, 0);
916                 x += s->channels;
917             }
918
919             s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, s->coded_samples[ch][i] * quant);
920             x += s->channels;
921         }
922
923         for (i = 0; i < s->num_taps; i++)
924             s->predictor_state[ch][i] = s->int_samples[s->frame_size - s->channels + ch - i*s->channels];
925     }
926
927     switch(s->decorrelation)
928     {
929         case MID_SIDE:
930             for (i = 0; i < s->frame_size; i += s->channels)
931             {
932                 s->int_samples[i+1] += shift(s->int_samples[i], 1);
933                 s->int_samples[i] -= s->int_samples[i+1];
934             }
935             break;
936         case LEFT_SIDE:
937             for (i = 0; i < s->frame_size; i += s->channels)
938                 s->int_samples[i+1] += s->int_samples[i];
939             break;
940         case RIGHT_SIDE:
941             for (i = 0; i < s->frame_size; i += s->channels)
942                 s->int_samples[i] += s->int_samples[i+1];
943             break;
944     }
945
946     if (!s->lossless)
947         for (i = 0; i < s->frame_size; i++)
948             s->int_samples[i] = shift(s->int_samples[i], SAMPLE_SHIFT);
949
950     // internal -> short
951     for (i = 0; i < s->frame_size; i++)
952         samples[i] = av_clip_int16(s->int_samples[i]);
953
954     align_get_bits(&gb);
955
956     *got_frame_ptr = 1;
957
958     return (get_bits_count(&gb)+7)/8;
959 }
960
961 AVCodec ff_sonic_decoder = {
962     .name           = "sonic",
963     .type           = AVMEDIA_TYPE_AUDIO,
964     .id             = AV_CODEC_ID_SONIC,
965     .priv_data_size = sizeof(SonicContext),
966     .init           = sonic_decode_init,
967     .close          = sonic_decode_close,
968     .decode         = sonic_decode_frame,
969     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,
970     .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
971 };
972 #endif /* CONFIG_SONIC_DECODER */
973
974 #if CONFIG_SONIC_ENCODER
975 AVCodec ff_sonic_encoder = {
976     .name           = "sonic",
977     .type           = AVMEDIA_TYPE_AUDIO,
978     .id             = AV_CODEC_ID_SONIC,
979     .priv_data_size = sizeof(SonicContext),
980     .init           = sonic_encode_init,
981     .encode2        = sonic_encode_frame,
982     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },
983     .capabilities   = CODEC_CAP_EXPERIMENTAL,
984     .close          = sonic_encode_close,
985     .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
986 };
987 #endif
988
989 #if CONFIG_SONIC_LS_ENCODER
990 AVCodec ff_sonic_ls_encoder = {
991     .name           = "sonicls",
992     .type           = AVMEDIA_TYPE_AUDIO,
993     .id             = AV_CODEC_ID_SONIC_LS,
994     .priv_data_size = sizeof(SonicContext),
995     .init           = sonic_encode_init,
996     .encode2        = sonic_encode_frame,
997     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },
998     .capabilities   = CODEC_CAP_EXPERIMENTAL,
999     .close          = sonic_encode_close,
1000     .long_name = NULL_IF_CONFIG_SMALL("Sonic lossless"),
1001 };
1002 #endif