FFmpeg  4.1.5
sonic.c
Go to the documentation of this file.
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;
53 
55  double quantization;
56 
58 
59  int *tap_quant;
62 
63  // for encoding
64  int *tail;
65  int tail_size;
66  int *window;
68 
69  // for decoding
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, a;
144  e= 0;
145  while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
146  e++;
147  if (e > 31)
148  return AVERROR_INVALIDDATA;
149  }
150 
151  a= 1;
152  for(i=e-1; i>=0; i--){
153  a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
154  }
155 
156  e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
157  return (a^e)-e;
158  }
159 }
160 
161 #if 1
162 static inline int intlist_write(RangeCoder *c, uint8_t *state, int *buf, int entries, int base_2_part)
163 {
164  int i;
165 
166  for (i = 0; i < entries; i++)
167  put_symbol(c, state, buf[i], 1, NULL, NULL);
168 
169  return 1;
170 }
171 
172 static inline int intlist_read(RangeCoder *c, uint8_t *state, int *buf, int entries, int base_2_part)
173 {
174  int i;
175 
176  for (i = 0; i < entries; i++)
177  buf[i] = get_symbol(c, state, 1);
178 
179  return 1;
180 }
181 #elif 1
182 static inline int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part)
183 {
184  int i;
185 
186  for (i = 0; i < entries; i++)
187  set_se_golomb(pb, buf[i]);
188 
189  return 1;
190 }
191 
192 static inline int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part)
193 {
194  int i;
195 
196  for (i = 0; i < entries; i++)
197  buf[i] = get_se_golomb(gb);
198 
199  return 1;
200 }
201 
202 #else
203 
204 #define ADAPT_LEVEL 8
205 
206 static int bits_to_store(uint64_t x)
207 {
208  int res = 0;
209 
210  while(x)
211  {
212  res++;
213  x >>= 1;
214  }
215  return res;
216 }
217 
218 static void write_uint_max(PutBitContext *pb, unsigned int value, unsigned int max)
219 {
220  int i, bits;
221 
222  if (!max)
223  return;
224 
225  bits = bits_to_store(max);
226 
227  for (i = 0; i < bits-1; i++)
228  put_bits(pb, 1, value & (1 << i));
229 
230  if ( (value | (1 << (bits-1))) <= max)
231  put_bits(pb, 1, value & (1 << (bits-1)));
232 }
233 
234 static unsigned int read_uint_max(GetBitContext *gb, int max)
235 {
236  int i, bits, value = 0;
237 
238  if (!max)
239  return 0;
240 
241  bits = bits_to_store(max);
242 
243  for (i = 0; i < bits-1; i++)
244  if (get_bits1(gb))
245  value += 1 << i;
246 
247  if ( (value | (1<<(bits-1))) <= max)
248  if (get_bits1(gb))
249  value += 1 << (bits-1);
250 
251  return value;
252 }
253 
254 static int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part)
255 {
256  int i, j, x = 0, low_bits = 0, max = 0;
257  int step = 256, pos = 0, dominant = 0, any = 0;
258  int *copy, *bits;
259 
260  copy = av_calloc(entries, sizeof(*copy));
261  if (!copy)
262  return AVERROR(ENOMEM);
263 
264  if (base_2_part)
265  {
266  int energy = 0;
267 
268  for (i = 0; i < entries; i++)
269  energy += abs(buf[i]);
270 
271  low_bits = bits_to_store(energy / (entries * 2));
272  if (low_bits > 15)
273  low_bits = 15;
274 
275  put_bits(pb, 4, low_bits);
276  }
277 
278  for (i = 0; i < entries; i++)
279  {
280  put_bits(pb, low_bits, abs(buf[i]));
281  copy[i] = abs(buf[i]) >> low_bits;
282  if (copy[i] > max)
283  max = abs(copy[i]);
284  }
285 
286  bits = av_calloc(entries*max, sizeof(*bits));
287  if (!bits)
288  {
289  av_free(copy);
290  return AVERROR(ENOMEM);
291  }
292 
293  for (i = 0; i <= max; i++)
294  {
295  for (j = 0; j < entries; j++)
296  if (copy[j] >= i)
297  bits[x++] = copy[j] > i;
298  }
299 
300  // store bitstream
301  while (pos < x)
302  {
303  int steplet = step >> 8;
304 
305  if (pos + steplet > x)
306  steplet = x - pos;
307 
308  for (i = 0; i < steplet; i++)
309  if (bits[i+pos] != dominant)
310  any = 1;
311 
312  put_bits(pb, 1, any);
313 
314  if (!any)
315  {
316  pos += steplet;
317  step += step / ADAPT_LEVEL;
318  }
319  else
320  {
321  int interloper = 0;
322 
323  while (((pos + interloper) < x) && (bits[pos + interloper] == dominant))
324  interloper++;
325 
326  // note change
327  write_uint_max(pb, interloper, (step >> 8) - 1);
328 
329  pos += interloper + 1;
330  step -= step / ADAPT_LEVEL;
331  }
332 
333  if (step < 256)
334  {
335  step = 65536 / step;
336  dominant = !dominant;
337  }
338  }
339 
340  // store signs
341  for (i = 0; i < entries; i++)
342  if (buf[i])
343  put_bits(pb, 1, buf[i] < 0);
344 
345  av_free(bits);
346  av_free(copy);
347 
348  return 0;
349 }
350 
351 static int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part)
352 {
353  int i, low_bits = 0, x = 0;
354  int n_zeros = 0, step = 256, dominant = 0;
355  int pos = 0, level = 0;
356  int *bits = av_calloc(entries, sizeof(*bits));
357 
358  if (!bits)
359  return AVERROR(ENOMEM);
360 
361  if (base_2_part)
362  {
363  low_bits = get_bits(gb, 4);
364 
365  if (low_bits)
366  for (i = 0; i < entries; i++)
367  buf[i] = get_bits(gb, low_bits);
368  }
369 
370 // av_log(NULL, AV_LOG_INFO, "entries: %d, low bits: %d\n", entries, low_bits);
371 
372  while (n_zeros < entries)
373  {
374  int steplet = step >> 8;
375 
376  if (!get_bits1(gb))
377  {
378  for (i = 0; i < steplet; i++)
379  bits[x++] = dominant;
380 
381  if (!dominant)
382  n_zeros += steplet;
383 
384  step += step / ADAPT_LEVEL;
385  }
386  else
387  {
388  int actual_run = read_uint_max(gb, steplet-1);
389 
390 // av_log(NULL, AV_LOG_INFO, "actual run: %d\n", actual_run);
391 
392  for (i = 0; i < actual_run; i++)
393  bits[x++] = dominant;
394 
395  bits[x++] = !dominant;
396 
397  if (!dominant)
398  n_zeros += actual_run;
399  else
400  n_zeros++;
401 
402  step -= step / ADAPT_LEVEL;
403  }
404 
405  if (step < 256)
406  {
407  step = 65536 / step;
408  dominant = !dominant;
409  }
410  }
411 
412  // reconstruct unsigned values
413  n_zeros = 0;
414  for (i = 0; n_zeros < entries; i++)
415  {
416  while(1)
417  {
418  if (pos >= entries)
419  {
420  pos = 0;
421  level += 1 << low_bits;
422  }
423 
424  if (buf[pos] >= level)
425  break;
426 
427  pos++;
428  }
429 
430  if (bits[i])
431  buf[pos] += 1 << low_bits;
432  else
433  n_zeros++;
434 
435  pos++;
436  }
437  av_free(bits);
438 
439  // read signs
440  for (i = 0; i < entries; i++)
441  if (buf[i] && get_bits1(gb))
442  buf[i] = -buf[i];
443 
444 // av_log(NULL, AV_LOG_INFO, "zeros: %d pos: %d\n", n_zeros, pos);
445 
446  return 0;
447 }
448 #endif
449 
450 static void predictor_init_state(int *k, int *state, int order)
451 {
452  int i;
453 
454  for (i = order-2; i >= 0; i--)
455  {
456  int j, p, x = state[i];
457 
458  for (j = 0, p = i+1; p < order; j++,p++)
459  {
460  int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT);
461  state[p] += shift_down(k[j]*x, LATTICE_SHIFT);
462  x = tmp;
463  }
464  }
465 }
466 
467 static int predictor_calc_error(int *k, int *state, int order, int error)
468 {
469  int i, x = error - shift_down(k[order-1] * state[order-1], LATTICE_SHIFT);
470 
471 #if 1
472  int *k_ptr = &(k[order-2]),
473  *state_ptr = &(state[order-2]);
474  for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--)
475  {
476  int k_value = *k_ptr, state_value = *state_ptr;
477  x -= shift_down(k_value * state_value, LATTICE_SHIFT);
478  state_ptr[1] = state_value + shift_down(k_value * (unsigned)x, LATTICE_SHIFT);
479  }
480 #else
481  for (i = order-2; i >= 0; i--)
482  {
483  x -= shift_down(k[i] * state[i], LATTICE_SHIFT);
484  state[i+1] = state[i] + shift_down(k[i] * x, LATTICE_SHIFT);
485  }
486 #endif
487 
488  // don't drift too far, to avoid overflows
489  if (x > (SAMPLE_FACTOR<<16)) x = (SAMPLE_FACTOR<<16);
490  if (x < -(SAMPLE_FACTOR<<16)) x = -(SAMPLE_FACTOR<<16);
491 
492  state[0] = x;
493 
494  return x;
495 }
496 
497 #if CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER
498 // Heavily modified Levinson-Durbin algorithm which
499 // copes better with quantization, and calculates the
500 // actual whitened result as it goes.
501 
502 static int modified_levinson_durbin(int *window, int window_entries,
503  int *out, int out_entries, int channels, int *tap_quant)
504 {
505  int i;
506  int *state = av_calloc(window_entries, sizeof(*state));
507 
508  if (!state)
509  return AVERROR(ENOMEM);
510 
511  memcpy(state, window, 4* window_entries);
512 
513  for (i = 0; i < out_entries; i++)
514  {
515  int step = (i+1)*channels, k, j;
516  double xx = 0.0, xy = 0.0;
517 #if 1
518  int *x_ptr = &(window[step]);
519  int *state_ptr = &(state[0]);
520  j = window_entries - step;
521  for (;j>0;j--,x_ptr++,state_ptr++)
522  {
523  double x_value = *x_ptr;
524  double state_value = *state_ptr;
525  xx += state_value*state_value;
526  xy += x_value*state_value;
527  }
528 #else
529  for (j = 0; j <= (window_entries - step); j++);
530  {
531  double stepval = window[step+j];
532  double stateval = window[j];
533 // xx += (double)window[j]*(double)window[j];
534 // xy += (double)window[step+j]*(double)window[j];
535  xx += stateval*stateval;
536  xy += stepval*stateval;
537  }
538 #endif
539  if (xx == 0.0)
540  k = 0;
541  else
542  k = (int)(floor(-xy/xx * (double)LATTICE_FACTOR / (double)(tap_quant[i]) + 0.5));
543 
544  if (k > (LATTICE_FACTOR/tap_quant[i]))
545  k = LATTICE_FACTOR/tap_quant[i];
546  if (-k > (LATTICE_FACTOR/tap_quant[i]))
547  k = -(LATTICE_FACTOR/tap_quant[i]);
548 
549  out[i] = k;
550  k *= tap_quant[i];
551 
552 #if 1
553  x_ptr = &(window[step]);
554  state_ptr = &(state[0]);
555  j = window_entries - step;
556  for (;j>0;j--,x_ptr++,state_ptr++)
557  {
558  int x_value = *x_ptr;
559  int state_value = *state_ptr;
560  *x_ptr = x_value + shift_down(k*state_value,LATTICE_SHIFT);
561  *state_ptr = state_value + shift_down(k*x_value, LATTICE_SHIFT);
562  }
563 #else
564  for (j=0; j <= (window_entries - step); j++)
565  {
566  int stepval = window[step+j];
567  int stateval=state[j];
568  window[step+j] += shift_down(k * stateval, LATTICE_SHIFT);
569  state[j] += shift_down(k * stepval, LATTICE_SHIFT);
570  }
571 #endif
572  }
573 
574  av_free(state);
575  return 0;
576 }
577 
578 static inline int code_samplerate(int samplerate)
579 {
580  switch (samplerate)
581  {
582  case 44100: return 0;
583  case 22050: return 1;
584  case 11025: return 2;
585  case 96000: return 3;
586  case 48000: return 4;
587  case 32000: return 5;
588  case 24000: return 6;
589  case 16000: return 7;
590  case 8000: return 8;
591  }
592  return AVERROR(EINVAL);
593 }
594 
595 static av_cold int sonic_encode_init(AVCodecContext *avctx)
596 {
597  SonicContext *s = avctx->priv_data;
598  PutBitContext pb;
599  int i;
600 
601  s->version = 2;
602 
603  if (avctx->channels > MAX_CHANNELS)
604  {
605  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
606  return AVERROR(EINVAL); /* only stereo or mono for now */
607  }
608 
609  if (avctx->channels == 2)
610  s->decorrelation = MID_SIDE;
611  else
612  s->decorrelation = 3;
613 
614  if (avctx->codec->id == AV_CODEC_ID_SONIC_LS)
615  {
616  s->lossless = 1;
617  s->num_taps = 32;
618  s->downsampling = 1;
619  s->quantization = 0.0;
620  }
621  else
622  {
623  s->num_taps = 128;
624  s->downsampling = 2;
625  s->quantization = 1.0;
626  }
627 
628  // max tap 2048
629  if (s->num_taps < 32 || s->num_taps > 1024 || s->num_taps % 32) {
630  av_log(avctx, AV_LOG_ERROR, "Invalid number of taps\n");
631  return AVERROR_INVALIDDATA;
632  }
633 
634  // generate taps
635  s->tap_quant = av_calloc(s->num_taps, sizeof(*s->tap_quant));
636  if (!s->tap_quant)
637  return AVERROR(ENOMEM);
638 
639  for (i = 0; i < s->num_taps; i++)
640  s->tap_quant[i] = ff_sqrt(i+1);
641 
642  s->channels = avctx->channels;
643  s->samplerate = avctx->sample_rate;
644 
645  s->block_align = 2048LL*s->samplerate/(44100*s->downsampling);
647 
648  s->tail_size = s->num_taps*s->channels;
649  s->tail = av_calloc(s->tail_size, sizeof(*s->tail));
650  if (!s->tail)
651  return AVERROR(ENOMEM);
652 
653  s->predictor_k = av_calloc(s->num_taps, sizeof(*s->predictor_k) );
654  if (!s->predictor_k)
655  return AVERROR(ENOMEM);
656 
657  for (i = 0; i < s->channels; i++)
658  {
659  s->coded_samples[i] = av_calloc(s->block_align, sizeof(**s->coded_samples));
660  if (!s->coded_samples[i])
661  return AVERROR(ENOMEM);
662  }
663 
664  s->int_samples = av_calloc(s->frame_size, sizeof(*s->int_samples));
665 
666  s->window_size = ((2*s->tail_size)+s->frame_size);
667  s->window = av_calloc(s->window_size, sizeof(*s->window));
668  if (!s->window || !s->int_samples)
669  return AVERROR(ENOMEM);
670 
671  avctx->extradata = av_mallocz(16);
672  if (!avctx->extradata)
673  return AVERROR(ENOMEM);
674  init_put_bits(&pb, avctx->extradata, 16*8);
675 
676  put_bits(&pb, 2, s->version); // version
677  if (s->version >= 1)
678  {
679  if (s->version >= 2) {
680  put_bits(&pb, 8, s->version);
681  put_bits(&pb, 8, s->minor_version);
682  }
683  put_bits(&pb, 2, s->channels);
684  put_bits(&pb, 4, code_samplerate(s->samplerate));
685  }
686  put_bits(&pb, 1, s->lossless);
687  if (!s->lossless)
688  put_bits(&pb, 3, SAMPLE_SHIFT); // XXX FIXME: sample precision
689  put_bits(&pb, 2, s->decorrelation);
690  put_bits(&pb, 2, s->downsampling);
691  put_bits(&pb, 5, (s->num_taps >> 5)-1); // 32..1024
692  put_bits(&pb, 1, 0); // XXX FIXME: no custom tap quant table
693 
694  flush_put_bits(&pb);
695  avctx->extradata_size = put_bits_count(&pb)/8;
696 
697  av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d.%d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
699 
700  avctx->frame_size = s->block_align*s->downsampling;
701 
702  return 0;
703 }
704 
705 static av_cold int sonic_encode_close(AVCodecContext *avctx)
706 {
707  SonicContext *s = avctx->priv_data;
708  int i;
709 
710  for (i = 0; i < s->channels; i++)
711  av_freep(&s->coded_samples[i]);
712 
713  av_freep(&s->predictor_k);
714  av_freep(&s->tail);
715  av_freep(&s->tap_quant);
716  av_freep(&s->window);
717  av_freep(&s->int_samples);
718 
719  return 0;
720 }
721 
722 static int sonic_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
723  const AVFrame *frame, int *got_packet_ptr)
724 {
725  SonicContext *s = avctx->priv_data;
726  RangeCoder c;
727  int i, j, ch, quant = 0, x = 0;
728  int ret;
729  const short *samples = (const int16_t*)frame->data[0];
730  uint8_t state[32];
731 
732  if ((ret = ff_alloc_packet2(avctx, avpkt, s->frame_size * 5 + 1000, 0)) < 0)
733  return ret;
734 
735  ff_init_range_encoder(&c, avpkt->data, avpkt->size);
736  ff_build_rac_states(&c, 0.05*(1LL<<32), 256-8);
737  memset(state, 128, sizeof(state));
738 
739  // short -> internal
740  for (i = 0; i < s->frame_size; i++)
741  s->int_samples[i] = samples[i];
742 
743  if (!s->lossless)
744  for (i = 0; i < s->frame_size; i++)
745  s->int_samples[i] = s->int_samples[i] << SAMPLE_SHIFT;
746 
747  switch(s->decorrelation)
748  {
749  case MID_SIDE:
750  for (i = 0; i < s->frame_size; i += s->channels)
751  {
752  s->int_samples[i] += s->int_samples[i+1];
753  s->int_samples[i+1] -= shift(s->int_samples[i], 1);
754  }
755  break;
756  case LEFT_SIDE:
757  for (i = 0; i < s->frame_size; i += s->channels)
758  s->int_samples[i+1] -= s->int_samples[i];
759  break;
760  case RIGHT_SIDE:
761  for (i = 0; i < s->frame_size; i += s->channels)
762  s->int_samples[i] -= s->int_samples[i+1];
763  break;
764  }
765 
766  memset(s->window, 0, 4* s->window_size);
767 
768  for (i = 0; i < s->tail_size; i++)
769  s->window[x++] = s->tail[i];
770 
771  for (i = 0; i < s->frame_size; i++)
772  s->window[x++] = s->int_samples[i];
773 
774  for (i = 0; i < s->tail_size; i++)
775  s->window[x++] = 0;
776 
777  for (i = 0; i < s->tail_size; i++)
778  s->tail[i] = s->int_samples[s->frame_size - s->tail_size + i];
779 
780  // generate taps
781  ret = modified_levinson_durbin(s->window, s->window_size,
782  s->predictor_k, s->num_taps, s->channels, s->tap_quant);
783  if (ret < 0)
784  return ret;
785 
786  if ((ret = intlist_write(&c, state, s->predictor_k, s->num_taps, 0)) < 0)
787  return ret;
788 
789  for (ch = 0; ch < s->channels; ch++)
790  {
791  x = s->tail_size+ch;
792  for (i = 0; i < s->block_align; i++)
793  {
794  int sum = 0;
795  for (j = 0; j < s->downsampling; j++, x += s->channels)
796  sum += s->window[x];
797  s->coded_samples[ch][i] = sum;
798  }
799  }
800 
801  // simple rate control code
802  if (!s->lossless)
803  {
804  double energy1 = 0.0, energy2 = 0.0;
805  for (ch = 0; ch < s->channels; ch++)
806  {
807  for (i = 0; i < s->block_align; i++)
808  {
809  double sample = s->coded_samples[ch][i];
810  energy2 += sample*sample;
811  energy1 += fabs(sample);
812  }
813  }
814 
815  energy2 = sqrt(energy2/(s->channels*s->block_align));
816  energy1 = M_SQRT2*energy1/(s->channels*s->block_align);
817 
818  // increase bitrate when samples are like a gaussian distribution
819  // reduce bitrate when samples are like a two-tailed exponential distribution
820 
821  if (energy2 > energy1)
822  energy2 += (energy2-energy1)*RATE_VARIATION;
823 
824  quant = (int)(BASE_QUANT*s->quantization*energy2/SAMPLE_FACTOR);
825 // av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2);
826 
827  quant = av_clip(quant, 1, 65534);
828 
829  put_symbol(&c, state, quant, 0, NULL, NULL);
830 
831  quant *= SAMPLE_FACTOR;
832  }
833 
834  // write out coded samples
835  for (ch = 0; ch < s->channels; ch++)
836  {
837  if (!s->lossless)
838  for (i = 0; i < s->block_align; i++)
839  s->coded_samples[ch][i] = ROUNDED_DIV(s->coded_samples[ch][i], quant);
840 
841  if ((ret = intlist_write(&c, state, s->coded_samples[ch], s->block_align, 1)) < 0)
842  return ret;
843  }
844 
845 // av_log(avctx, AV_LOG_DEBUG, "used bytes: %d\n", (put_bits_count(&pb)+7)/8);
846 
847  avpkt->size = ff_rac_terminate(&c);
848  *got_packet_ptr = 1;
849  return 0;
850 
851 }
852 #endif /* CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER */
853 
854 #if CONFIG_SONIC_DECODER
855 static const int samplerate_table[] =
856  { 44100, 22050, 11025, 96000, 48000, 32000, 24000, 16000, 8000 };
857 
858 static av_cold int sonic_decode_init(AVCodecContext *avctx)
859 {
860  SonicContext *s = avctx->priv_data;
861  GetBitContext gb;
862  int i;
863  int ret;
864 
865  s->channels = avctx->channels;
866  s->samplerate = avctx->sample_rate;
867 
868  if (!avctx->extradata)
869  {
870  av_log(avctx, AV_LOG_ERROR, "No mandatory headers present\n");
871  return AVERROR_INVALIDDATA;
872  }
873 
874  ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size);
875  if (ret < 0)
876  return ret;
877 
878  s->version = get_bits(&gb, 2);
879  if (s->version >= 2) {
880  s->version = get_bits(&gb, 8);
881  s->minor_version = get_bits(&gb, 8);
882  }
883  if (s->version != 2)
884  {
885  av_log(avctx, AV_LOG_ERROR, "Unsupported Sonic version, please report\n");
886  return AVERROR_INVALIDDATA;
887  }
888 
889  if (s->version >= 1)
890  {
891  int sample_rate_index;
892  s->channels = get_bits(&gb, 2);
893  sample_rate_index = get_bits(&gb, 4);
894  if (sample_rate_index >= FF_ARRAY_ELEMS(samplerate_table)) {
895  av_log(avctx, AV_LOG_ERROR, "Invalid sample_rate_index %d\n", sample_rate_index);
896  return AVERROR_INVALIDDATA;
897  }
898  s->samplerate = samplerate_table[sample_rate_index];
899  av_log(avctx, AV_LOG_INFO, "Sonicv2 chans: %d samprate: %d\n",
900  s->channels, s->samplerate);
901  }
902 
903  if (s->channels > MAX_CHANNELS || s->channels < 1)
904  {
905  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
906  return AVERROR_INVALIDDATA;
907  }
908  avctx->channels = s->channels;
909 
910  s->lossless = get_bits1(&gb);
911  if (!s->lossless)
912  skip_bits(&gb, 3); // XXX FIXME
913  s->decorrelation = get_bits(&gb, 2);
914  if (s->decorrelation != 3 && s->channels != 2) {
915  av_log(avctx, AV_LOG_ERROR, "invalid decorrelation %d\n", s->decorrelation);
916  return AVERROR_INVALIDDATA;
917  }
918 
919  s->downsampling = get_bits(&gb, 2);
920  if (!s->downsampling) {
921  av_log(avctx, AV_LOG_ERROR, "invalid downsampling value\n");
922  return AVERROR_INVALIDDATA;
923  }
924 
925  s->num_taps = (get_bits(&gb, 5)+1)<<5;
926  if (get_bits1(&gb)) // XXX FIXME
927  av_log(avctx, AV_LOG_INFO, "Custom quant table\n");
928 
929  s->block_align = 2048LL*s->samplerate/(44100*s->downsampling);
931 // avctx->frame_size = s->block_align;
932 
933  if (s->num_taps * s->channels > s->frame_size) {
934  av_log(avctx, AV_LOG_ERROR,
935  "number of taps times channels (%d * %d) larger than frame size %d\n",
936  s->num_taps, s->channels, s->frame_size);
937  return AVERROR_INVALIDDATA;
938  }
939 
940  av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d.%d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
942 
943  // generate taps
944  s->tap_quant = av_calloc(s->num_taps, sizeof(*s->tap_quant));
945  if (!s->tap_quant)
946  return AVERROR(ENOMEM);
947 
948  for (i = 0; i < s->num_taps; i++)
949  s->tap_quant[i] = ff_sqrt(i+1);
950 
951  s->predictor_k = av_calloc(s->num_taps, sizeof(*s->predictor_k));
952 
953  for (i = 0; i < s->channels; i++)
954  {
955  s->predictor_state[i] = av_calloc(s->num_taps, sizeof(**s->predictor_state));
956  if (!s->predictor_state[i])
957  return AVERROR(ENOMEM);
958  }
959 
960  for (i = 0; i < s->channels; i++)
961  {
962  s->coded_samples[i] = av_calloc(s->block_align, sizeof(**s->coded_samples));
963  if (!s->coded_samples[i])
964  return AVERROR(ENOMEM);
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  int i;
978 
979  av_freep(&s->int_samples);
980  av_freep(&s->tap_quant);
981  av_freep(&s->predictor_k);
982 
983  for (i = 0; i < s->channels; i++)
984  {
985  av_freep(&s->predictor_state[i]);
986  av_freep(&s->coded_samples[i]);
987  }
988 
989  return 0;
990 }
991 
992 static int sonic_decode_frame(AVCodecContext *avctx,
993  void *data, int *got_frame_ptr,
994  AVPacket *avpkt)
995 {
996  const uint8_t *buf = avpkt->data;
997  int buf_size = avpkt->size;
998  SonicContext *s = avctx->priv_data;
999  RangeCoder c;
1000  uint8_t state[32];
1001  int i, quant, ch, j, ret;
1002  int16_t *samples;
1003  AVFrame *frame = data;
1004 
1005  if (buf_size == 0) return 0;
1006 
1007  frame->nb_samples = s->frame_size / avctx->channels;
1008  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1009  return ret;
1010  samples = (int16_t *)frame->data[0];
1011 
1012 // av_log(NULL, AV_LOG_INFO, "buf_size: %d\n", buf_size);
1013 
1014  memset(state, 128, sizeof(state));
1015  ff_init_range_decoder(&c, buf, buf_size);
1016  ff_build_rac_states(&c, 0.05*(1LL<<32), 256-8);
1017 
1018  intlist_read(&c, state, s->predictor_k, s->num_taps, 0);
1019 
1020  // dequantize
1021  for (i = 0; i < s->num_taps; i++)
1022  s->predictor_k[i] *= s->tap_quant[i];
1023 
1024  if (s->lossless)
1025  quant = 1;
1026  else
1027  quant = get_symbol(&c, state, 0) * SAMPLE_FACTOR;
1028 
1029 // av_log(NULL, AV_LOG_INFO, "quant: %d\n", quant);
1030 
1031  for (ch = 0; ch < s->channels; ch++)
1032  {
1033  int x = ch;
1034 
1036 
1037  intlist_read(&c, state, s->coded_samples[ch], s->block_align, 1);
1038 
1039  for (i = 0; i < s->block_align; i++)
1040  {
1041  for (j = 0; j < s->downsampling - 1; j++)
1042  {
1044  x += s->channels;
1045  }
1046 
1047  s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, s->coded_samples[ch][i] * quant);
1048  x += s->channels;
1049  }
1050 
1051  for (i = 0; i < s->num_taps; i++)
1052  s->predictor_state[ch][i] = s->int_samples[s->frame_size - s->channels + ch - i*s->channels];
1053  }
1054 
1055  switch(s->decorrelation)
1056  {
1057  case MID_SIDE:
1058  for (i = 0; i < s->frame_size; i += s->channels)
1059  {
1060  s->int_samples[i+1] += shift(s->int_samples[i], 1);
1061  s->int_samples[i] -= s->int_samples[i+1];
1062  }
1063  break;
1064  case LEFT_SIDE:
1065  for (i = 0; i < s->frame_size; i += s->channels)
1066  s->int_samples[i+1] += s->int_samples[i];
1067  break;
1068  case RIGHT_SIDE:
1069  for (i = 0; i < s->frame_size; i += s->channels)
1070  s->int_samples[i] += s->int_samples[i+1];
1071  break;
1072  }
1073 
1074  if (!s->lossless)
1075  for (i = 0; i < s->frame_size; i++)
1076  s->int_samples[i] = shift(s->int_samples[i], SAMPLE_SHIFT);
1077 
1078  // internal -> short
1079  for (i = 0; i < s->frame_size; i++)
1080  samples[i] = av_clip_int16(s->int_samples[i]);
1081 
1082  *got_frame_ptr = 1;
1083 
1084  return buf_size;
1085 }
1086 
1088  .name = "sonic",
1089  .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
1090  .type = AVMEDIA_TYPE_AUDIO,
1091  .id = AV_CODEC_ID_SONIC,
1092  .priv_data_size = sizeof(SonicContext),
1093  .init = sonic_decode_init,
1094  .close = sonic_decode_close,
1095  .decode = sonic_decode_frame,
1096  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_EXPERIMENTAL,
1097 };
1098 #endif /* CONFIG_SONIC_DECODER */
1099 
1100 #if CONFIG_SONIC_ENCODER
1102  .name = "sonic",
1103  .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
1104  .type = AVMEDIA_TYPE_AUDIO,
1105  .id = AV_CODEC_ID_SONIC,
1106  .priv_data_size = sizeof(SonicContext),
1107  .init = sonic_encode_init,
1108  .encode2 = sonic_encode_frame,
1110  .capabilities = AV_CODEC_CAP_EXPERIMENTAL,
1111  .close = sonic_encode_close,
1112 };
1113 #endif
1114 
1115 #if CONFIG_SONIC_LS_ENCODER
1117  .name = "sonicls",
1118  .long_name = NULL_IF_CONFIG_SMALL("Sonic lossless"),
1119  .type = AVMEDIA_TYPE_AUDIO,
1120  .id = AV_CODEC_ID_SONIC_LS,
1121  .priv_data_size = sizeof(SonicContext),
1122  .init = sonic_encode_init,
1123  .encode2 = sonic_encode_frame,
1125  .capabilities = AV_CODEC_CAP_EXPERIMENTAL,
1126  .close = sonic_encode_close,
1127 };
1128 #endif
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1542
int * int_samples
Definition: sonic.c:60
int * tail
Definition: sonic.c:64
int samplerate
Definition: sonic.c:57
#define LATTICE_FACTOR
Definition: sonic.c:76
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
static void copy(const float *p1, float *p2, const int length)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
int lossless
Definition: sonic.c:52
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
int * predictor_state[MAX_CHANNELS]
Definition: sonic.c:71
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
channels
Definition: aptx.c:30
Range coder.
int size
Definition: avcodec.h:1446
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
const char * b
Definition: vf_curves.c:116
#define LATTICE_SHIFT
Definition: sonic.c:74
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1016
int version
Definition: sonic.c:50
int * tap_quant
Definition: sonic.c:59
#define sample
AVCodec.
Definition: avcodec.h:3424
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:109
#define MID_SIDE
Definition: sonic.c:45
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
AVCodec ff_sonic_ls_encoder
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2197
uint8_t
#define av_cold
Definition: attributes.h:82
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:119
#define MAX_CHANNELS
Definition: sonic.c:43
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1634
static AVFrame * frame
const char data[16]
Definition: mxf.c:91
uint8_t * data
Definition: avcodec.h:1445
bitstream reader API header.
#define RIGHT_SIDE
Definition: sonic.c:47
#define av_log(a,...)
#define ff_sqrt
Definition: mathops.h:206
#define ROUNDED_DIV(a, b)
Definition: common.h:56
enum AVCodecID id
Definition: avcodec.h:3438
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:258
int channels
Definition: sonic.c:57
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
const char * name
Name of the codec implementation.
Definition: avcodec.h:3431
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
static struct @303 state
AVCodec ff_sonic_decoder
#define av_flatten
Definition: attributes.h:88
#define FFMIN(a, b)
Definition: common.h:96
static av_flatten int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: sonic.c:139
int block_align
Definition: sonic.c:57
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
#define RATE_VARIATION
Definition: sonic.c:80
if(ret< 0)
Definition: vf_mcdeint.c:279
static void error(const char *err)
#define FF_ARRAY_ELEMS(a)
#define av_log2
Definition: intmath.h:83
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2209
AVCodec ff_sonic_encoder
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Libavcodec external API header.
static void set_se_golomb(PutBitContext *pb, int i)
write signed exp golomb code.
Definition: golomb.h:661
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2189
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:650
int * predictor_k
Definition: sonic.c:70
main external API structure.
Definition: avcodec.h:1533
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1918
void * buf
Definition: avisynth_c.h:690
int tail_size
Definition: sonic.c:65
int extradata_size
Definition: avcodec.h:1635
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:487
double value
Definition: eval.c:98
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:460
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: rangecoder.c:53
#define LEFT_SIDE
Definition: sonic.c:46
static int intlist_write(RangeCoder *c, uint8_t *state, int *buf, int entries, int base_2_part)
Definition: sonic.c:162
static void predictor_init_state(int *k, int *state, int order)
Definition: sonic.c:450
const uint8_t * quant
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
uint8_t level
Definition: svq3.c:207
#define BASE_QUANT
Definition: sonic.c:79
#define SAMPLE_SHIFT
Definition: sonic.c:75
#define put_rac(C, S, B)
#define M_SQRT2
Definition: mathematics.h:61
int
int downsampling
Definition: sonic.c:54
int decorrelation
Definition: sonic.c:52
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
signed 16 bits
Definition: samplefmt.h:61
static double c[64]
int window_size
Definition: sonic.c:67
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
void * priv_data
Definition: avcodec.h:1560
#define av_free(p)
int channels
number of audio channels
Definition: avcodec.h:2190
double quantization
Definition: sonic.c:55
int * coded_samples[MAX_CHANNELS]
Definition: sonic.c:61
static int predictor_calc_error(int *k, int *state, int order, int error)
Definition: sonic.c:467
int frame_size
Definition: sonic.c:57
int num_taps
Definition: sonic.c:54
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
int minor_version
Definition: sonic.c:51
FILE * out
Definition: movenc.c:54
#define SAMPLE_FACTOR
Definition: sonic.c:77
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
static int shift_down(int a, int b)
Definition: sonic.c:87
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1422
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:292
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:968
static int intlist_read(RangeCoder *c, uint8_t *state, int *buf, int entries, int base_2_part)
Definition: sonic.c:172
for(j=16;j >0;--j)
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])
Definition: sonic.c:92
int * window
Definition: sonic.c:66
static uint8_t tmp[11]
Definition: aes_ctr.c:26