Go to the documentation of this file.
72 bytestream_put_byte (&bs, 0x1);
76 bytestream_put_le16 (&bs, 0x0);
77 bytestream_put_byte (&bs, 0x0);
82 int tmp = 0x0, extended_toc = 0;
86 { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 17, 0, 21, 25, 29 } },
87 { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 18, 0, 22, 26, 30 } },
88 { { 1, 5, 9, 0, 0 }, { 0, 0, 0, 13, 15 }, { 19, 0, 23, 27, 31 } },
89 { { 2, 6, 10, 0, 0 }, { 0, 0, 0, 14, 16 }, { 20, 0, 24, 28, 32 } },
90 { { 3, 7, 11, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } },
91 { { 4, 8, 12, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } },
93 int cfg = toc_cfg[
s->packet.framesize][
s->packet.mode][
s->packet.bandwidth];
97 if (
s->packet.frames == 2) {
98 if (
s->frame[0].framebits ==
s->frame[1].framebits) {
104 }
else if (
s->packet.frames > 2) {
108 tmp |= (
s->channels > 1) << 2;
109 tmp |= (cfg - 1) << 3;
112 for (
int i = 0;
i < (
s->packet.frames - 1);
i++)
113 *fsize_needed |= (
s->frame[
i].framebits !=
s->frame[
i + 1].framebits);
114 tmp = (*fsize_needed) << 7;
116 tmp |=
s->packet.frames;
119 *
size = 1 + extended_toc;
126 const int subframesize =
s->avctx->frame_size;
131 for (
int ch = 0; ch <
f->channels; ch++) {
140 for (
int sf = 0; sf < subframes; sf++) {
141 if (sf != (subframes - 1))
146 for (
int ch = 0; ch <
f->channels; ch++) {
152 memcpy(&
b->samples[sf*subframesize],
input,
len);
157 if (sf != (subframes - 1))
165 const int subframesize =
s->avctx->frame_size;
170 for (
int ch = 0; ch <
f->channels; ch++) {
172 float m =
b->emph_coeff;
182 for (
int sf = 0; sf < subframes; sf++) {
183 for (
int ch = 0; ch <
f->channels; ch++) {
185 float m =
b->emph_coeff;
186 for (
int i = 0;
i < subframesize;
i++) {
187 float sample =
b->samples[sf*subframesize +
i];
188 b->samples[sf*subframesize +
i] =
sample - m;
191 if (sf != (subframes - 1))
200 float *
win =
s->scratch, *
temp =
s->scratch + 1920;
203 for (
int ch = 0; ch <
f->channels; ch++) {
205 float *
src1 =
b->overlap;
206 for (
int t = 0; t <
f->blocks; t++) {
212 s->tx_fn[0](
s->tx[0],
b->coeffs + t,
win,
sizeof(
float)*
f->blocks);
218 memset(
win, 0, wlen*
sizeof(
float));
219 for (
int ch = 0; ch <
f->channels; ch++) {
230 s->dsp->vector_fmul_reverse(
temp,
b->samples + rwin,
234 s->tx_fn[
f->size](
s->tx[
f->size],
b->coeffs,
win,
sizeof(
float));
238 for (
int ch = 0; ch <
f->channels; ch++) {
244 float *coeffs = &
block->coeffs[band_offset];
246 for (
int j = 0; j < band_size; j++)
247 ener += coeffs[j]*coeffs[j];
250 ener = 1.0f/
block->lin_energy[
i];
252 for (
int j = 0; j < band_size; j++)
265 int tf_select = 0,
diff = 0, tf_changed = 0, tf_select_needed;
266 int bits =
f->transient ? 2 : 4;
270 for (
int i =
f->start_band; i < f->end_band;
i++) {
272 const int tbit = (
diff ^ 1) ==
f->tf_change[
i];
277 bits =
f->transient ? 4 : 5;
283 tf_select =
f->tf_select;
286 for (
int i =
f->start_band; i < f->end_band;
i++)
292 float gain =
f->pf_gain;
293 int txval, octave =
f->pf_octave,
period =
f->pf_period, tapset =
f->pf_tapset;
300 txval =
FFMIN(octave, 6);
304 txval =
av_clip(
period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
306 period = txval + (16 << octave) - 1;
308 txval =
FFMIN(((
int)(gain / 0.09375
f)) - 1, 7);
310 gain = 0.09375f * (txval + 1);
317 for (
int i = 0;
i < 2;
i++) {
330 float alpha, beta, prev[2] = { 0, 0 };
341 beta = 1.0f - (4915.0f/32768.0f);
347 for (
int i =
f->start_band; i < f->end_band;
i++) {
348 for (
int ch = 0; ch <
f->channels; ch++) {
351 const float last =
FFMAX(-9.0
f, last_energy[ch][
i]);
356 }
else if (
left >= 2) {
359 }
else if (
left >= 1) {
365 prev[ch] += beta * q_en;
373 uint32_t inter, intra;
392 for (
int i =
f->start_band; i < f->end_band;
i++) {
393 if (!
f->fine_bits[
i])
395 for (
int ch = 0; ch <
f->channels; ch++) {
397 int quant, lim = (1 <<
f->fine_bits[
i]);
401 offset = 0.5f - ((
quant + 0.5f) * (1 << (14 -
f->fine_bits[
i])) / 16384.0
f);
409 for (
int priority = 0; priority < 2; priority++) {
410 for (
int i =
f->start_band; i < f->end_band && (
f->framebits -
opus_rc_tell(rc)) >=
f->channels;
i++) {
413 for (
int ch = 0; ch <
f->channels; ch++) {
415 const float err =
block->error_energy[
i];
416 const float offset = 0.5f * (1 << (14 -
f->fine_bits[
i] - 1)) / 16384.0f;
435 if (
f->framebits >= 16)
437 for (
int ch = 0; ch <
s->channels; ch++)
438 memset(
s->last_quantized_energy[ch], 0.0f,
sizeof(
float)*
CELT_MAX_BANDS);
477 if (
f->anticollapse_needed)
483 for (
int ch = 0; ch <
f->channels; ch++) {
486 s->last_quantized_energy[ch][
i] =
block->energy[
i] +
block->error_energy[
i];
494 return 1 + (v >= 252);
506 for (
int i = 0;
i <
s->packet.frames - 1;
i++) {
508 s->frame[
i].framebits >> 3);
513 for (
int i = 0;
i <
s->packet.frames;
i++) {
515 s->frame[
i].framebits >> 3);
516 offset +=
s->frame[
i].framebits >> 3;
529 f->format =
s->avctx->sample_fmt;
530 f->nb_samples =
s->avctx->frame_size;
540 for (
int i = 0;
i <
s->channels;
i++) {
542 memset(
f->extended_data[
i], 0,
bps*
f->nb_samples);
559 if (!
s->afq.remaining_samples || !avctx->
frame_num)
571 int pad_empty =
s->packet.frames*(
frame_size/
s->avctx->frame_size) -
s->bufqueue.available + 1;
576 for (
int i = 0;
i < pad_empty;
i++) {
584 for (
int i = 0;
i <
s->packet.frames;
i++) {
586 alloc_size +=
s->frame[
i].framebits >> 3;
590 alloc_size += 2 +
s->packet.frames*2;
652 avctx->
bit_rate = coupled*(96000) + (
s->channels - coupled*2)*(48000);
655 av_log(avctx,
AV_LOG_ERROR,
"Unsupported bitrate %"PRId64
" kbps, clipping to %"PRId64
" kbps\n",
656 avctx->
bit_rate/1000, clipped_rate/1000);
683 for (
int ch = 0; ch <
s->channels; ch++)
684 memset(
s->last_quantized_energy[ch], 0.0f,
sizeof(
float)*
CELT_MAX_BANDS);
695 max_frames =
ceilf(
FFMIN(
s->options.max_delay_ms, 120.0f)/2.5f);
703 for (
int i = 0;
i < max_frames;
i++) {
704 s->frame[
i].dsp =
s->dsp;
705 s->frame[
i].avctx =
s->avctx;
706 s->frame[
i].seed = 0;
707 s->frame[
i].pvq =
s->pvq;
708 s->frame[
i].apply_phase_inv =
s->options.apply_phase_inv;
709 s->frame[
i].block[0].emph_coeff =
s->frame[
i].block[1].emph_coeff = 0.0f;
715 #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
717 {
"opus_delay",
"Maximum delay in milliseconds", offsetof(
OpusEncContext,
options.max_delay_ms),
AV_OPT_TYPE_FLOAT, { .dbl =
OPUS_MAX_LOOKAHEAD }, 2.5f,
OPUS_MAX_LOOKAHEAD,
OPUSENC_FLAGS, .unit =
"max_delay_ms" },
718 {
"apply_phase_inv",
"Apply intensity stereo phase inversion", offsetof(
OpusEncContext,
options.apply_phase_inv),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
OPUSENC_FLAGS, .unit =
"apply_phase_inv" },
731 {
"compression_level",
"10" },
749 .p.supported_samplerates = (
const int []){ 48000, 0 },
const float ff_celt_window_padded[136]
int frame_size
Number of samples per channel in an audio frame.
@ AV_SAMPLE_FMT_FLTP
float, planar
static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
static av_cold int opus_encode_init(AVCodecContext *avctx)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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
static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
#define AV_CHANNEL_LAYOUT_STEREO
int sample_rate
samples per second
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define CELT_ENERGY_SILENCE
static const AVOption opusenc_options[]
static av_always_inline uint32_t opus_rc_tell(const OpusRangeCoder *rc)
CELT: estimate bits of entropy that have thus far been consumed for the current CELT frame,...
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static const AVClass opusenc_class
This structure describes decoded (raw) audio or video data.
#define CELT_MAX_FINE_BITS
static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)
static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
void ff_opus_rc_enc_laplace(OpusRangeCoder *rc, int *value, uint32_t symbol, int decay)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
const float ff_opus_deemph_weights[]
int nb_channels
Number of channels in this layout.
static __device__ float ceilf(float a)
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
#define OPUS_RC_CHECKPOINT_SPAWN(rc)
static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)
Get the first buffer from the queue and remove it.
static float win(SuperEqualizerContext *s, float n, int N)
void ff_opus_rc_enc_init(OpusRangeCoder *rc)
void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f)
AVCodec p
The public AVCodec.
void ff_opus_rc_enc_end(OpusRangeCoder *rc, uint8_t *dst, int size)
AVChannelLayout ch_layout
Audio channel layout.
int initial_padding
Audio only.
int flags
AV_CODEC_FLAG_*.
#define OPUS_MAX_LOOKAHEAD
#define FF_CODEC_ENCODE_CB(func)
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
const uint16_t ff_celt_model_tapset[]
void ff_opus_psy_signal_eof(OpusPsyContext *s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static const uint8_t quant[64]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
const float ff_celt_postfilter_taps[3][3]
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
static __device__ float floor(float a)
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
#define OPUS_BLOCK_SIZE(x)
static av_cold int opus_encode_end(AVCodecContext *avctx)
#define CODEC_LONG_NAME(str)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
const int8_t ff_celt_tf_select[4][2][2][2]
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc, float last_energy[][CELT_MAX_BANDS])
const uint8_t ff_celt_freq_range[]
av_cold int ff_opus_psy_end(OpusPsyContext *s)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
int64_t bit_rate
the average bitrate
const char * av_default_item_name(void *ptr)
Return the context name.
static void ff_bufqueue_discard_all(struct FFBufQueue *queue)
Unref and remove all buffers from the queue.
static __device__ float sqrtf(float a)
#define CELT_POSTFILTER_MINPERIOD
void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)
const uint8_t ff_celt_coarse_energy_dist[4][2][42]
static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
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
static const FFCodecDefault opusenc_defaults[]
static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
const float ff_celt_beta_coef[]
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
const uint8_t ff_opus_default_coupled_streams[]
An AVChannelLayout holds information about the channel layout of audio data.
#define DECLARE_ALIGNED(n, t, v)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
static const float *const ff_celt_window
static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f, float last_energy[][CELT_MAX_BANDS], int intra)
const FFCodec ff_opus_encoder
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static void ff_bufqueue_add(void *log, struct FFBufQueue *queue, AVFrame *buf)
Add a buffer to the queue.
int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
int nb_samples
number of audio samples (per channel) described by this frame
static AVFrame * ff_bufqueue_peek(struct FFBufQueue *queue, unsigned index)
Get a buffer from the queue without altering it.
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f, int index)
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Structure holding the queue.
uint8_t ** extended_data
pointers to the data planes/channels.
AVSampleFormat
Audio sample formats.
const char * name
Name of the codec implementation.
static int write_opuslacing(uint8_t *dst, int v)
const uint16_t ff_celt_model_energy_small[]
static AVFrame * spawn_empty_frame(OpusEncContext *s)
static void opus_write_extradata(AVCodecContext *avctx)
AVTXContext * tx[CELT_BLOCK_NB]
void ff_opus_rc_enc_cdf(OpusRangeCoder *rc, int val, const uint16_t *cdf)
int64_t frame_num
Frame counter, set by libavcodec.
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
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
static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
#define AV_INPUT_BUFFER_PADDING_SIZE
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
main external API structure.
const float ff_celt_alpha_coef[]
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)
av_tx_fn tx_fn[CELT_BLOCK_NB]
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
const float ff_celt_mean_energy[]
#define OPUS_MAX_CHANNELS
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define AV_CHANNEL_LAYOUT_MONO
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static const int16_t alpha[]
This structure stores compressed data.
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)
CELT: write 0 - 31 bits to the rawbits buffer.
The exact code depends on how similar the blocks are and how related they are to the block
#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)
const uint8_t ff_celt_freq_bands[]
av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)
struct FFBufQueue bufqueue
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)
CELT: write a uniformly distributed integer.
#define OPUS_RC_CHECKPOINT_BITS(rc)