FFmpeg coverage

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