43 #define MAX_CHANNELS 2 74 #define LATTICE_SHIFT 10 75 #define SAMPLE_SHIFT 4 76 #define LATTICE_FACTOR (1 << LATTICE_SHIFT) 77 #define SAMPLE_FACTOR (1 << SAMPLE_SHIFT) 79 #define BASE_QUANT 0.6 80 #define RATE_VARIATION 3.0 84 return (a+(1<<(b-1))) >>
b;
95 #define put_rac(C,S,B) \ 99 rc_stat2[(S)-state][B]++;\ 114 for(i=e-1; i>=0; i--){
115 put_rac(c, state+22+i, (a>>i)&1);
119 put_rac(c, state+11 + e, v < 0);
126 for(i=e-1; i>=0; i--){
131 put_rac(c, state+11 + 10, v < 0);
153 for(i=e-1; i>=0; i--){
167 for (i = 0; i < entries; i++)
177 for (i = 0; i < entries; i++)
187 for (i = 0; i < entries; i++)
197 for (i = 0; i < entries; i++)
205 #define ADAPT_LEVEL 8 207 static int bits_to_store(uint64_t x)
226 bits = bits_to_store(max);
228 for (i = 0; i < bits-1; i++)
231 if ( (
value | (1 << (bits-1))) <= max)
242 bits = bits_to_store(max);
244 for (i = 0; i < bits-1; i++)
248 if ( (value | (1<<(bits-1))) <= max)
250 value += 1 << (bits-1);
257 int i, j, x = 0, low_bits = 0,
max = 0;
258 int step = 256,
pos = 0, dominant = 0, any = 0;
261 copy =
av_calloc(entries,
sizeof(*copy));
269 for (i = 0; i < entries; i++)
270 energy +=
abs(buf[i]);
272 low_bits = bits_to_store(energy / (entries * 2));
279 for (i = 0; i < entries; i++)
282 copy[
i] =
abs(buf[i]) >> low_bits;
294 for (i = 0; i <=
max; i++)
296 for (j = 0; j < entries; j++)
298 bits[x++] = copy[j] >
i;
304 int steplet = step >> 8;
306 if (
pos + steplet > x)
309 for (i = 0; i < steplet; i++)
310 if (bits[i+pos] != dominant)
318 step += step / ADAPT_LEVEL;
324 while (((pos + interloper) < x) && (bits[pos + interloper] == dominant))
328 write_uint_max(pb, interloper, (step >> 8) - 1);
330 pos += interloper + 1;
331 step -= step / ADAPT_LEVEL;
337 dominant = !dominant;
342 for (i = 0; i < entries; i++)
354 int i, low_bits = 0, x = 0;
355 int n_zeros = 0,
step = 256, dominant = 0;
367 for (i = 0; i < entries; i++)
373 while (n_zeros < entries)
375 int steplet =
step >> 8;
379 for (i = 0; i < steplet; i++)
380 bits[x++] = dominant;
389 int actual_run = read_uint_max(gb, steplet-1);
393 for (i = 0; i < actual_run; i++)
394 bits[x++] = dominant;
396 bits[x++] = !dominant;
399 n_zeros += actual_run;
409 dominant = !dominant;
415 for (i = 0; n_zeros < entries; i++)
422 level += 1 << low_bits;
425 if (buf[pos] >=
level)
432 buf[
pos] += 1 << low_bits;
441 for (i = 0; i < entries; i++)
455 for (i = order-2; i >= 0; i--)
457 int j, p, x = state[
i];
459 for (j = 0, p = i+1; p < order; j++,p++)
473 int *k_ptr = &(k[order-2]),
474 *state_ptr = &(state[order-2]);
475 for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--)
477 int k_value = *k_ptr, state_value = *state_ptr;
482 for (i = order-2; i >= 0; i--)
498 #if CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER 503 static void modified_levinson_durbin(
int *
window,
int window_entries,
509 memcpy(state,
window, window_entries *
sizeof(*state));
511 for (i = 0; i < out_entries; i++)
514 double xx = 0.0, xy = 0.0;
517 int *state_ptr = &(state[0]);
518 j = window_entries -
step;
519 for (;j>0;j--,x_ptr++,state_ptr++)
521 double x_value = *x_ptr;
522 double state_value = *state_ptr;
523 xx += state_value*state_value;
524 xy += x_value*state_value;
527 for (j = 0; j <= (window_entries -
step); j++);
529 double stepval =
window[step+j];
530 double stateval =
window[j];
533 xx += stateval*stateval;
534 xy += stepval*stateval;
552 state_ptr = &(state[0]);
553 j = window_entries -
step;
554 for (;j>0;j--,x_ptr++,state_ptr++)
556 int x_value = *x_ptr;
557 int state_value = *state_ptr;
562 for (j=0; j <= (window_entries -
step); j++)
564 int stepval =
window[step+j];
565 int stateval=state[j];
573 static inline int code_samplerate(
int samplerate)
577 case 44100:
return 0;
578 case 22050:
return 1;
579 case 11025:
return 2;
580 case 96000:
return 3;
581 case 48000:
return 4;
582 case 32000:
return 5;
583 case 24000:
return 6;
584 case 16000:
return 7;
692 av_log(avctx,
AV_LOG_INFO,
"Sonic: ver: %d.%d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
719 int i, j, ch,
quant = 0, x = 0;
721 const short *
samples = (
const int16_t*)frame->
data[0];
779 for (ch = 0; ch < s->
channels; ch++)
794 double energy1 = 0.0, energy2 = 0.0;
795 for (ch = 0; ch < s->
channels; ch++)
801 energy1 +=
fabs(sample);
811 if (energy2 > energy1)
817 quant =
av_clip(quant, 1, 65534);
825 for (ch = 0; ch < s->
channels; ch++)
844 #if CONFIG_SONIC_DECODER 845 static const int samplerate_table[] =
846 { 44100, 22050, 11025, 96000, 48000, 32000, 24000, 16000, 8000 };
882 int sample_rate_index;
884 sample_rate_index =
get_bits(&gb, 4);
889 s->
samplerate = samplerate_table[sample_rate_index];
926 "number of taps times channels (%d * %d) larger than frame size %d\n",
931 av_log(avctx,
AV_LOG_INFO,
"Sonic: ver: %d.%d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
978 void *
data,
int *got_frame_ptr,
982 int buf_size = avpkt->
size;
990 if (buf_size == 0)
return 0;
995 samples = (int16_t *)frame->
data[0];
999 memset(state, 128,
sizeof(state));
1016 for (ch = 0; ch < s->
channels; ch++)
1081 .
init = sonic_decode_init,
1082 .close = sonic_decode_close,
1083 .
decode = sonic_decode_frame,
1089 #if CONFIG_SONIC_ENCODER 1096 .
init = sonic_encode_init,
1097 .encode2 = sonic_encode_frame,
1101 .close = sonic_encode_close,
1105 #if CONFIG_SONIC_LS_ENCODER 1112 .
init = sonic_encode_init,
1113 .encode2 = sonic_encode_frame,
1117 .close = sonic_encode_close,
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
const struct AVCodec * codec
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int shift(int a, int b)
static void copy(const float *p1, float *p2, const int length)
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
int * predictor_state[MAX_CHANNELS]
static av_cold int init(AVCodecContext *avctx)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
#define FF_ARRAY_ELEMS(a)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static void error(const char *err)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
static __device__ float floor(float a)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
AVCodec ff_sonic_ls_encoder
enum AVSampleFormat sample_fmt
audio sample format
static int get_rac(RangeCoder *c, uint8_t *const state)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
GLsizei GLboolean const GLfloat * value
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
bitstream reader API header.
#define ROUNDED_DIV(a, b)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static __device__ float fabs(float a)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
const char * name
Name of the codec implementation.
static int put_bits_count(PutBitContext *s)
static av_flatten int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int frame_size
Number of samples per channel in an audio frame.
#define AV_LOG_INFO
Standard information.
Libavcodec external API header.
static void set_se_golomb(PutBitContext *pb, int i)
write signed exp golomb code.
AVSampleFormat
Audio sample formats.
int sample_rate
samples per second
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
main external API structure.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size)
static int intlist_write(RangeCoder *c, uint8_t *state, int *buf, int entries, int base_2_part)
static void predictor_init_state(int *k, int *state, int order)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
int channels
number of audio channels
int * coded_samples[MAX_CHANNELS]
static int predictor_calc_error(int *k, int *state, int order, int error)
static enum AVSampleFormat sample_fmts[]
Filter the word “frame” indicates either a video frame or a group of audio samples
static int shift_down(int a, int b)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static int intlist_read(RangeCoder *c, uint8_t *state, int *buf, int entries, int base_2_part)
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])
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step