Go to the documentation of this file.
43 #define BITSTREAM_WRITER_LE
145 #define MAX_CHANNELS 2
146 #define MAX_CODEBOOK_DIM 8
148 #define MAX_FLOOR_CLASS_DIM 4
149 #define NUM_FLOOR_PARTITIONS 8
150 #define MAX_FLOOR_VALUES (MAX_FLOOR_CLASS_DIM*NUM_FLOOR_PARTITIONS+2)
152 #define RESIDUE_SIZE 1600
153 #define RESIDUE_PART_SIZE 32
154 #define NUM_RESIDUE_PARTITIONS (RESIDUE_SIZE/RESIDUE_PART_SIZE)
173 return dimensions *entries;
189 if (!
cb->dimensions || !
cb->pow2)
191 for (
i = 0;
i <
cb->nentries;
i++) {
195 for (j = 0; j <
cb->ndimensions; j++) {
198 off = (
i / div) % vals;
200 off =
i *
cb->ndimensions + j;
202 cb->dimensions[
i *
cb->ndimensions + j] = last +
cb->min +
cb->quantlist[off] *
cb->delta;
204 last =
cb->dimensions[
i *
cb->ndimensions + j];
205 cb->pow2[
i] +=
cb->dimensions[
i *
cb->ndimensions + j] *
cb->dimensions[
i *
cb->ndimensions + j];
224 for (j = 0; j < 8; j++)
225 if (rc->
books[
i][j] != -1)
230 assert(
cb->ndimensions >= 2);
233 for (j = 0; j <
cb->nentries; j++) {
237 a =
fabs(
cb->dimensions[j *
cb->ndimensions]);
240 a =
fabs(
cb->dimensions[j *
cb->ndimensions + 1]);
282 const uint8_t *clens, *
quant;
299 for (book = 0; book < venc->
ncodebooks; book++) {
311 if (!
cb->lens || !
cb->codewords)
322 for (
i = 0;
i < vals;
i++)
339 fc->partition_to_class =
av_malloc(
sizeof(
int) *
fc->partitions);
340 if (!
fc->partition_to_class)
343 for (
i = 0;
i <
fc->partitions;
i++) {
344 static const int a[] = {0, 1, 2, 2, 3, 3, 4, 4};
345 fc->partition_to_class[
i] =
a[
i];
346 fc->nclasses =
FFMAX(
fc->nclasses,
fc->partition_to_class[
i]);
352 for (
i = 0;
i <
fc->nclasses;
i++) {
358 books = (1 <<
c->subclass);
362 for (j = 0; j < books; j++)
369 for (
i = 0;
i <
fc->partitions;
i++)
370 fc->values +=
fc->classes[
fc->partition_to_class[
i]].dim;
376 fc->list[1].x = 1 <<
fc->rangebits;
377 for (
i = 2;
i <
fc->values;
i++) {
378 static const int a[] = {
379 93, 23,372, 6, 46,186,750, 14, 33, 65,
380 130,260,556, 3, 10, 18, 28, 39, 55, 79,
381 111,158,220,312,464,650,850
383 fc->list[
i].x =
a[
i - 2];
405 static const int8_t
a[10][8] = {
406 { -1, -1, -1, -1, -1, -1, -1, -1, },
407 { -1, -1, 16, -1, -1, -1, -1, -1, },
408 { -1, -1, 17, -1, -1, -1, -1, -1, },
409 { -1, -1, 18, -1, -1, -1, -1, -1, },
410 { -1, -1, 19, -1, -1, -1, -1, -1, },
411 { -1, -1, 20, -1, -1, -1, -1, -1, },
412 { -1, -1, 21, -1, -1, -1, -1, -1, },
413 { 22, 23, -1, -1, -1, -1, -1, -1, },
414 { 24, 25, -1, -1, -1, -1, -1, -1, },
415 { 26, 27, 28, -1, -1, -1, -1, -1, },
417 memcpy(rc->
books,
a,
sizeof a);
437 if (!
mc->floor || !
mc->residue)
439 for (
i = 0;
i <
mc->submaps;
i++) {
443 mc->coupling_steps = venc->
channels == 2 ? 1 : 0;
446 if (!
mc->magnitude || !
mc->angle)
448 if (
mc->coupling_steps) {
449 mc->magnitude[0] = 0;
485 mant = (
int)ldexp(frexp(
f, &
exp), 20);
491 res |= mant | (
exp << 21);
504 for (
i = 1;
i <
cb->nentries;
i++)
505 if (
cb->lens[
i] <
cb->lens[
i-1])
507 if (
i ==
cb->nentries)
512 int len =
cb->lens[0];
515 while (i < cb->nentries) {
517 for (j = 0; j+
i <
cb->nentries; j++)
526 for (
i = 0;
i <
cb->nentries;
i++)
529 if (
i !=
cb->nentries)
533 for (
i = 0;
i <
cb->nentries;
i++) {
568 for (
i = 0;
i <
fc->partitions;
i++)
571 for (
i = 0;
i <
fc->nclasses;
i++) {
577 if (
fc->classes[
i].subclass)
580 books = (1 <<
fc->classes[
i].subclass);
582 for (j = 0; j < books; j++)
589 for (
i = 2;
i <
fc->values;
i++)
607 for (j = 0; j < 8; j++)
619 for (j = 0; j < 8; j++)
620 if (rc->
books[
i][j] != -1)
630 int buffer_len = 50000;
638 for (
i = 0;
"vorbis"[
i];
i++)
652 buffer_len -= hlens[0];
658 for (
i = 0;
"vorbis"[
i];
i++)
666 buffer_len -= hlens[1];
672 for (
i = 0;
"vorbis"[
i];
i++)
706 if (
mc->coupling_steps) {
708 for (j = 0; j <
mc->coupling_steps; j++) {
717 for (j = 0; j < venc->
channels; j++)
720 for (j = 0; j <
mc->submaps; j++) {
741 len = hlens[0] + hlens[1] + hlens[2];
750 for (
i = 0;
i < 3;
i++) {
751 memcpy(p,
buffer + buffer_len, hlens[
i]);
753 buffer_len += hlens[
i];
762 int begin =
fc->list[
fc->list[
FFMAX(
i-1, 0)].sort].x;
763 int end =
fc->list[
fc->list[
FFMIN(
i+1,
fc->values - 1)].sort].x;
767 for (j = begin; j < end; j++)
768 average +=
fabs(coeffs[j]);
769 return average / (end - begin);
773 float *coeffs, uint16_t *posts,
int samples)
775 int range = 255 /
fc->multiplier + 1;
777 float tot_average = 0.0;
779 for (
i = 0;
i <
fc->values;
i++) {
781 tot_average += averages[
i];
783 tot_average /=
fc->values;
786 for (
i = 0;
i <
fc->values;
i++) {
787 int position =
fc->list[
fc->list[
i].sort].x;
788 float average = averages[
i];
791 average = sqrt(tot_average * average) * pow(1.25
f, position*0.005
f);
792 for (j = 0; j <
range - 1; j++)
795 posts[
fc->list[
i].sort] = j;
801 return y0 + (x - x0) * (y1 - y0) / (x1 - x0);
808 int range = 255 /
fc->multiplier + 1;
817 coded[0] = coded[1] = 1;
819 for (
i = 2;
i <
fc->values;
i++) {
821 posts[
fc->list[
i].low],
822 fc->list[
fc->list[
i].high].x,
823 posts[
fc->list[
i].high],
825 int highroom =
range - predicted;
826 int lowroom = predicted;
827 int room =
FFMIN(highroom, lowroom);
828 if (predicted == posts[
i]) {
832 if (!coded[
fc->list[
i].low ])
833 coded[
fc->list[
i].low ] = -1;
834 if (!coded[
fc->list[
i].high])
835 coded[
fc->list[
i].high] = -1;
837 if (posts[
i] > predicted) {
838 if (posts[
i] - predicted > room)
839 coded[
i] = posts[
i] - predicted + lowroom;
841 coded[
i] = (posts[
i] - predicted) << 1;
843 if (predicted - posts[
i] > room)
844 coded[
i] = predicted - posts[
i] + highroom - 1;
846 coded[
i] = ((predicted - posts[
i]) << 1) - 1;
851 for (
i = 0;
i <
fc->partitions;
i++) {
853 int k, cval = 0, csub = 1<<
c->subclass;
857 for (k = 0; k <
c->dim; k++) {
859 for (l = 0; l < csub; l++) {
861 if (
c->books[l] != -1)
864 if (coded[counter + k] < maxval)
869 cshift +=
c->subclass;
874 for (k = 0; k <
c->dim; k++) {
875 int book =
c->books[cval & (csub-1)];
876 int entry = coded[counter++];
877 cval >>=
c->subclass;
905 d -= vec[j] * num[j];
920 int pass,
i, j, p, k;
922 int partitions = (rc->
end - rc->
begin) / psize;
929 for (p = 0; p < partitions; p++) {
930 float max1 = 0.0, max2 = 0.0;
931 int s = rc->
begin + p * psize;
932 for (k =
s; k <
s + psize; k += 2) {
933 max1 =
FFMAX(max1,
fabs(coeffs[ k / real_ch]));
938 if (max1 < rc->maxes[
i][0] && max2 < rc->maxes[
i][1])
943 for (pass = 0; pass < 8; pass++) {
945 while (p < partitions) {
950 for (
i = 0;
i < classwords;
i++) {
952 entry += classes[j][p +
i];
957 for (
i = 0;
i < classwords && p < partitions;
i++, p++) {
959 int nbook = rc->
books[classes[j][p]][pass];
965 assert(rc->
type == 0 || rc->
type == 2);
986 *pv++ = coeffs[
a2 +
b2];
996 coeffs[
a1 +
b1] -= *pv++;
1014 const float *
win = venc->
win[1];
1055 for (ch = 0; ch <
channels; ch++) {
1057 memset(
f->extended_data[ch], 0,
bps *
f->nb_samples);
1072 for (ch = 0; ch < venc->
channels; ch++)
1076 for (ch = 0; ch < venc->
channels; ch++)
1079 for (sf = 0; sf < subframes; sf++) {
1082 for (ch = 0; ch < venc->
channels; ch++) {
1089 memcpy(save + sf*sf_size,
input,
len);
1101 int i,
ret, need_more;
1120 need_more =
frame && need_more;
1130 for (
i = 0;
i < frames_needed;
i++) {
1156 if (
mode->blockflag) {
1206 *got_packet_ptr = 1;
1278 av_log(avctx,
AV_LOG_ERROR,
"Current FFmpeg Vorbis encoder only supports 2 channels.\n");
int frame_size
Number of samples per channel in an audio frame.
static void put_codebook_header(PutBitContext *pb, vorbis_enc_codebook *cb)
@ AV_SAMPLE_FMT_FLTP
float, planar
#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 av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
static const struct @249 cvectors[]
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
static void put_residue_header(PutBitContext *pb, vorbis_enc_residue *rc)
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
static int put_bytes_output(const PutBitContext *s)
int sample_rate
samples per second
static double cb(void *priv, double x, double y)
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
static av_cold int vorbis_encode_init(AVCodecContext *avctx)
int ff_vorbis_ready_floor1_list(void *logctx, vorbis_floor1_entry *list, int values)
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
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...
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.
This structure describes decoded (raw) audio or video data.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static const uint8_t codebooks[]
#define fc(width, name, range_min, range_max)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
#define NUM_FLOOR_PARTITIONS
int nb_channels
Number of channels in this layout.
static void put_floor_header(PutBitContext *pb, vorbis_enc_floor *fc)
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...
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n)
static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)
Get the first buffer from the queue and remove it.
static av_cold int vorbis_encode_close(AVCodecContext *avctx)
static float win(SuperEqualizerContext *s, float n, int N)
vorbis_floor1_entry * list
static float * put_vector(vorbis_enc_codebook *book, PutBitContext *pb, float *num)
AVCodec p
The public AVCodec.
static double b1(void *priv, double x, double y)
AVChannelLayout ch_layout
Audio channel layout.
static AVFrame * spawn_empty_frame(AVCodecContext *avctx, int channels)
void ff_vorbis_floor1_render_list(vorbis_floor1_entry *list, int values, uint16_t *y_list, int *flag, int multiplier, float *out, int samples)
int initial_padding
Audio only.
static int put_bits_left(PutBitContext *s)
int flags
AV_CODEC_FLAG_*.
static double a2(void *priv, double x, double y)
#define FF_CODEC_ENCODE_CB(func)
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static const uint8_t quant[64]
const float ff_vorbis_floor1_inverse_db_table[256]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void put_float(PutBitContext *pb, float f)
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
#define FF_ARRAY_ELEMS(a)
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
int global_quality
Global quality for codecs which cannot change it per frame.
static int put_main_header(vorbis_enc_context *venc, uint8_t **out)
static __device__ float floor(float a)
static av_cold int dsp_init(AVCodecContext *avctx, vorbis_enc_context *venc)
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
vorbis_enc_residue * residues
vorbis_enc_floor_class * classes
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
#define CODEC_LONG_NAME(str)
static float get_floor_average(vorbis_enc_floor *fc, float *coeffs, int i)
static __device__ float fabs(float a)
static int residue_encode(vorbis_enc_context *venc, vorbis_enc_residue *rc, PutBitContext *pb, float *coeffs, int samples, int real_ch)
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
int64_t bit_rate
the average bitrate
static void ff_bufqueue_discard_all(struct FFBufQueue *queue)
Unref and remove all buffers from the queue.
static void floor_fit(vorbis_enc_context *venc, vorbis_enc_floor *fc, float *coeffs, uint16_t *posts, int samples)
static int floor_encode(vorbis_enc_context *venc, vorbis_enc_floor *fc, PutBitContext *pb, uint16_t *posts, float *floor, int samples)
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 int put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb, int entry)
static const struct @250 floor_classes[]
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
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.
static int render_point(int x0, int y0, int x1, int y1, int x)
enum AVSampleFormat sample_fmt
audio sample format
static int apply_window_and_mdct(vorbis_enc_context *venc)
static void move_audio(vorbis_enc_context *venc, int sf_size)
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
static double b2(void *priv, double x, double y)
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
static int ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc)
vorbis_enc_floor * floors
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.
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
vorbis_enc_mapping * mappings
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
int nb_samples
number of audio samples (per channel) described by this frame
static int ready_codebook(vorbis_enc_codebook *cb)
#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 int create_vorbis_context(vorbis_enc_context *venc, AVCodecContext *avctx)
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.
#define av_malloc_array(a, b)
unsigned short available
number of available buffers
AVSampleFormat
Audio sample formats.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
void * av_calloc(size_t nmemb, size_t size)
const FFCodec ff_vorbis_encoder
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
main external API structure.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
@ 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...
Filter the word “frame” indicates either a video frame or a group of audio samples
struct FFBufQueue bufqueue
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static void scale(int *out, const int *in, const int w, const int h, const int shift)
This structure stores compressed data.
vorbis_enc_codebook * codebooks
#define NUM_RESIDUE_PARTITIONS
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
static const uint8_t quant_tables[]
static float distance(float x, float y, int band)
const float *const ff_vorbis_vwin[8]
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static double a1(void *priv, double x, double y)
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
static int cb_lookup_vals(int lookup, int dimensions, int entries)