66 bytestream_put_byte (&bs, 0x1);
67 bytestream_put_byte (&bs, avctx->
channels);
70 bytestream_put_le16 (&bs, 0x0);
71 bytestream_put_byte (&bs, 0x0);
76 int tmp = 0x0, extended_toc = 0;
80 { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 17, 0, 21, 25, 29 } },
81 { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 18, 0, 22, 26, 30 } },
82 { { 1, 5, 9, 0, 0 }, { 0, 0, 0, 13, 15 }, { 19, 0, 23, 27, 31 } },
83 { { 2, 6, 10, 0, 0 }, { 0, 0, 0, 14, 16 }, { 20, 0, 24, 28, 32 } },
84 { { 3, 7, 11, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } },
85 { { 4, 8, 12, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } },
103 tmp |= (cfg - 1) << 3;
108 tmp = (*fsize_needed) << 7;
113 *size = 1 + extended_toc;
125 for (
int ch = 0; ch < f->
channels; ch++) {
134 for (
int sf = 0; sf < subframes; sf++) {
135 if (sf != (subframes - 1))
140 for (
int ch = 0; ch < f->
channels; ch++) {
146 memcpy(&b->
samples[sf*subframesize], input, len);
151 if (sf != (subframes - 1))
163 for (
int ch = 0; ch < f->
channels; ch++) {
175 for (
int sf = 0; sf < subframes; sf++) {
176 for (
int ch = 0; ch < f->
channels; ch++) {
179 for (
int i = 0;
i < subframesize;
i++) {
181 b->
samples[sf*subframesize +
i] = sample - m;
184 if (sf != (subframes - 1))
196 for (
int ch = 0; ch < f->
channels; ch++) {
199 for (
int t = 0; t < f->
blocks; t++) {
211 memset(win, 0, wlen*
sizeof(
float));
212 for (
int ch = 0; ch < f->
channels; ch++) {
217 memcpy(win + lap_dst,
temp, CELT_OVERLAP*
sizeof(
float));
220 memcpy(&win[lap_dst + CELT_OVERLAP], b->
samples, rwin*
sizeof(
float));
225 memcpy(win + lap_dst + blk_len,
temp, CELT_OVERLAP*
sizeof(
float));
231 for (
int ch = 0; ch < f->
channels; ch++) {
237 float *coeffs = &block->
coeffs[band_offset];
239 for (
int j = 0; j < band_size; j++)
240 ener += coeffs[j]*coeffs[j];
245 for (
int j = 0; j < band_size; j++)
258 int tf_select = 0,
diff = 0, tf_changed = 0, tf_select_needed;
293 txval =
FFMIN(octave, 6);
297 txval =
av_clip(
period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
299 period = txval + (16 << octave) - 1;
301 txval =
FFMIN(((
int)(gain / 0.09375f)) - 1, 7);
303 gain = 0.09375f * (txval + 1);
310 for (
int i = 0;
i < 2;
i++) {
315 block->
pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
316 block->
pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
323 float alpha, beta, prev[2] = { 0, 0 };
334 beta = 1.0f - (4915.0f/32768.0f);
341 for (
int ch = 0; ch < f->
channels; ch++) {
344 const float last =
FFMAX(-9.0f, last_energy[ch][
i]);
349 }
else if (left >= 2) {
352 }
else if (left >= 1) {
358 prev[ch] += beta * q_en;
366 uint32_t inter, intra;
388 for (
int ch = 0; ch < f->
channels; ch++) {
394 offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->
fine_bits[
i])) / 16384.0f);
402 for (
int priority = 0; priority < 2; priority++) {
406 for (
int ch = 0; ch < f->
channels; ch++) {
410 const int sign =
FFABS(err + offset) <
FFABS(err - offset);
430 for (
int ch = 0; ch < s->
channels; ch++)
476 for (
int ch = 0; ch < f->
channels; ch++) {
486 dst[1] = v - dst[0] >> 2;
487 return 1 + (v >= 252);
564 for (
int i = 0;
i < pad_empty;
i++) {
644 av_log(avctx,
AV_LOG_ERROR,
"Unsupported bitrate %"PRId64
" kbps, clipping to %"PRId64
" kbps\n",
645 avctx->
bit_rate/1000, clipped_rate/1000);
670 for (
int ch = 0; ch < s->
channels; ch++)
690 for (
int i = 0;
i < max_frames;
i++) {
702 #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM 704 {
"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,
"max_delay_ms" },
705 {
"apply_phase_inv",
"Apply intensity stereo phase inversion", offsetof(
OpusEncContext,
options.
apply_phase_inv),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
OPUSENC_FLAGS,
"apply_phase_inv" },
718 {
"compression_level",
"10" },
735 .supported_samplerates = (
const int []){ 48000, 0 },
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)
Get the first buffer from the queue and remove it.
void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
static av_cold int opus_encode_init(AVCodecContext *avctx)
enum OpusBandwidth bandwidth
#define OPUS_RC_CHECKPOINT_SPAWN(rc)
This structure describes decoded (raw) audio or video data.
static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)
static const AVCodecDefault opusenc_defaults[]
static const AVOption opusenc_options[]
const uint8_t ff_celt_coarse_energy_dist[4][2][42]
static AVFrame * spawn_empty_frame(OpusEncContext *s)
void ff_opus_rc_enc_init(OpusRangeCoder *rc)
float coeffs[CELT_MAX_FRAME_SIZE]
int64_t bit_rate
the average bitrate
#define LIBAVUTIL_VERSION_INT
static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
static float win(SuperEqualizerContext *s, float n, int N)
static av_cold int init(AVCodecContext *avctx)
const uint8_t ff_celt_freq_bands[]
const char * av_default_item_name(void *ptr)
Return the context name.
static av_cold int opus_encode_end(AVCodecContext *avctx)
static __device__ float ceilf(float a)
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)
int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
const float ff_celt_postfilter_taps[3][3]
#define AV_CH_LAYOUT_STEREO
void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)
CELT: write a uniformly distributed integer.
Structure holding the queue.
static __device__ float floor(float a)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#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 fine_priority[CELT_MAX_BANDS]
static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f, float last_energy[][CELT_MAX_BANDS], int intra)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
enum AVSampleFormat sample_fmt
audio sample format
The exact code depends on how similar the blocks are and how related they are to the block
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
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
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
void(* mdct)(struct MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
#define OPUS_MAX_LOOKAHEAD
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
av_cold int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale)
#define CELT_POSTFILTER_MINPERIOD
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
float lin_energy[CELT_MAX_BANDS]
static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
float samples[FFALIGN(CELT_MAX_FRAME_SIZE, 16)]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
#define OPUS_BLOCK_SIZE(x)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int initial_padding
Audio only.
#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)
int flags
AV_CODEC_FLAG_*.
av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)
int tf_change[CELT_MAX_BANDS]
const char * name
Name of the codec implementation.
static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
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
int fine_bits[CELT_MAX_BANDS]
uint64_t channel_layout
Audio channel layout.
uint64_t channel_layout
Channel layout of the audio data.
const int8_t ff_celt_tf_select[4][2][2][2]
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
#define OPUS_RC_CHECKPOINT_BITS(rc)
MDCT15Context * mdct[CELT_BLOCK_NB]
static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
float error_energy[CELT_MAX_BANDS]
static void ff_bufqueue_discard_all(struct FFBufQueue *queue)
Unref and remove all buffers from the queue.
const uint8_t ff_celt_freq_range[]
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
const uint8_t ff_opus_default_coupled_streams[]
void ff_opus_rc_enc_cdf(OpusRangeCoder *rc, int val, const uint16_t *cdf)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
int frame_size
Number of samples per channel in an audio frame.
struct FFBufQueue bufqueue
static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f, int index)
AVSampleFormat
Audio sample formats.
unsigned short available
number of available buffers
int sample_rate
samples per second
static const int16_t alpha[]
main external API structure.
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...
#define CELT_MAX_FINE_BITS
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
void ff_opus_rc_enc_laplace(OpusRangeCoder *rc, int *value, uint32_t symbol, int decay)
static int write_opuslacing(uint8_t *dst, int v)
Describe the class of an AVClass context structure.
void ff_opus_psy_signal_eof(OpusPsyContext *s)
#define CELT_ENERGY_SILENCE
static void opus_write_extradata(AVCodecContext *avctx)
Recommmends skipping the specified number of samples.
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
av_cold int ff_opus_psy_end(OpusPsyContext *s)
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
static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc, float last_energy[][CELT_MAX_BANDS])
void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc)
const uint16_t ff_celt_model_energy_small[]
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
#define OPUS_MAX_CHANNELS
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
float energy[CELT_MAX_BANDS]
static const AVClass opusenc_class
static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
const float ff_celt_beta_coef[]
void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)
CELT: write 0 - 31 bits to the rawbits buffer.
common internal api header.
void ff_opus_rc_enc_end(OpusRangeCoder *rc, uint8_t *dst, int size)
const float *const ff_celt_window
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
av_cold void ff_mdct15_uninit(MDCT15Context **ps)
float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int channels
number of audio channels
const float ff_celt_alpha_coef[]
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
const float ff_celt_mean_energy[]
static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
int frame_number
Frame counter, set by libavcodec.
static void ff_bufqueue_add(void *log, struct FFBufQueue *queue, AVFrame *buf)
Add a buffer to the queue.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
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
uint8_t ** extended_data
pointers to the data planes/channels.
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
const uint16_t ff_celt_model_tapset[]
static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
int nb_samples
number of audio samples (per channel) described by this frame
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
float overlap[FFALIGN(CELT_OVERLAP, 16)]
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
static AVFrame * ff_bufqueue_peek(struct FFBufQueue *queue, unsigned index)
Get a buffer from the queue without altering it.
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...