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