GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/sonic.c Lines: 0 394 0.0 %
Date: 2020-10-23 17:01:47 Branches: 0 274 0.0 %

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