Go to the documentation of this file.
56 #define OFFSET(x) offsetof(DatascopeContext, x)
57 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
58 #define FLAGSR AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
85 int x0,
int y0,
const uint8_t *text,
int vertical)
89 for (; *text; text++) {
111 color->rgba[3] = 255;
114 for (
i = 0;
i < 4;
i++) {
119 value[p] =
in->data[p][(y >> draw->
vsub[p]) *
in->linesize[p] + (
x >> draw->
hsub[p])];
129 color->rgba[3] = 255;
132 for (
i = 0;
i < 4;
i++) {
149 reverse->comp[p].u8[0] =
color->comp[p].u8[0] > 127 ? 0 : 255;
150 reverse->comp[p].u8[1] =
color->comp[p].u8[1] > 127 ? 0 : 255;
151 reverse->comp[p].u8[2] =
color->comp[p].u8[2] > 127 ? 0 : 255;
162 const unsigned mid = (
max + 1) / 2;
183 const int xoff =
td->xoff;
184 const int yoff =
td->yoff;
185 const int P =
FFMAX(
s->nb_planes,
s->nb_comps);
186 const int C =
s->chars;
187 const int D = ((
s->chars -
s->dformat) >> 2) +
s->dformat * 2;
188 const int W = (outlink->
w - xoff) / (
C * 10);
189 const int H = (outlink->
h - yoff) / (
P * 12);
190 const char *
format[4] = {
"%02X\n",
"%04X\n",
"%03d\n",
"%05d\n"};
191 const int slice_start = (
W * jobnr) / nb_jobs;
192 const int slice_end = (
W * (jobnr+1)) / nb_jobs;
195 for (y = 0; y <
H && (y +
s->y <
inlink->h); y++) {
199 int value[4] = { 0 };
204 xoff +
x *
C * 10, yoff + y *
P * 12,
C * 10,
P * 12);
206 for (p = 0; p <
P; p++) {
226 const int xoff =
td->xoff;
227 const int yoff =
td->yoff;
228 const int P =
FFMAX(
s->nb_planes,
s->nb_comps);
229 const int C =
s->chars;
230 const int D = ((
s->chars -
s->dformat) >> 2) +
s->dformat * 2;
231 const int W = (outlink->
w - xoff) / (
C * 10);
232 const int H = (outlink->
h - yoff) / (
P * 12);
233 const char *
format[4] = {
"%02X\n",
"%04X\n",
"%03d\n",
"%05d\n"};
234 const int slice_start = (
W * jobnr) / nb_jobs;
235 const int slice_end = (
W * (jobnr+1)) / nb_jobs;
238 for (y = 0; y <
H && (y +
s->y <
inlink->h); y++) {
241 int value[4] = { 0 };
245 for (p = 0; p <
P; p++) {
265 const int xoff =
td->xoff;
266 const int yoff =
td->yoff;
267 const int P =
FFMAX(
s->nb_planes,
s->nb_comps);
268 const int C =
s->chars;
269 const int D = ((
s->chars -
s->dformat) >> 2) +
s->dformat * 2;
270 const int W = (outlink->
w - xoff) / (
C * 10);
271 const int H = (outlink->
h - yoff) / (
P * 12);
272 const char *
format[4] = {
"%02X\n",
"%04X\n",
"%03d\n",
"%05d\n"};
273 const int slice_start = (
W * jobnr) / nb_jobs;
274 const int slice_end = (
W * (jobnr+1)) / nb_jobs;
277 for (y = 0; y <
H && (y +
s->y <
inlink->h); y++) {
280 int value[4] = { 0 };
283 for (p = 0; p <
P; p++) {
287 draw_text(&
s->draw,
out, &
s->white, xoff +
x *
C * 10 + 2, yoff + y *
P * 12 + p * 10 + 2, text, 0);
313 0, 0, outlink->
w, outlink->
h);
316 const int P =
FFMAX(
s->nb_planes,
s->nb_comps);
317 const int C =
s->chars;
318 int Y = outlink->
h / (
P * 12);
319 int X = outlink->
w / (
C * 10);
320 char text[256] = { 0 };
324 ymaxlen = strlen(text);
327 xmaxlen = strlen(text);
330 Y = (outlink->
h - xmaxlen) / (
P * 12);
331 X = (outlink->
w - ymaxlen) / (
C * 10);
333 for (y = 0; y <
Y; y++) {
334 snprintf(text,
sizeof(text),
"%d",
s->y + y);
337 0, xmaxlen + y *
P * 12 + (
P + 1) *
P - 2, ymaxlen, 10);
339 draw_text(&
s->draw,
out, &
s->yellow, 2, xmaxlen + y *
P * 12 + (
P + 1) *
P, text, 0);
342 for (
x = 0;
x <
X;
x++) {
346 ymaxlen +
x *
C * 10 + 2 *
C - 2, 0, 10, xmaxlen);
352 td.in =
in;
td.out =
out,
td.yoff = xmaxlen,
td.xoff = ymaxlen;
370 s->chars = (
s->draw.desc->comp[0].depth + 7) / 8 * 2 +
s->dformat;
371 s->nb_comps =
s->draw.desc->nb_components;
379 if (
s->draw.desc->comp[0].depth <= 8) {
424 .priv_class = &datascope_class,
460 #define POFFSET(x) offsetof(PixscopeContext, x)
487 s->nb_comps =
s->draw.desc->nb_components;
491 s->colors[0] = &
s->red;
492 s->colors[1] = &
s->green;
493 s->colors[2] = &
s->blue;
494 s->colors[3] = &
s->white;
497 s->colors[0] = &
s->white;
498 s->colors[1] = &
s->blue;
499 s->colors[2] = &
s->red;
500 s->colors[3] = &
s->white;
507 if (
s->draw.desc->comp[0].depth <= 8) {
531 #define SQR(x) ((x)*(x))
539 int max[4] = { 0 },
min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };
540 float average[4] = { 0 };
541 double std[4] = { 0 }, rms[4] = { 0 };
542 const char rgba[4] = {
'R',
'G',
'B',
'A' };
543 const char yuva[4] = {
'Y',
'U',
'V',
'A' };
558 X = (
in->width -
s->ww) *
s->wx;
560 X = (
in->width -
s->ww) * -
s->wx;
563 Y = (
in->height -
s->wh) *
s->wy;
565 Y = (
in->height -
s->wh) * -
s->wy;
569 if (
s->x +
s->w >=
X && (
s->x +
s->w <=
X +
s->ww) &&
570 s->y +
s->h >=
Y && (
s->y +
s->h <=
Y +
s->wh)) {
571 X = (
in->width -
s->ww) * (1 +
s->wx);
576 if (
s->x +
s->w >=
X && (
s->x +
s->w <=
X +
s->ww) &&
577 s->y +
s->h >=
Y && (
s->y +
s->h <=
Y +
s->wh)) {
578 Y = (
in->height -
s->wh) * (1 +
s->wy);
589 for (y = 0; y <
s->h; y++) {
590 for (
x = 0;
x <
s->w;
x++) {
592 int value[4] = { 0 };
596 x *
w + (
s->ww - 4 - (
s->w *
w)) / 2 +
X, y *
h + 2 +
Y,
w,
h);
597 for (
i = 0;
i < 4;
i++) {
609 s->x - 2,
s->y - 2,
s->w + 4, 1);
613 s->x - 1,
s->y - 1,
s->w + 2, 1);
617 s->x - 1,
s->y - 1, 1,
s->h + 2);
621 s->x - 2,
s->y - 2, 1,
s->h + 4);
625 s->x - 1,
s->y + 1 +
s->h,
s->w + 3, 1);
629 s->x - 2,
s->y + 2 +
s->h,
s->w + 4, 1);
633 s->x + 1 +
s->w,
s->y - 1, 1,
s->h + 2);
637 s->x + 2 +
s->w,
s->y - 2, 1,
s->h + 5);
639 for (
i = 0;
i < 4;
i++) {
640 rms[
i] /=
s->w *
s->h;
641 rms[
i] = sqrt(rms[
i]);
642 average[
i] /=
s->w *
s->h;
645 for (y = 0; y <
s->h; y++) {
646 for (
x = 0;
x <
s->w;
x++) {
647 for (
i = 0;
i < 4;
i++)
648 std[
i] +=
SQR(
s->values[
i][
x][y] - average[
i]);
652 for (
i = 0;
i < 4;
i++) {
653 std[
i] /=
s->w *
s->h;
654 std[
i] = sqrt(std[
i]);
657 snprintf(text,
sizeof(text),
"CH AVG MIN MAX RMS\n");
659 for (
i = 0;
i <
s->nb_comps;
i++) {
660 int c =
s->rgba_map[
i];
662 snprintf(text,
sizeof(text),
"%c %07.1f %05d %05d %07.1f\n",
s->is_rgb ? rgba[
i] : yuva[
i], average[
c],
min[
c],
max[
c], rms[
c]);
665 snprintf(text,
sizeof(text),
"CH STD\n");
667 for (
i = 0;
i <
s->nb_comps;
i++) {
668 int c =
s->rgba_map[
i];
670 snprintf(text,
sizeof(text),
"%c %07.2f\n",
s->is_rgb ? rgba[
i] : yuva[
i], std[
c]);
700 .priv_class = &pixscope_class,
753 #define OOFFSET(x) offsetof(OscilloscopeContext, x)
784 int dx =
FFABS(
x1 - x0), sx = x0 <
x1 ? 1 : -1;
785 int dy =
FFABS(
y1 - y0), sy = y0 <
y1 ? 1 : -1;
786 int err = (dx > dy ? dx : -dy) / 2, e2;
790 if (x0 >= 0 && y0 >= 0 && x0 < out->
width && y0 < out->
height) {
794 for (
i = 0;
i < 4;
i++) {
802 for (
i = 0;
i < 4;
i++) {
812 if (x0 ==
x1 && y0 ==
y1)
833 for (
i = 1;
i <
s->nb_values;
i++) {
834 for (
c = 0;
c <
s->nb_comps;
c++) {
835 if ((1 <<
c) &
s->components) {
836 int x =
i *
s->width /
s->nb_values;
837 int px = (
i - 1) *
s->width /
s->nb_values;
838 int py =
s->height -
s->values[
i-1].p[
s->rgba_map[
c]] *
s->height / 256;
839 int y =
s->height -
s->values[
i].p[
s->rgba_map[
c]] *
s->height / 256;
852 for (
i = 1;
i <
s->nb_values;
i++) {
853 for (
c = 0;
c <
s->nb_comps;
c++) {
854 if ((1 <<
c) &
s->components) {
855 int x =
i *
s->width /
s->nb_values;
856 int px = (
i - 1) *
s->width /
s->nb_values;
857 int py =
s->height -
s->values[
i-1].p[
s->rgba_map[
c]] *
s->height /
s->max;
858 int y =
s->height -
s->values[
i].p[
s->rgba_map[
c]] *
s->height /
s->max;
879 cx =
s->xpos * (
inlink->w - 1);
880 cy =
s->ypos * (
inlink->h - 1);
904 s->nb_comps =
s->draw.desc->nb_components;
908 s->colors[0] = &
s->red;
909 s->colors[1] = &
s->green;
910 s->colors[2] = &
s->blue;
911 s->colors[3] = &
s->white;
914 s->colors[0] = &
s->white;
915 s->colors[1] = &
s->cyan;
916 s->colors[2] = &
s->magenta;
917 s->colors[3] = &
s->white;
924 if (
s->draw.desc->comp[0].depth <= 8) {
932 s->max = (1 <<
s->draw.desc->comp[0].depth);
947 int dx =
FFABS(
x1 - x0), sx = x0 <
x1 ? 1 : -1;
948 int dy =
FFABS(
y1 - y0), sy = y0 <
y1 ? 1 : -1;
949 int err = (dx > dy ? dx : -dy) / 2, e2;
952 if (x0 >= 0 && y0 >= 0 && x0 < out->
width && y0 < out->
height) {
954 int value[4] = { 0 };
957 s->values[
s->nb_values].p[0] =
value[0];
958 s->values[
s->nb_values].p[1] =
value[1];
959 s->values[
s->nb_values].p[2] =
value[2];
960 s->values[
s->nb_values].p[3] =
value[3];
964 if (
s->draw.desc->comp[0].depth == 8) {
965 if (
s->draw.nb_planes == 1) {
968 for (
i = 0;
i <
s->draw.pixelstep[0];
i++)
969 out->data[0][
out->linesize[0] * y0 + x0 *
s->draw.pixelstep[0] +
i] = 255 * ((
s->nb_values +
state) & 1);
971 out->data[0][
out->linesize[0] * y0 + x0] = 255 * ((
s->nb_values +
state) & 1);
974 if (
s->draw.nb_planes == 1) {
977 for (
i = 0;
i <
s->draw.pixelstep[0];
i++)
978 AV_WN16(
out->data[0] +
out->linesize[0] * y0 + 2 * x0 * (
s->draw.pixelstep[0] +
i), (
s->max - 1) * ((
s->nb_values +
state) & 1));
980 AV_WN16(
out->data[0] +
out->linesize[0] * y0 + 2 * x0, (
s->max - 1) * ((
s->nb_values +
state) & 1));
986 if (x0 ==
x1 && y0 ==
y1)
1008 float average[4] = { 0 };
1010 int min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };
1017 s->ox,
s->oy,
s->width,
s->height + 20 *
s->statistics);
1019 if (
s->grid && outlink->
h >= 10) {
1021 s->ox,
s->oy,
s->width - 1, 1);
1023 for (
i = 1;
i < 5;
i++) {
1025 s->ox,
s->oy +
i * (
s->height - 1) / 4,
s->width, 1);
1028 for (
i = 0;
i < 10;
i++) {
1030 s->ox +
i * (
s->width - 1) / 10,
s->oy, 1,
s->height);
1034 s->ox +
s->width - 1,
s->oy, 1,
s->height);
1039 for (
i = 0;
i <
s->nb_values;
i++) {
1040 for (
c = 0;
c <
s->nb_comps;
c++) {
1041 if ((1 <<
c) &
s->components) {
1044 average[
c] +=
s->values[
i].p[
s->rgba_map[
c]];
1048 for (
c = 0;
c <
s->nb_comps;
c++) {
1049 average[
c] /=
s->nb_values;
1052 if (
s->statistics &&
s->height > 10 &&
s->width > 280 * av_popcount(
s->components)) {
1053 for (
c = 0,
i = 0;
c <
s->nb_comps;
c++) {
1054 if ((1 <<
c) &
s->components) {
1055 const char rgba[4] = {
'R',
'G',
'B',
'A' };
1056 const char yuva[4] = {
'Y',
'U',
'V',
'A' };
1059 snprintf(text,
sizeof(text),
"%c avg:%.1f min:%d max:%d\n",
s->is_rgb ? rgba[
c] : yuva[
c], average[
c],
min[
c],
max[
c]);
1069 char *res,
int res_len,
int flags)
1088 .needs_writable = 1,
1102 .
name =
"oscilloscope",
1105 .priv_class = &oscilloscope_class,
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
#define AV_LOG_WARNING
Something somehow does not look correct.
static void reverse_color8(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)
static const AVFilterPad pixscope_inputs[]
static int filter_mono(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
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 const AVFilterPad pixscope_outputs[]
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static int filter_color2(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
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.
const struct AVPixFmtDescriptor * desc
int depth
Number of bits in the component.
const char * name
Filter name.
static uint32_t reverse(uint32_t num, int bits)
static void pick_color8(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)
AVFormatInternal * internal
An opaque field for libavformat internal usage.
A link between two filters.
int pixelstep[MAX_PLANES]
void(* draw_trace)(struct OscilloscopeContext *s, AVFrame *frame)
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
void * priv
private data for use by the filter
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
void ff_blend_mask(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, const uint8_t *mask, int mask_linesize, int mask_w, int mask_h, int l2depth, unsigned endianness, int x0, int y0)
Blend an alpha mask with an uniform color.
void(* reverse_color)(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)
A filter pad used for either input or output.
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void update_oscilloscope(AVFilterContext *ctx)
uint16_t values[4][80][80]
static int filter_color(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int(* filter)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static void oscilloscope_uninit(AVFilterContext *ctx)
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
static int config_input(AVFilterLink *inlink)
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
static const AVFilterPad inputs[]
static const AVFilterPad oscilloscope_outputs[]
int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
Init a draw context.
static void pick_color16(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)
static void reverse_color16(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)
static int query_formats(AVFilterContext *ctx)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Describe the class of an AVClass context structure.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Rational number (pair of numerator and denominator).
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
static const AVOption datascope_options[]
static const AVOption oscilloscope_options[]
void(* pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)
static void draw_trace8(OscilloscopeContext *s, AVFrame *frame)
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
AVFILTER_DEFINE_CLASS(datascope)
static void draw_trace16(OscilloscopeContext *s, AVFrame *frame)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
void ff_blend_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, int x0, int y0, int w, int h)
Blend a rectangle with an uniform color.
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
static int oscilloscope_process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
static av_const double hypot(double x, double y)
static const AVFilterPad outputs[]
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
static void draw_text(FFDrawContext *draw, AVFrame *frame, FFDrawColor *color, int x0, int y0, const uint8_t *text, int vertical)
static const AVFilterPad oscilloscope_inputs[]
void ff_fill_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_x, int dst_y, int w, int h)
Fill a rectangle with an uniform color.
AVFilterContext * src
source filter
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.
static int pixscope_filter_frame(AVFilterLink *inlink, AVFrame *in)
void(* pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)
AVFilter ff_vf_oscilloscope
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
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
#define i(width, name, range_min, range_max)
int w
agreed upon image width
AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)
Return the list of pixel formats supported by the draw functions.
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Used for passing data between threads.
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 value
const char * name
Pad name.
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
void(* pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)
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
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo ug o o w
typedef void(RENAME(mix_any_func_type))
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
int h
agreed upon image height
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
static void draw_scope(OscilloscopeContext *s, int x0, int y0, int x1, int y1, AVFrame *out, PixelValues *p, int state)
const uint8_t avpriv_cga_font[2048]
static const int16_t alpha[]
static int config_output(AVFilterLink *outlink)
static void draw_line(FFDrawContext *draw, int x0, int y0, int x1, int y1, AVFrame *out, FFDrawColor *color)
static const AVOption pixscope_options[]
static int pixscope_config_input(AVFilterLink *inlink)
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
#define flags(name, subs,...)
static av_cold int uninit(AVCodecContext *avctx)
static int oscilloscope_filter_frame(AVFilterLink *inlink, AVFrame *frame)
static int oscilloscope_config_input(AVFilterLink *inlink)