FFmpeg: libavcodec/sonic.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /