2 * Simple free lossless/lossy audio codec
3 * Copyright (c) 2004 Alex Beregszaszi
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include "bitstream.h"
25 * Simple free lossless/lossy audio codec
26 * Based on Paul Francis Harrison's Bonk (http://www.logarithmic.net/pfh/bonk)
27 * Written and designed by Alex Beregszaszi
30 * - CABAC put/get_symbol
31 * - independent quantizer for channels
32 * - >2 channels support
33 * - more decorrelation types
34 * - more tap_quant tests
35 * - selectable intlist writers/readers (bonk-style, golomb, cabac)
38 #define MAX_CHANNELS 2
44 typedef struct SonicContext
{
45 int lossless
, decorrelation
;
47 int num_taps
, downsampling
;
50 int channels
, samplerate
, block_align
, frame_size
;
54 int *coded_samples
[MAX_CHANNELS
];
64 int *predictor_state
[MAX_CHANNELS
];
67 #define LATTICE_SHIFT 10
68 #define SAMPLE_SHIFT 4
69 #define LATTICE_FACTOR (1 << LATTICE_SHIFT)
70 #define SAMPLE_FACTOR (1 << SAMPLE_SHIFT)
72 #define BASE_QUANT 0.6
73 #define RATE_VARIATION 3.0
75 static inline int divide(int a
, int b
)
78 return -( (-a
+ b
/2)/b
);
83 static inline int shift(int a
,int b
)
85 return (a
+(1<<(b
-1))) >> b
;
88 static inline int shift_down(int a
,int b
)
90 return (a
>>b
)+((a
<0)?1:0);
94 static inline int intlist_write(PutBitContext
*pb
, int *buf
, int entries
, int base_2_part
)
98 for (i
= 0; i
< entries
; i
++)
99 set_se_golomb(pb
, buf
[i
]);
104 static inline int intlist_read(GetBitContext
*gb
, int *buf
, int entries
, int base_2_part
)
108 for (i
= 0; i
< entries
; i
++)
109 buf
[i
] = get_se_golomb(gb
);
116 #define ADAPT_LEVEL 8
118 static int bits_to_store(uint64_t x
)
130 static void write_uint_max(PutBitContext
*pb
, unsigned int value
, unsigned int max
)
137 bits
= bits_to_store(max
);
139 for (i
= 0; i
< bits
-1; i
++)
140 put_bits(pb
, 1, value
& (1 << i
));
142 if ( (value
| (1 << (bits
-1))) <= max
)
143 put_bits(pb
, 1, value
& (1 << (bits
-1)));
146 static unsigned int read_uint_max(GetBitContext
*gb
, int max
)
148 int i
, bits
, value
= 0;
153 bits
= bits_to_store(max
);
155 for (i
= 0; i
< bits
-1; i
++)
159 if ( (value
| (1<<(bits
-1))) <= max
)
161 value
+= 1 << (bits
-1);
166 static int intlist_write(PutBitContext
*pb
, int *buf
, int entries
, int base_2_part
)
168 int i
, j
, x
= 0, low_bits
= 0, max
= 0;
169 int step
= 256, pos
= 0, dominant
= 0, any
= 0;
172 copy
= av_mallocz(4* entries
);
180 for (i
= 0; i
< entries
; i
++)
181 energy
+= abs(buf
[i
]);
183 low_bits
= bits_to_store(energy
/ (entries
* 2));
187 put_bits(pb
, 4, low_bits
);
190 for (i
= 0; i
< entries
; i
++)
192 put_bits(pb
, low_bits
, abs(buf
[i
]));
193 copy
[i
] = abs(buf
[i
]) >> low_bits
;
198 bits
= av_mallocz(4* entries
*max
);
205 for (i
= 0; i
<= max
; i
++)
207 for (j
= 0; j
< entries
; j
++)
209 bits
[x
++] = copy
[j
] > i
;
215 int steplet
= step
>> 8;
217 if (pos
+ steplet
> x
)
220 for (i
= 0; i
< steplet
; i
++)
221 if (bits
[i
+pos
] != dominant
)
224 put_bits(pb
, 1, any
);
229 step
+= step
/ ADAPT_LEVEL
;
235 while (((pos
+ interloper
) < x
) && (bits
[pos
+ interloper
] == dominant
))
239 write_uint_max(pb
, interloper
, (step
>> 8) - 1);
241 pos
+= interloper
+ 1;
242 step
-= step
/ ADAPT_LEVEL
;
248 dominant
= !dominant
;
253 for (i
= 0; i
< entries
; i
++)
255 put_bits(pb
, 1, buf
[i
] < 0);
263 static int intlist_read(GetBitContext
*gb
, int *buf
, int entries
, int base_2_part
)
265 int i
, low_bits
= 0, x
= 0;
266 int n_zeros
= 0, step
= 256, dominant
= 0;
267 int pos
= 0, level
= 0;
268 int *bits
= av_mallocz(4* entries
);
275 low_bits
= get_bits(gb
, 4);
278 for (i
= 0; i
< entries
; i
++)
279 buf
[i
] = get_bits(gb
, low_bits
);
282 // av_log(NULL, AV_LOG_INFO, "entries: %d, low bits: %d\n", entries, low_bits);
284 while (n_zeros
< entries
)
286 int steplet
= step
>> 8;
290 for (i
= 0; i
< steplet
; i
++)
291 bits
[x
++] = dominant
;
296 step
+= step
/ ADAPT_LEVEL
;
300 int actual_run
= read_uint_max(gb
, steplet
-1);
302 // av_log(NULL, AV_LOG_INFO, "actual run: %d\n", actual_run);
304 for (i
= 0; i
< actual_run
; i
++)
305 bits
[x
++] = dominant
;
307 bits
[x
++] = !dominant
;
310 n_zeros
+= actual_run
;
314 step
-= step
/ ADAPT_LEVEL
;
320 dominant
= !dominant
;
324 // reconstruct unsigned values
326 for (i
= 0; n_zeros
< entries
; i
++)
333 level
+= 1 << low_bits
;
336 if (buf
[pos
] >= level
)
343 buf
[pos
] += 1 << low_bits
;
352 for (i
= 0; i
< entries
; i
++)
353 if (buf
[i
] && get_bits1(gb
))
356 // av_log(NULL, AV_LOG_INFO, "zeros: %d pos: %d\n", n_zeros, pos);
362 static void predictor_init_state(int *k
, int *state
, int order
)
366 for (i
= order
-2; i
>= 0; i
--)
368 int j
, p
, x
= state
[i
];
370 for (j
= 0, p
= i
+1; p
< order
; j
++,p
++)
372 int tmp
= x
+ shift_down(k
[j
] * state
[p
], LATTICE_SHIFT
);
373 state
[p
] += shift_down(k
[j
]*x
, LATTICE_SHIFT
);
379 static int predictor_calc_error(int *k
, int *state
, int order
, int error
)
381 int i
, x
= error
- shift_down(k
[order
-1] * state
[order
-1], LATTICE_SHIFT
);
384 int *k_ptr
= &(k
[order
-2]),
385 *state_ptr
= &(state
[order
-2]);
386 for (i
= order
-2; i
>= 0; i
--, k_ptr
--, state_ptr
--)
388 int k_value
= *k_ptr
, state_value
= *state_ptr
;
389 x
-= shift_down(k_value
* state_value
, LATTICE_SHIFT
);
390 state_ptr
[1] = state_value
+ shift_down(k_value
* x
, LATTICE_SHIFT
);
393 for (i
= order
-2; i
>= 0; i
--)
395 x
-= shift_down(k
[i
] * state
[i
], LATTICE_SHIFT
);
396 state
[i
+1] = state
[i
] + shift_down(k
[i
] * x
, LATTICE_SHIFT
);
400 // don't drift too far, to avoid overflows
401 if (x
> (SAMPLE_FACTOR
<<16)) x
= (SAMPLE_FACTOR
<<16);
402 if (x
< -(SAMPLE_FACTOR
<<16)) x
= -(SAMPLE_FACTOR
<<16);
409 // Heavily modified Levinson-Durbin algorithm which
410 // copes better with quantization, and calculates the
411 // actual whitened result as it goes.
413 static void modified_levinson_durbin(int *window
, int window_entries
,
414 int *out
, int out_entries
, int channels
, int *tap_quant
)
417 int *state
= av_mallocz(4* window_entries
);
419 memcpy(state
, window
, 4* window_entries
);
421 for (i
= 0; i
< out_entries
; i
++)
423 int step
= (i
+1)*channels
, k
, j
;
424 double xx
= 0.0, xy
= 0.0;
426 int *x_ptr
= &(window
[step
]), *state_ptr
= &(state
[0]);
427 j
= window_entries
- step
;
428 for (;j
>=0;j
--,x_ptr
++,state_ptr
++)
430 double x_value
= *x_ptr
, state_value
= *state_ptr
;
431 xx
+= state_value
*state_value
;
432 xy
+= x_value
*state_value
;
435 for (j
= 0; j
<= (window_entries
- step
); j
++);
437 double stepval
= window
[step
+j
], stateval
= window
[j
];
438 // xx += (double)window[j]*(double)window[j];
439 // xy += (double)window[step+j]*(double)window[j];
440 xx
+= stateval
*stateval
;
441 xy
+= stepval
*stateval
;
447 k
= (int)(floor(-xy
/xx
* (double)LATTICE_FACTOR
/ (double)(tap_quant
[i
]) + 0.5));
449 if (k
> (LATTICE_FACTOR
/tap_quant
[i
]))
450 k
= LATTICE_FACTOR
/tap_quant
[i
];
451 if (-k
> (LATTICE_FACTOR
/tap_quant
[i
]))
452 k
= -(LATTICE_FACTOR
/tap_quant
[i
]);
458 x_ptr
= &(window
[step
]);
459 state_ptr
= &(state
[0]);
460 j
= window_entries
- step
;
461 for (;j
>=0;j
--,x_ptr
++,state_ptr
++)
463 int x_value
= *x_ptr
, state_value
= *state_ptr
;
464 *x_ptr
= x_value
+ shift_down(k
*state_value
,LATTICE_SHIFT
);
465 *state_ptr
= state_value
+ shift_down(k
*x_value
, LATTICE_SHIFT
);
468 for (j
=0; j
<= (window_entries
- step
); j
++)
470 int stepval
= window
[step
+j
], stateval
=state
[j
];
471 window
[step
+j
] += shift_down(k
* stateval
, LATTICE_SHIFT
);
472 state
[j
] += shift_down(k
* stepval
, LATTICE_SHIFT
);
480 static int samplerate_table
[] =
481 { 44100, 22050, 11025, 96000, 48000, 32000, 24000, 16000, 8000 };
483 #ifdef CONFIG_ENCODERS
485 static inline int code_samplerate(int samplerate
)
489 case 44100: return 0;
490 case 22050: return 1;
491 case 11025: return 2;
492 case 96000: return 3;
493 case 48000: return 4;
494 case 32000: return 5;
495 case 24000: return 6;
496 case 16000: return 7;
502 static int sonic_encode_init(AVCodecContext
*avctx
)
504 SonicContext
*s
= avctx
->priv_data
;
508 if (avctx
->channels
> MAX_CHANNELS
)
510 av_log(avctx
, AV_LOG_ERROR
, "Only mono and stereo streams are supported by now\n");
511 return -1; /* only stereo or mono for now */
514 if (avctx
->channels
== 2)
515 s
->decorrelation
= MID_SIDE
;
517 if (avctx
->codec
->id
== CODEC_ID_SONIC_LS
)
522 s
->quantization
= 0.0;
528 s
->quantization
= 1.0;
532 if ((s
->num_taps
< 32) || (s
->num_taps
> 1024) ||
533 ((s
->num_taps
>>5)<<5 != s
->num_taps
))
535 av_log(avctx
, AV_LOG_ERROR
, "Invalid number of taps\n");
540 s
->tap_quant
= av_mallocz(4* s
->num_taps
);
541 for (i
= 0; i
< s
->num_taps
; i
++)
542 s
->tap_quant
[i
] = (int)(sqrt(i
+1));
544 s
->channels
= avctx
->channels
;
545 s
->samplerate
= avctx
->sample_rate
;
547 s
->block_align
= (int)(2048.0*s
->samplerate
/44100)/s
->downsampling
;
548 s
->frame_size
= s
->channels
*s
->block_align
*s
->downsampling
;
550 s
->tail
= av_mallocz(4* s
->num_taps
*s
->channels
);
553 s
->tail_size
= s
->num_taps
*s
->channels
;
555 s
->predictor_k
= av_mallocz(4 * s
->num_taps
);
559 for (i
= 0; i
< s
->channels
; i
++)
561 s
->coded_samples
[i
] = av_mallocz(4* s
->block_align
);
562 if (!s
->coded_samples
[i
])
566 s
->int_samples
= av_mallocz(4* s
->frame_size
);
568 s
->window_size
= ((2*s
->tail_size
)+s
->frame_size
);
569 s
->window
= av_mallocz(4* s
->window_size
);
573 avctx
->extradata
= av_mallocz(16);
574 if (!avctx
->extradata
)
576 init_put_bits(&pb
, avctx
->extradata
, 16*8);
578 put_bits(&pb
, 2, version
); // version
581 put_bits(&pb
, 2, s
->channels
);
582 put_bits(&pb
, 4, code_samplerate(s
->samplerate
));
584 put_bits(&pb
, 1, s
->lossless
);
586 put_bits(&pb
, 3, SAMPLE_SHIFT
); // XXX FIXME: sample precision
587 put_bits(&pb
, 2, s
->decorrelation
);
588 put_bits(&pb
, 2, s
->downsampling
);
589 put_bits(&pb
, 5, (s
->num_taps
>> 5)-1); // 32..1024
590 put_bits(&pb
, 1, 0); // XXX FIXME: no custom tap quant table
593 avctx
->extradata_size
= put_bits_count(&pb
)/8;
595 av_log(avctx
, AV_LOG_INFO
, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
596 version
, s
->lossless
, s
->decorrelation
, s
->num_taps
, s
->block_align
, s
->frame_size
, s
->downsampling
);
598 avctx
->coded_frame
= avcodec_alloc_frame();
599 if (!avctx
->coded_frame
)
601 avctx
->coded_frame
->key_frame
= 1;
602 avctx
->frame_size
= s
->block_align
*s
->downsampling
;
607 static int sonic_encode_close(AVCodecContext
*avctx
)
609 SonicContext
*s
= avctx
->priv_data
;
612 av_freep(&avctx
->coded_frame
);
614 for (i
= 0; i
< s
->channels
; i
++)
615 av_free(s
->coded_samples
[i
]);
617 av_free(s
->predictor_k
);
619 av_free(s
->tap_quant
);
621 av_free(s
->int_samples
);
626 static int sonic_encode_frame(AVCodecContext
*avctx
,
627 uint8_t *buf
, int buf_size
, void *data
)
629 SonicContext
*s
= avctx
->priv_data
;
631 int i
, j
, ch
, quant
= 0, x
= 0;
632 short *samples
= data
;
634 init_put_bits(&pb
, buf
, buf_size
*8);
637 for (i
= 0; i
< s
->frame_size
; i
++)
638 s
->int_samples
[i
] = samples
[i
];
641 for (i
= 0; i
< s
->frame_size
; i
++)
642 s
->int_samples
[i
] = s
->int_samples
[i
] << SAMPLE_SHIFT
;
644 switch(s
->decorrelation
)
647 for (i
= 0; i
< s
->frame_size
; i
+= s
->channels
)
649 s
->int_samples
[i
] += s
->int_samples
[i
+1];
650 s
->int_samples
[i
+1] -= shift(s
->int_samples
[i
], 1);
654 for (i
= 0; i
< s
->frame_size
; i
+= s
->channels
)
655 s
->int_samples
[i
+1] -= s
->int_samples
[i
];
658 for (i
= 0; i
< s
->frame_size
; i
+= s
->channels
)
659 s
->int_samples
[i
] -= s
->int_samples
[i
+1];
663 memset(s
->window
, 0, 4* s
->window_size
);
665 for (i
= 0; i
< s
->tail_size
; i
++)
666 s
->window
[x
++] = s
->tail
[i
];
668 for (i
= 0; i
< s
->frame_size
; i
++)
669 s
->window
[x
++] = s
->int_samples
[i
];
671 for (i
= 0; i
< s
->tail_size
; i
++)
674 for (i
= 0; i
< s
->tail_size
; i
++)
675 s
->tail
[i
] = s
->int_samples
[s
->frame_size
- s
->tail_size
+ i
];
678 modified_levinson_durbin(s
->window
, s
->window_size
,
679 s
->predictor_k
, s
->num_taps
, s
->channels
, s
->tap_quant
);
680 if (intlist_write(&pb
, s
->predictor_k
, s
->num_taps
, 0) < 0)
683 for (ch
= 0; ch
< s
->channels
; ch
++)
686 for (i
= 0; i
< s
->block_align
; i
++)
689 for (j
= 0; j
< s
->downsampling
; j
++, x
+= s
->channels
)
691 s
->coded_samples
[ch
][i
] = sum
;
695 // simple rate control code
698 double energy1
= 0.0, energy2
= 0.0;
699 for (ch
= 0; ch
< s
->channels
; ch
++)
701 for (i
= 0; i
< s
->block_align
; i
++)
703 double sample
= s
->coded_samples
[ch
][i
];
704 energy2
+= sample
*sample
;
705 energy1
+= fabs(sample
);
709 energy2
= sqrt(energy2
/(s
->channels
*s
->block_align
));
710 energy1
= sqrt(2.0)*energy1
/(s
->channels
*s
->block_align
);
712 // increase bitrate when samples are like a gaussian distribution
713 // reduce bitrate when samples are like a two-tailed exponential distribution
715 if (energy2
> energy1
)
716 energy2
+= (energy2
-energy1
)*RATE_VARIATION
;
718 quant
= (int)(BASE_QUANT
*s
->quantization
*energy2
/SAMPLE_FACTOR
);
719 // av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2);
726 set_ue_golomb(&pb
, quant
);
728 quant
*= SAMPLE_FACTOR
;
731 // write out coded samples
732 for (ch
= 0; ch
< s
->channels
; ch
++)
735 for (i
= 0; i
< s
->block_align
; i
++)
736 s
->coded_samples
[ch
][i
] = divide(s
->coded_samples
[ch
][i
], quant
);
738 if (intlist_write(&pb
, s
->coded_samples
[ch
], s
->block_align
, 1) < 0)
742 // av_log(avctx, AV_LOG_DEBUG, "used bytes: %d\n", (put_bits_count(&pb)+7)/8);
745 return (put_bits_count(&pb
)+7)/8;
747 #endif //CONFIG_ENCODERS
749 static int sonic_decode_init(AVCodecContext
*avctx
)
751 SonicContext
*s
= avctx
->priv_data
;
755 s
->channels
= avctx
->channels
;
756 s
->samplerate
= avctx
->sample_rate
;
758 if (!avctx
->extradata
)
760 av_log(avctx
, AV_LOG_ERROR
, "No mandatory headers present\n");
764 init_get_bits(&gb
, avctx
->extradata
, avctx
->extradata_size
);
766 version
= get_bits(&gb
, 2);
769 av_log(avctx
, AV_LOG_ERROR
, "Unsupported Sonic version, please report\n");
775 s
->channels
= get_bits(&gb
, 2);
776 s
->samplerate
= samplerate_table
[get_bits(&gb
, 4)];
777 av_log(avctx
, AV_LOG_INFO
, "Sonicv2 chans: %d samprate: %d\n",
778 s
->channels
, s
->samplerate
);
781 if (s
->channels
> MAX_CHANNELS
)
783 av_log(avctx
, AV_LOG_ERROR
, "Only mono and stereo streams are supported by now\n");
787 s
->lossless
= get_bits1(&gb
);
789 skip_bits(&gb
, 3); // XXX FIXME
790 s
->decorrelation
= get_bits(&gb
, 2);
792 s
->downsampling
= get_bits(&gb
, 2);
793 s
->num_taps
= (get_bits(&gb
, 5)+1)<<5;
794 if (get_bits1(&gb
)) // XXX FIXME
795 av_log(avctx
, AV_LOG_INFO
, "Custom quant table\n");
797 s
->block_align
= (int)(2048.0*(s
->samplerate
/44100))/s
->downsampling
;
798 s
->frame_size
= s
->channels
*s
->block_align
*s
->downsampling
;
799 // avctx->frame_size = s->block_align;
801 av_log(avctx
, AV_LOG_INFO
, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
802 version
, s
->lossless
, s
->decorrelation
, s
->num_taps
, s
->block_align
, s
->frame_size
, s
->downsampling
);
805 s
->tap_quant
= av_mallocz(4* s
->num_taps
);
806 for (i
= 0; i
< s
->num_taps
; i
++)
807 s
->tap_quant
[i
] = (int)(sqrt(i
+1));
809 s
->predictor_k
= av_mallocz(4* s
->num_taps
);
811 for (i
= 0; i
< s
->channels
; i
++)
813 s
->predictor_state
[i
] = av_mallocz(4* s
->num_taps
);
814 if (!s
->predictor_state
[i
])
818 for (i
= 0; i
< s
->channels
; i
++)
820 s
->coded_samples
[i
] = av_mallocz(4* s
->block_align
);
821 if (!s
->coded_samples
[i
])
824 s
->int_samples
= av_mallocz(4* s
->frame_size
);
829 static int sonic_decode_close(AVCodecContext
*avctx
)
831 SonicContext
*s
= avctx
->priv_data
;
834 av_free(s
->int_samples
);
835 av_free(s
->tap_quant
);
836 av_free(s
->predictor_k
);
838 for (i
= 0; i
< s
->channels
; i
++)
840 av_free(s
->predictor_state
[i
]);
841 av_free(s
->coded_samples
[i
]);
847 static int sonic_decode_frame(AVCodecContext
*avctx
,
848 void *data
, int *data_size
,
849 uint8_t *buf
, int buf_size
)
851 SonicContext
*s
= avctx
->priv_data
;
854 short *samples
= data
;
856 if (buf_size
== 0) return 0;
858 // av_log(NULL, AV_LOG_INFO, "buf_size: %d\n", buf_size);
860 init_get_bits(&gb
, buf
, buf_size
*8);
862 intlist_read(&gb
, s
->predictor_k
, s
->num_taps
, 0);
865 for (i
= 0; i
< s
->num_taps
; i
++)
866 s
->predictor_k
[i
] *= s
->tap_quant
[i
];
871 quant
= get_ue_golomb(&gb
) * SAMPLE_FACTOR
;
873 // av_log(NULL, AV_LOG_INFO, "quant: %d\n", quant);
875 for (ch
= 0; ch
< s
->channels
; ch
++)
879 predictor_init_state(s
->predictor_k
, s
->predictor_state
[ch
], s
->num_taps
);
881 intlist_read(&gb
, s
->coded_samples
[ch
], s
->block_align
, 1);
883 for (i
= 0; i
< s
->block_align
; i
++)
885 for (j
= 0; j
< s
->downsampling
- 1; j
++)
887 s
->int_samples
[x
] = predictor_calc_error(s
->predictor_k
, s
->predictor_state
[ch
], s
->num_taps
, 0);
891 s
->int_samples
[x
] = predictor_calc_error(s
->predictor_k
, s
->predictor_state
[ch
], s
->num_taps
, s
->coded_samples
[ch
][i
] * quant
);
895 for (i
= 0; i
< s
->num_taps
; i
++)
896 s
->predictor_state
[ch
][i
] = s
->int_samples
[s
->frame_size
- s
->channels
+ ch
- i
*s
->channels
];
899 switch(s
->decorrelation
)
902 for (i
= 0; i
< s
->frame_size
; i
+= s
->channels
)
904 s
->int_samples
[i
+1] += shift(s
->int_samples
[i
], 1);
905 s
->int_samples
[i
] -= s
->int_samples
[i
+1];
909 for (i
= 0; i
< s
->frame_size
; i
+= s
->channels
)
910 s
->int_samples
[i
+1] += s
->int_samples
[i
];
913 for (i
= 0; i
< s
->frame_size
; i
+= s
->channels
)
914 s
->int_samples
[i
] += s
->int_samples
[i
+1];
919 for (i
= 0; i
< s
->frame_size
; i
++)
920 s
->int_samples
[i
] = shift(s
->int_samples
[i
], SAMPLE_SHIFT
);
923 for (i
= 0; i
< s
->frame_size
; i
++)
925 if (s
->int_samples
[i
] > 32767)
927 else if (s
->int_samples
[i
] < -32768)
930 samples
[i
] = s
->int_samples
[i
];
935 *data_size
= s
->frame_size
* 2;
937 return (get_bits_count(&gb
)+7)/8;
940 #ifdef CONFIG_ENCODERS
941 AVCodec sonic_encoder
= {
945 sizeof(SonicContext
),
952 AVCodec sonic_ls_encoder
= {
956 sizeof(SonicContext
),
964 #ifdef CONFIG_DECODERS
965 AVCodec sonic_decoder
= {
969 sizeof(SonicContext
),