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++) {
249 draw_text(&
s->draw,
out, &
color, xoff + x *
C * 10 + 2, yoff + y *
P * 12 + p * 10 + 2, text, 0);
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++) {
343 snprintf(text,
sizeof(text),
"%d",
s->x + x);
346 ymaxlen + x *
C * 10 + 2 *
C - 2, 0, 10, xmaxlen);
348 draw_text(&
s->draw,
out, &
s->yellow, ymaxlen + x *
C * 10 + 2 *
C, 2, text, 1);
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' };
544 int x, y,
X,
Y,
i,
w,
h;
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
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[]
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
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
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)