43 static void fcmul_add_c(
float *sum,
const float *t,
const float *
c, ptrdiff_t
len)
47 for (n = 0; n <
len; n++) {
48 const float cre = c[2 * n ];
49 const float cim = c[2 * n + 1];
50 const float tre = t[2 * n ];
51 const float tim = t[2 * n + 1];
53 sum[2 * n ] += tre * cre - tim * cim;
54 sum[2 * n + 1] += tre * cim + tim * cre;
57 sum[2 * n] += t[2 * n] * c[2 * n];
62 for (
int n = 0; n <
len; n++)
63 for (
int m = 0; m <= n; m++)
64 out[n] += ir[m].
re * in[n - m];
69 if ((nb_samples & 15) == 0 && nb_samples >= 16) {
72 for (
int n = 0; n < nb_samples; n++)
95 for (n = 0; n < nb_samples; n++)
119 direct(src, coeff, nb_samples, dst);
130 for (n = 0; n < nb_samples; n++) {
136 memset(sum, 0,
sizeof(*sum) * seg->
fft_length);
140 memcpy(block, src,
sizeof(*src) * seg->
part_size);
166 memcpy(dst, buf, seg->
part_size *
sizeof(*dst));
182 for (n = 0; n < nb_samples; n++)
203 const int start = (out->
channels * jobnr) / nb_jobs;
204 const int end = (out->
channels * (jobnr+1)) / nb_jobs;
206 for (
int ch = start; ch <
end; ch++) {
248 for (i = 0; txt[
i]; i++) {
252 for (char_y = 0; char_y < font_height; char_y++) {
253 for (mask = 0x80;
mask; mask >>= 1) {
254 if (font[txt[i] * font_height + char_y] & mask)
265 int dx =
FFABS(x1-x0);
266 int dy =
FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;
267 int err = (dx>dy ? dx : -dy) / 2, e2;
272 if (x0 == x1 && y0 == y1)
292 float *mag, *phase, *delay,
min = FLT_MAX,
max = FLT_MIN;
293 float min_delay = FLT_MAX, max_delay = FLT_MIN;
294 int prev_ymag = -1, prev_yphase = -1, prev_ydelay = -1;
303 if (!mag || !phase || !delay)
307 for (i = 0; i < s->
w; i++) {
309 double w = i *
M_PI / (s->
w - 1);
310 double div, real_num = 0., imag_num = 0., real = 0., imag = 0.;
312 for (x = 0; x < s->
nb_taps; x++) {
313 real += cos(-x *
w) * src[x];
314 imag += sin(-x * w) * src[x];
315 real_num += cos(-x * w) * src[x] * x;
316 imag_num += sin(-x * w) * src[x] * x;
319 mag[
i] =
hypot(real, imag);
320 phase[
i] = atan2(imag, real);
321 div = real * real + imag * imag;
322 delay[
i] = (real_num * real + imag_num * imag) / div;
323 min =
fminf(min, mag[i]);
324 max =
fmaxf(max, mag[i]);
325 min_delay =
fminf(min_delay, delay[i]);
326 max_delay =
fmaxf(max_delay, delay[i]);
329 for (i = 0; i < s->
w; i++) {
330 int ymag = mag[
i] / max * (s->
h - 1);
331 int ydelay = (delay[
i] - min_delay) / (max_delay - min_delay) * (s->
h - 1);
332 int yphase = (0.5 * (1. + phase[
i] /
M_PI)) * (s->
h - 1);
334 ymag = s->
h - 1 - av_clip(ymag, 0, s->
h - 1);
335 yphase = s->
h - 1 - av_clip(yphase, 0, s->
h - 1);
336 ydelay = s->
h - 1 - av_clip(ydelay, 0, s->
h - 1);
341 prev_yphase = yphase;
343 prev_ydelay = ydelay;
346 draw_line(out, i, yphase,
FFMAX(i - 1, 0), prev_yphase, 0xFF00FF00);
347 draw_line(out, i, ydelay,
FFMAX(i - 1, 0), prev_ydelay, 0xFF00FFFF);
350 prev_yphase = yphase;
351 prev_ydelay = ydelay;
354 if (s->
w > 400 && s->
h > 100) {
355 drawtext(out, 2, 2,
"Max Magnitude:", 0xDDDDDDDD);
356 snprintf(text,
sizeof(text),
"%.2f", max);
357 drawtext(out, 15 * 8 + 2, 2, text, 0xDDDDDDDD);
359 drawtext(out, 2, 12,
"Min Magnitude:", 0xDDDDDDDD);
360 snprintf(text,
sizeof(text),
"%.2f", min);
361 drawtext(out, 15 * 8 + 2, 12, text, 0xDDDDDDDD);
363 drawtext(out, 2, 22,
"Max Delay:", 0xDDDDDDDD);
364 snprintf(text,
sizeof(text),
"%.2f", max_delay);
365 drawtext(out, 11 * 8 + 2, 22, text, 0xDDDDDDDD);
367 drawtext(out, 2, 32,
"Min Delay:", 0xDDDDDDDD);
368 snprintf(text,
sizeof(text),
"%.2f", min_delay);
369 drawtext(out, 11 * 8 + 2, 32, text, 0xDDDDDDDD);
379 int offset,
int nb_partitions,
int part_size)
401 for (
int ch = 0; ch < ctx->
inputs[0]->
channels && part_size >= 8; ch++) {
453 int ret,
i, ch, n, cur_nb_taps;
457 int part_size, max_part_size;
474 for (i = 0; left > 0; i++) {
475 int step = part_size == max_part_size ? INT_MAX : 1 + (i == 0);
476 int nb_partitions =
FFMIN(step, (left + part_size - 1) / part_size);
482 offset += nb_partitions * part_size;
483 left -= nb_partitions * part_size;
485 part_size =
FFMIN(part_size, max_part_size);
511 for (i = 0; i < cur_nb_taps; i++)
512 power +=
FFABS(time[i]);
520 for (i = 0; i < cur_nb_taps; i++)
529 for (i = 0; i < cur_nb_taps; i++)
530 power += time[i] * time[i];
532 s->
gain = sqrtf(ch / power);
566 const float scale = 1.f / seg->
part_size;
568 const int remaining = s->
nb_taps - toffset;
572 for (n = 0; n <
size; n++)
573 coeff[coffset + n].
re = time[toffset + n];
579 memset(block, 0,
sizeof(*block) * seg->
fft_length);
580 memcpy(block, time + toffset, size *
sizeof(*block));
584 coeff[coffset].re = block[0] * scale;
585 coeff[coffset].im = 0;
587 coeff[coffset + n].re = block[2 * n] * scale;
588 coeff[coffset + n].im = block[2 * n + 1] * scale;
615 int nb_taps, max_nb_taps;
619 if (nb_taps > max_nb_taps) {
620 av_log(ctx,
AV_LOG_ERROR,
"Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
849 for (
int n = 0; n < s->
nb_irs; n++) {
877 .
name =
"filter_response",
904 int prev_ir = s->
selir;
912 if (prev_ir != s->
selir) {
919 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 920 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM 921 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 922 #define OFFSET(x) offsetof(AudioFIRContext, x) 939 {
"channel",
"set IR channel to display frequency response",
OFFSET(ir_channel),
AV_OPT_TYPE_INT, {.i64=0}, 0, 1024,
VF },
953 .description =
NULL_IF_CONFIG_SMALL(
"Apply Finite Impulse Response filter with supplied coefficients in additional stream(s)."),
955 .priv_class = &afir_class,
static int check_ir(AVFilterLink *link)
static av_cold int init(AVFilterContext *ctx)
This structure describes decoded (raw) audio or video data.
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Main libavfilter public API header.
int h
agreed upon image height
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
static av_cold void uninit(AVFilterContext *ctx)
float fminf(float, float)
static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, int offset, int nb_partitions, int part_size)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
AVFilterFormatsConfig outcfg
Lists of supported formats / etc.
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
const char * name
Pad name.
AVFilterLink ** inputs
array of pointers to input links
static void draw_response(AVFilterContext *ctx, AVFrame *out)
void(* vector_fmac_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float and add to destination vector.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
The exact code depends on how similar the blocks are and how related they are to the block
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
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 av_cold int end(AVCodecContext *avctx)
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 void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
void ff_afir_init_x86(AudioFIRDSPContext *s)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
#define AVERROR_EOF
End of file.
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
static int process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function.If this function returns true
static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
AVFilterPad * input_pads
array of input pads
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const uint8_t avpriv_cga_font[2048]
static int convert_coeffs(AVFilterContext *ctx)
AVFILTER_DEFINE_CLASS(afir)
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
int sample_rate
samples per second
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
static const uint16_t mask[17]
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 ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options...
void * priv
private data for use by the filter
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static void direct(const float *in, const FFTComplex *ir, int len, float *out)
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
void av_rdft_calc(RDFTContext *s, FFTSample *data)
int w
agreed upon image width
char * av_asprintf(const char *fmt,...)
static av_const double hypot(double x, double y)
int channels
number of audio channels, only used for audio.
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
unsigned nb_inputs
number of input pads
float fmaxf(float, float)
int ff_inlink_queued_samples(AVFilterLink *link)
AudioFIRDSPContext afirdsp
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
void(* fcmul_add)(float *sum, const float *t, const float *c, ptrdiff_t len)
void av_rdft_end(RDFTContext *s)
RDFTContext * av_rdft_init(int nbits, enum RDFTransformType trans)
Set up a real FFT.
AVFilterContext * src
source filter
static void fir_fadd(AudioFIRContext *s, float *dst, const float *src, int nb_samples)
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
void ff_afir_init(AudioFIRDSPContext *dsp)
static void fcmul_add_c(float *sum, const float *t, const float *c, ptrdiff_t len)
A list of supported channel layouts.
static int query_formats(AVFilterContext *ctx)
AVSampleFormat
Audio sample formats.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
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
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Rational number (pair of numerator and denominator).
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
offset must point to AVRational
const char * name
Filter name.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
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 link
offset must point to two consecutive integers
AVFilterLink ** outputs
array of pointers to output links
enum MovChannelLayoutTag * layouts
static enum AVPixelFormat pix_fmts[]
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
common internal and external API header
AudioFIRSegment seg[1024]
channel
Use these values when setting the channel map with ebur128_set_channel().
static int config_video(AVFilterLink *outlink)
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
uint64_t channel_layout
channel layout of current buffer (see libavutil/channel_layout.h)
int channels
Number of channels.
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
avfilter_execute_func * execute
static const AVOption afir_options[]
static int activate(AVFilterContext *ctx)
AVFilterContext * dst
dest filter
static const double coeff[2][5]
static enum AVSampleFormat sample_fmts[]
#define av_malloc_array(a, b)
static int config_output(AVFilterLink *outlink)
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
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
AVPixelFormat
Pixel format.
int nb_samples
number of audio samples (per channel) described by this frame
#define AV_NOPTS_VALUE
Undefined timestamp value.
CGA/EGA/VGA ROM font data.
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
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.
static int fir_quantum(AVFilterContext *ctx, AVFrame *out, int ch, int offset)