FFmpeg: libavfilter/vf_datascope.c Source File

FFmpeg

[フレーム]

libavfilter

vf_datascope.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include "libavutil/intreadwrite.h"

22 #include "libavutil/mem.h"

23 #include "libavutil/opt.h"

24 #include "libavutil/pixdesc.h"

25 #include "libavutil/xga_font_data.h"

26 #include "avfilter.h"

27 #include "drawutils.h"

28 #include "filters.h"

29 #include "formats.h"

30 #include "video.h"

32 typedef struct DatascopeContext {

33 const AVClass *class;

34 int ow, oh;

35 int x, y;

36 int mode;

37 int dformat;

38 int axis;

39 int components;

40 float opacity;

42 int nb_planes;

43 int nb_comps;

44 int chars;

45 FFDrawContext draw;

46 FFDrawColor yellow;

47 FFDrawColor white;

48 FFDrawColor black;

49 FFDrawColor gray;

51 void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);

52 void (*reverse_color)(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse);

53 int (*filter)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);

54 } DatascopeContext;

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

60 static const AVOption datascope_options[] = {

61 { "size", "set output size", OFFSET(ow), AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, FLAGS },

62 { "s", "set output size", OFFSET(ow), AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, FLAGS },

63 { "x", "set x offset", OFFSET(x), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGSR },

64 { "y", "set y offset", OFFSET(y), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGSR },

65 { "mode", "set scope mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGSR, .unit = "mode" },

66 { "mono", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGSR, .unit = "mode" },

67 { "color", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGSR, .unit = "mode" },

68 { "color2", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGSR, .unit = "mode" },

69 { "axis", "draw column/row numbers", OFFSET(axis), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGSR },

70 { "opacity", "set background opacity", OFFSET(opacity), AV_OPT_TYPE_FLOAT, {.dbl=0.75}, 0, 1, FLAGSR },

71 { "format", "set display number format", OFFSET(dformat), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGSR, .unit = "format" },

72 { "hex", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGSR, .unit = "format" },

73 { "dec", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGSR, .unit = "format" },

74 { "components", "set components to display", OFFSET(components), AV_OPT_TYPE_INT, {.i64=15}, 1, 15, FLAGSR },

75 { NULL }

76 };

78 AVFILTER_DEFINE_CLASS(datascope);

80 static int query_formats(const AVFilterContext *ctx,

81 AVFilterFormatsConfig **cfg_in,

82 AVFilterFormatsConfig **cfg_out)

83 {

84 return ff_set_common_formats2(ctx, cfg_in, cfg_out,

85 ff_draw_supported_pixel_formats(0));

86 }

88 static void draw_text(FFDrawContext *draw, AVFrame *frame, FFDrawColor *color,

89 int x0, int y0, const uint8_t *text, int vertical)

90 {

91 const uint8_t *cga_font = avpriv_cga_font_get();

92 int x = x0;

94 for (; *text; text++) {

95 if (*text == '\n') {

96 x = x0;

97 y0 += 8;

98 continue;

99 }

100 ff_blend_mask(draw, color, frame->data, frame->linesize,

101 frame->width, frame->height,

102 &cga_font[*text * 8], 1, 8, 8, 0, 0, x, y0);

103 if (vertical) {

104 x = x0;

105 y0 += 8;

106 } else {

107 x += 8;

108 }

109 }

110 }

111

112 static void pick_color8(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)

113 {

114 int p, i;

115

116 color->rgba[3] = 255;

117 for (p = 0; p < draw->nb_planes; p++) {

118 if (draw->nb_planes == 1) {

119 for (i = 0; i < 4; i++) {

120 value[i] = in->data[0][y * in->linesize[0] + x * draw->pixelstep[0] + i];

121 color->comp[0].u8[i] = value[i];

122 }

123 } else {

124 value[p] = in->data[p][(y >> draw->vsub[p]) * in->linesize[p] + (x >> draw->hsub[p])];

125 color->comp[p].u8[0] = value[p];

126 }

127 }

128 }

129

130 static void pick_color16(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)

131 {

132 int p, i;

133

134 color->rgba[3] = 255;

135 for (p = 0; p < draw->nb_planes; p++) {

136 if (draw->nb_planes == 1) {

137 for (i = 0; i < 4; i++) {

138 value[i] = AV_RL16(in->data[0] + y * in->linesize[0] + x * draw->pixelstep[0] + i * 2);

139 color->comp[0].u16[i] = value[i];

140 }

141 } else {

142 value[p] = AV_RL16(in->data[p] + (y >> draw->vsub[p]) * in->linesize[p] + (x >> draw->hsub[p]) * 2);

143 color->comp[p].u16[0] = value[p];

144 }

145 }

146 }

147

148 static void reverse_color8(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)

149 {

150 int p;

151

152 reverse->rgba[3] = 255;

153 for (p = 0; p < draw->nb_planes; p++) {

154 reverse->comp[p].u8[0] = color->comp[p].u8[0] > 127 ? 0 : 255;

155 reverse->comp[p].u8[1] = color->comp[p].u8[1] > 127 ? 0 : 255;

156 reverse->comp[p].u8[2] = color->comp[p].u8[2] > 127 ? 0 : 255;

157 }

158 }

159

160 static void reverse_color16(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)

161 {

162 int p;

163

164 reverse->rgba[3] = 255;

165 for (p = 0; p < draw->nb_planes; p++) {

166 const unsigned max = (1 << draw->desc->comp[p].depth) - 1;

167 const unsigned mid = (max + 1) / 2;

168

169 reverse->comp[p].u16[0] = color->comp[p].u16[0] > mid ? 0 : max;

170 reverse->comp[p].u16[1] = color->comp[p].u16[1] > mid ? 0 : max;

171 reverse->comp[p].u16[2] = color->comp[p].u16[2] > mid ? 0 : max;

172 }

173 }

174

175 typedef struct ThreadData {

176 AVFrame *in, *out;

177 int xoff, yoff, PP;

178 } ThreadData;

179

180 static int filter_color2(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

181 {

182 DatascopeContext *s = ctx->priv;

183 AVFilterLink *outlink = ctx->outputs[0];

184 AVFilterLink *inlink = ctx->inputs[0];

185 ThreadData *td = arg;

186 AVFrame *in = td->in;

187 AVFrame *out = td->out;

188 const int PP = td->PP;

189 const int xoff = td->xoff;

190 const int yoff = td->yoff;

191 const int P = FFMAX(s->nb_planes, s->nb_comps);

192 const int C = s->chars;

193 const int D = ((s->chars - s->dformat) >> 2) + s->dformat * 2;

194 const int W = (outlink->w - xoff) / (C * 10);

195 const int H = (outlink->h - yoff) / (PP * 12);

196 const char *format[4] = {"%02X\n", "%04X\n", "%03d\n", "%05d\n"};

197 const int slice_start = (W * jobnr) / nb_jobs;

198 const int slice_end = (W * (jobnr+1)) / nb_jobs;

199 int x, y, p;

200

201 for (y = 0; y < H && (y + s->y < inlink->h); y++) {

202 for (x = slice_start; x < slice_end && (x + s->x < inlink->w); x++) {

203 FFDrawColor color = { { 0 } };

204 FFDrawColor reverse = { { 0 } };

205 int value[4] = { 0 }, pp = 0;

206

207 s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);

208 s->reverse_color(&s->draw, &color, &reverse);

209 ff_fill_rectangle(&s->draw, &color, out->data, out->linesize,

210 xoff + x * C * 10, yoff + y * PP * 12, C * 10, PP * 12);

211

212 for (p = 0; p < P; p++) {

213 char text[256];

214

215 if (!(s->components & (1 << p)))

216 continue;

217 snprintf(text, sizeof(text), format[D], value[p]);

218 draw_text(&s->draw, out, &reverse, xoff + x * C * 10 + 2, yoff + y * PP * 12 + pp * 10 + 2, text, 0);

219 pp++;

220 }

221 }

222 }

223

224 return 0;

225 }

226

227 static int filter_color(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

228 {

229 DatascopeContext *s = ctx->priv;

230 AVFilterLink *outlink = ctx->outputs[0];

231 AVFilterLink *inlink = ctx->inputs[0];

232 ThreadData *td = arg;

233 AVFrame *in = td->in;

234 AVFrame *out = td->out;

235 const int PP = td->PP;

236 const int xoff = td->xoff;

237 const int yoff = td->yoff;

238 const int P = FFMAX(s->nb_planes, s->nb_comps);

239 const int C = s->chars;

240 const int D = ((s->chars - s->dformat) >> 2) + s->dformat * 2;

241 const int W = (outlink->w - xoff) / (C * 10);

242 const int H = (outlink->h - yoff) / (PP * 12);

243 const char *format[4] = {"%02X\n", "%04X\n", "%03d\n", "%05d\n"};

244 const int slice_start = (W * jobnr) / nb_jobs;

245 const int slice_end = (W * (jobnr+1)) / nb_jobs;

246 int x, y, p;

247

248 for (y = 0; y < H && (y + s->y < inlink->h); y++) {

249 for (x = slice_start; x < slice_end && (x + s->x < inlink->w); x++) {

250 FFDrawColor color = { { 0 } };

251 int value[4] = { 0 }, pp = 0;

252

253 s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);

254

255 for (p = 0; p < P; p++) {

256 char text[256];

257

258 if (!(s->components & (1 << p)))

259 continue;

260 snprintf(text, sizeof(text), format[D], value[p]);

261 draw_text(&s->draw, out, &color, xoff + x * C * 10 + 2, yoff + y * PP * 12 + pp * 10 + 2, text, 0);

262 pp++;

263 }

264 }

265 }

266

267 return 0;

268 }

269

270 static int filter_mono(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

271 {

272 DatascopeContext *s = ctx->priv;

273 AVFilterLink *outlink = ctx->outputs[0];

274 AVFilterLink *inlink = ctx->inputs[0];

275 ThreadData *td = arg;

276 AVFrame *in = td->in;

277 AVFrame *out = td->out;

278 const int PP = td->PP;

279 const int xoff = td->xoff;

280 const int yoff = td->yoff;

281 const int P = FFMAX(s->nb_planes, s->nb_comps);

282 const int C = s->chars;

283 const int D = ((s->chars - s->dformat) >> 2) + s->dformat * 2;

284 const int W = (outlink->w - xoff) / (C * 10);

285 const int H = (outlink->h - yoff) / (PP * 12);

286 const char *format[4] = {"%02X\n", "%04X\n", "%03d\n", "%05d\n"};

287 const int slice_start = (W * jobnr) / nb_jobs;

288 const int slice_end = (W * (jobnr+1)) / nb_jobs;

289 int x, y, p;

290

291 for (y = 0; y < H && (y + s->y < inlink->h); y++) {

292 for (x = slice_start; x < slice_end && (x + s->x < inlink->w); x++) {

293 FFDrawColor color = { { 0 } };

294 int value[4] = { 0 }, pp = 0;

295

296 s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);

297 for (p = 0; p < P; p++) {

298 char text[256];

299

300 if (!(s->components & (1 << p)))

301 continue;

302 snprintf(text, sizeof(text), format[D], value[p]);

303 draw_text(&s->draw, out, &s->white, xoff + x * C * 10 + 2, yoff + y * PP * 12 + pp * 10 + 2, text, 0);

304 pp++;

305 }

306 }

307 }

308

309 return 0;

310 }

311

312 static int filter_frame(AVFilterLink *inlink, AVFrame *in)

313 {

314 AVFilterContext *ctx = inlink->dst;

315 DatascopeContext *s = ctx->priv;

316 AVFilterLink *outlink = ctx->outputs[0];

317 const int P = FFMAX(s->nb_planes, s->nb_comps);

318 ThreadData td = { 0 };

319 int ymaxlen = 0;

320 int xmaxlen = 0;

321 int PP = 0;

322 AVFrame *out;

323

324 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

325 if (!out) {

326 av_frame_free(&in);

327 return AVERROR(ENOMEM);

328 }

329 av_frame_copy_props(out, in);

330

331 ff_fill_rectangle(&s->draw, &s->black, out->data, out->linesize,

332 0, 0, outlink->w, outlink->h);

333

334 for (int p = 0; p < P; p++) {

335 if (s->components & (1 << p))

336 PP++;

337 }

338 PP = FFMAX(PP, 1);

339

340 if (s->axis) {

341 const int C = s->chars;

342 int Y = outlink->h / (PP * 12);

343 int X = outlink->w / (C * 10);

344 char text[256] = { 0 };

345 int x, y;

346

347 snprintf(text, sizeof(text), "%d", s->y + Y);

348 ymaxlen = strlen(text);

349 ymaxlen *= 10;

350 snprintf(text, sizeof(text), "%d", s->x + X);

351 xmaxlen = strlen(text);

352 xmaxlen *= 10;

353

354 Y = (outlink->h - xmaxlen) / (PP * 12);

355 X = (outlink->w - ymaxlen) / (C * 10);

356

357 for (y = 0; y < Y; y++) {

358 snprintf(text, sizeof(text), "%d", s->y + y);

359

360 ff_fill_rectangle(&s->draw, &s->gray, out->data, out->linesize,

361 0, xmaxlen + y * PP * 12 + (PP + 1) * PP - 2, ymaxlen, 10);

362

363 draw_text(&s->draw, out, &s->yellow, 2, xmaxlen + y * PP * 12 + (PP + 1) * PP, text, 0);

364 }

365

366 for (x = 0; x < X; x++) {

367 snprintf(text, sizeof(text), "%d", s->x + x);

368

369 ff_fill_rectangle(&s->draw, &s->gray, out->data, out->linesize,

370 ymaxlen + x * C * 10 + 2 * C - 2, 0, 10, xmaxlen);

371

372 draw_text(&s->draw, out, &s->yellow, ymaxlen + x * C * 10 + 2 * C, 2, text, 1);

373 }

374 }

375

376 td.in = in; td.out = out, td.yoff = xmaxlen, td.xoff = ymaxlen, td.PP = PP;

377 ff_filter_execute(ctx, s->filter, &td, NULL,

378 FFMIN(ff_filter_get_nb_threads(ctx), FFMAX(outlink->w / 20, 1)));

379

380 av_frame_free(&in);

381 return ff_filter_frame(outlink, out);

382 }

383

384 static int config_input(AVFilterLink *inlink)

385 {

386 AVFilterContext *ctx = inlink->dst;

387 DatascopeContext *s = ctx->priv;

388

389 uint8_t alpha = s->opacity * 255;

390 int ret;

391

392 s->nb_planes = av_pix_fmt_count_planes(inlink->format);

393 ret = ff_draw_init_from_link(&s->draw, inlink, 0);

394 if (ret < 0) {

395 av_log(ctx, AV_LOG_ERROR, "Failed to initialize FFDrawContext\n");

396 return ret;

397 }

398 ff_draw_color(&s->draw, &s->white, (uint8_t[]){ 255, 255, 255, 255} );

399 ff_draw_color(&s->draw, &s->black, (uint8_t[]){ 0, 0, 0, alpha} );

400 ff_draw_color(&s->draw, &s->yellow, (uint8_t[]){ 255, 255, 0, 255} );

401 ff_draw_color(&s->draw, &s->gray, (uint8_t[]){ 77, 77, 77, 255} );

402 s->chars = (s->draw.desc->comp[0].depth + 7) / 8 * 2 + s->dformat;

403 s->nb_comps = s->draw.desc->nb_components;

404

405 switch (s->mode) {

406 case 0: s->filter = filter_mono; break;

407 case 1: s->filter = filter_color; break;

408 case 2: s->filter = filter_color2; break;

409 }

410

411 if (s->draw.desc->comp[0].depth <= 8) {

412 s->pick_color = pick_color8;

413 s->reverse_color = reverse_color8;

414 } else {

415 s->pick_color = pick_color16;

416 s->reverse_color = reverse_color16;

417 }

418

419 return 0;

420 }

421

422 static int config_output(AVFilterLink *outlink)

423 {

424 DatascopeContext *s = outlink->src->priv;

425

426 outlink->h = s->oh;

427 outlink->w = s->ow;

428 outlink->sample_aspect_ratio = (AVRational){1,1};

429

430 return 0;

431 }

432

433 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,

434 char *res, int res_len, int flags)

435 {

436 int ret;

437

438 ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);

439 if (ret < 0)

440 return ret;

441

442 return config_input(ctx->inputs[0]);

443 }

444

445 static const AVFilterPad inputs[] = {

446 {

447 .name = "default",

448 .type = AVMEDIA_TYPE_VIDEO,

449 .filter_frame = filter_frame,

450 .config_props = config_input,

451 },

452 };

453

454 static const AVFilterPad outputs[] = {

455 {

456 .name = "default",

457 .type = AVMEDIA_TYPE_VIDEO,

458 .config_props = config_output,

459 },

460 };

461

462 const FFFilter ff_vf_datascope = {

463 .p.name = "datascope",

464 .p.description = NULL_IF_CONFIG_SMALL("Video data analysis."),

465 .p.priv_class = &datascope_class,

466 .p.flags = AVFILTER_FLAG_SLICE_THREADS,

467 .priv_size = sizeof(DatascopeContext),

468 FILTER_INPUTS(inputs),

469 FILTER_OUTPUTS(outputs),

470 FILTER_QUERY_FUNC2(query_formats),

471 .process_command = process_command,

472 };

473

474 typedef struct PixscopeContext {

475 const AVClass *class;

476

477 float xpos, ypos;

478 float wx, wy;

479 int w, h;

480 float o;

481

482 int x, y;

483 int ww, wh;

484

485 int nb_planes;

486 int nb_comps;

487 int is_rgb;

488 uint8_t rgba_map[4];

489 FFDrawContext draw;

490 FFDrawColor dark;

491 FFDrawColor black;

492 FFDrawColor white;

493 FFDrawColor green;

494 FFDrawColor blue;

495 FFDrawColor red;

496 FFDrawColor *colors[4];

497

498 uint16_t values[4][80][80];

499

500 void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);

501 } PixscopeContext;

502

503 #define POFFSET(x) offsetof(PixscopeContext, x)

504

505 static const AVOption pixscope_options[] = {

506 { "x", "set scope x offset", POFFSET(xpos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGSR },

507 { "y", "set scope y offset", POFFSET(ypos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGSR },

508 { "w", "set scope width", POFFSET(w), AV_OPT_TYPE_INT, {.i64=7}, 1, 80, FLAGSR },

509 { "h", "set scope height", POFFSET(h), AV_OPT_TYPE_INT, {.i64=7}, 1, 80, FLAGSR },

510 { "o", "set window opacity", POFFSET(o), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGSR },

511 { "wx", "set window x offset", POFFSET(wx), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 1, FLAGSR },

512 { "wy", "set window y offset", POFFSET(wy), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 1, FLAGSR },

513 { NULL }

514 };

515

516 AVFILTER_DEFINE_CLASS(pixscope);

517

518 static int pixscope_config_input(AVFilterLink *inlink)

519 {

520 AVFilterContext *ctx = inlink->dst;

521 PixscopeContext *s = ctx->priv;

522 int ret;

523

524 s->nb_planes = av_pix_fmt_count_planes(inlink->format);

525 ret = ff_draw_init(&s->draw, inlink->format, 0);

526 if (ret < 0) {

527 av_log(ctx, AV_LOG_ERROR, "Failed to initialize FFDrawContext\n");

528 return ret;

529 }

530 ff_draw_color(&s->draw, &s->dark, (uint8_t[]){ 0, 0, 0, s->o * 255} );

531 ff_draw_color(&s->draw, &s->black, (uint8_t[]){ 0, 0, 0, 255} );

532 ff_draw_color(&s->draw, &s->white, (uint8_t[]){ 255, 255, 255, 255} );

533 ff_draw_color(&s->draw, &s->green, (uint8_t[]){ 0, 255, 0, 255} );

534 ff_draw_color(&s->draw, &s->blue, (uint8_t[]){ 0, 0, 255, 255} );

535 ff_draw_color(&s->draw, &s->red, (uint8_t[]){ 255, 0, 0, 255} );

536 s->nb_comps = s->draw.desc->nb_components;

537 s->is_rgb = s->draw.desc->flags & AV_PIX_FMT_FLAG_RGB;

538

539 if (s->is_rgb) {

540 s->colors[0] = &s->red;

541 s->colors[1] = &s->green;

542 s->colors[2] = &s->blue;

543 s->colors[3] = &s->white;

544 ff_fill_rgba_map(s->rgba_map, inlink->format);

545 } else {

546 s->colors[0] = &s->white;

547 s->colors[1] = &s->blue;

548 s->colors[2] = &s->red;

549 s->colors[3] = &s->white;

550 s->rgba_map[0] = 0;

551 s->rgba_map[1] = 1;

552 s->rgba_map[2] = 2;

553 s->rgba_map[3] = 3;

554 }

555

556 if (s->draw.desc->comp[0].depth <= 8) {

557 s->pick_color = pick_color8;

558 } else {

559 s->pick_color = pick_color16;

560 }

561

562 if (inlink->w < 640 || inlink->h < 480) {

563 av_log(inlink->dst, AV_LOG_ERROR, "min supported resolution is 640x480\n");

564 return AVERROR(EINVAL);

565 }

566

567 s->ww = 300;

568 s->wh = 300 * 1.6;

569 s->x = s->xpos * (inlink->w - 1);

570 s->y = s->ypos * (inlink->h - 1);

571 if (s->x + s->w >= inlink->w || s->y + s->h >= inlink->h) {

572 av_log(inlink->dst, AV_LOG_WARNING, "scope position is out of range, clipping\n");

573 s->x = FFMIN(s->x, inlink->w - s->w);

574 s->y = FFMIN(s->y, inlink->h - s->h);

575 }

576

577 return 0;

578 }

579

580 #define SQR(x) ((x)*(x))

581

582 static int pixscope_filter_frame(AVFilterLink *inlink, AVFrame *in)

583 {

584 AVFilterContext *ctx = inlink->dst;

585 PixscopeContext *s = ctx->priv;

586 AVFilterLink *outlink = ctx->outputs[0];

587 AVFrame *out = ff_get_video_buffer(outlink, in->width, in->height);

588 int max[4] = { 0 }, min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };

589 float average[4] = { 0 };

590 double std[4] = { 0 }, rms[4] = { 0 };

591 const char rgba[4] = { 'R', 'G', 'B', 'A' };

592 const char yuva[4] = { 'Y', 'U', 'V', 'A' };

593 int x, y, X, Y, i, w, h;

594 char text[128];

595

596 if (!out) {

597 av_frame_free(&in);

598 return AVERROR(ENOMEM);

599 }

600 av_frame_copy_props(out, in);

601 av_frame_copy(out, in);

602

603 w = s->ww / s->w;

604 h = s->ww / s->h;

605

606 if (s->wx >= 0) {

607 X = (in->width - s->ww) * s->wx;

608 } else {

609 X = (in->width - s->ww) * -s->wx;

610 }

611 if (s->wy >= 0) {

612 Y = (in->height - s->wh) * s->wy;

613 } else {

614 Y = (in->height - s->wh) * -s->wy;

615 }

616

617 if (s->wx < 0) {

618 if (s->x + s->w >= X && (s->x + s->w <= X + s->ww) &&

619 s->y + s->h >= Y && (s->y + s->h <= Y + s->wh)) {

620 X = (in->width - s->ww) * (1 + s->wx);

621 }

622 }

623

624 if (s->wy < 0) {

625 if (s->x + s->w >= X && (s->x + s->w <= X + s->ww) &&

626 s->y + s->h >= Y && (s->y + s->h <= Y + s->wh)) {

627 Y = (in->height - s->wh) * (1 + s->wy);

628 }

629 }

630

631 ff_blend_rectangle(&s->draw, &s->dark, out->data, out->linesize,

632 out->width, out->height,

633 X,

634 Y,

635 s->ww,

636 s->wh);

637

638 for (y = 0; y < s->h; y++) {

639 for (x = 0; x < s->w; x++) {

640 FFDrawColor color = { { 0 } };

641 int value[4] = { 0 };

642

643 s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);

644 ff_fill_rectangle(&s->draw, &color, out->data, out->linesize,

645 x * w + (s->ww - 4 - (s->w * w)) / 2 + X, y * h + 2 + Y, w, h);

646 for (i = 0; i < 4; i++) {

647 s->values[i][x][y] = value[i];

648 rms[i] += (double)value[i] * (double)value[i];

649 average[i] += value[i];

650 min[i] = FFMIN(min[i], value[i]);

651 max[i] = FFMAX(max[i], value[i]);

652 }

653 }

654 }

655

656 ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,

657 out->width, out->height,

658 s->x - 2, s->y - 2, s->w + 4, 1);

659

660 ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,

661 out->width, out->height,

662 s->x - 1, s->y - 1, s->w + 2, 1);

663

664 ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,

665 out->width, out->height,

666 s->x - 1, s->y - 1, 1, s->h + 2);

667

668 ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,

669 out->width, out->height,

670 s->x - 2, s->y - 2, 1, s->h + 4);

671

672 ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,

673 out->width, out->height,

674 s->x - 1, s->y + 1 + s->h, s->w + 3, 1);

675

676 ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,

677 out->width, out->height,

678 s->x - 2, s->y + 2 + s->h, s->w + 4, 1);

679

680 ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,

681 out->width, out->height,

682 s->x + 1 + s->w, s->y - 1, 1, s->h + 2);

683

684 ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,

685 out->width, out->height,

686 s->x + 2 + s->w, s->y - 2, 1, s->h + 5);

687

688 for (i = 0; i < 4; i++) {

689 rms[i] /= s->w * s->h;

690 rms[i] = sqrt(rms[i]);

691 average[i] /= s->w * s->h;

692 }

693

694 for (y = 0; y < s->h; y++) {

695 for (x = 0; x < s->w; x++) {

696 for (i = 0; i < 4; i++)

697 std[i] += SQR(s->values[i][x][y] - average[i]);

698 }

699 }

700

701 for (i = 0; i < 4; i++) {

702 std[i] /= s->w * s->h;

703 std[i] = sqrt(std[i]);

704 }

705

706 snprintf(text, sizeof(text), "CH AVG MIN MAX RMS\n");

707 draw_text(&s->draw, out, &s->white, X + 28, Y + s->ww + 5, text, 0);

708 for (i = 0; i < s->nb_comps; i++) {

709 int c = s->rgba_map[i];

710

711 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]);

712 draw_text(&s->draw, out, s->colors[i], X + 28, Y + s->ww + 15 * (i + 1), text, 0);

713 }

714 snprintf(text, sizeof(text), "CH STD\n");

715 draw_text(&s->draw, out, &s->white, X + 28, Y + s->ww + 15 * (0 + 5), text, 0);

716 for (i = 0; i < s->nb_comps; i++) {

717 int c = s->rgba_map[i];

718

719 snprintf(text, sizeof(text), "%c %07.2f\n", s->is_rgb ? rgba[i] : yuva[i], std[c]);

720 draw_text(&s->draw, out, s->colors[i], X + 28, Y + s->ww + 15 * (i + 6), text, 0);

721 }

722

723 av_frame_free(&in);

724 return ff_filter_frame(outlink, out);

725 }

726

727 static int pixscope_process_command(AVFilterContext *ctx, const char *cmd, const char *args,

728 char *res, int res_len, int flags)

729 {

730 int ret;

731

732 ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);

733 if (ret < 0)

734 return ret;

735

736 return pixscope_config_input(ctx->inputs[0]);

737 }

738

739 static const AVFilterPad pixscope_inputs[] = {

740 {

741 .name = "default",

742 .type = AVMEDIA_TYPE_VIDEO,

743 .filter_frame = pixscope_filter_frame,

744 .config_props = pixscope_config_input,

745 },

746 };

747

748 const FFFilter ff_vf_pixscope = {

749 .p.name = "pixscope",

750 .p.description = NULL_IF_CONFIG_SMALL("Pixel data analysis."),

751 .p.priv_class = &pixscope_class,

752 .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

753 .priv_size = sizeof(PixscopeContext),

754 FILTER_INPUTS(pixscope_inputs),

755 FILTER_OUTPUTS(ff_video_default_filterpad),

756 FILTER_QUERY_FUNC2(query_formats),

757 .process_command = pixscope_process_command,

758 };

759

760 typedef struct PixelValues {

761 uint16_t p[4];

762 } PixelValues;

763

764 typedef struct OscilloscopeContext {

765 const AVClass *class;

766

767 float xpos, ypos;

768 float tx, ty;

769 float size;

770 float tilt;

771 float theight, twidth;

772 float o;

773 int components;

774 int grid;

775 int statistics;

776 int scope;

777

778 int x1, y1, x2, y2;

779 int ox, oy;

780 int height, width;

781

782 int max;

783 int nb_planes;

784 int nb_comps;

785 int is_rgb;

786 uint8_t rgba_map[4];

787 FFDrawContext draw;

788 FFDrawColor dark;

789 FFDrawColor black;

790 FFDrawColor white;

791 FFDrawColor green;

792 FFDrawColor blue;

793 FFDrawColor red;

794 FFDrawColor cyan;

795 FFDrawColor magenta;

796 FFDrawColor gray;

797 FFDrawColor *colors[4];

798

799 int nb_values;

800 PixelValues *values;

801

802 void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);

803 void (*draw_trace)(struct OscilloscopeContext *s, AVFrame *frame);

804 } OscilloscopeContext;

805

806 #define OOFFSET(x) offsetof(OscilloscopeContext, x)

807

808 static const AVOption oscilloscope_options[] = {

809 { "x", "set scope x position", OOFFSET(xpos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGSR },

810 { "y", "set scope y position", OOFFSET(ypos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGSR },

811 { "s", "set scope size", OOFFSET(size), AV_OPT_TYPE_FLOAT, {.dbl=0.8}, 0, 1, FLAGSR },

812 { "t", "set scope tilt", OOFFSET(tilt), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGSR },

813 { "o", "set trace opacity", OOFFSET(o), AV_OPT_TYPE_FLOAT, {.dbl=0.8}, 0, 1, FLAGSR },

814 { "tx", "set trace x position", OOFFSET(tx), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGSR },

815 { "ty", "set trace y position", OOFFSET(ty), AV_OPT_TYPE_FLOAT, {.dbl=0.9}, 0, 1, FLAGSR },

816 { "tw", "set trace width", OOFFSET(twidth), AV_OPT_TYPE_FLOAT, {.dbl=0.8},.1, 1, FLAGSR },

817 { "th", "set trace height", OOFFSET(theight), AV_OPT_TYPE_FLOAT, {.dbl=0.3},.1, 1, FLAGSR },

818 { "c", "set components to trace", OOFFSET(components), AV_OPT_TYPE_INT, {.i64=7}, 0, 15, FLAGSR },

819 { "g", "draw trace grid", OOFFSET(grid), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGSR },

820 { "st", "draw statistics", OOFFSET(statistics), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGSR },

821 { "sc", "draw scope", OOFFSET(scope), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGSR },

822 { NULL }

823 };

824

825 AVFILTER_DEFINE_CLASS(oscilloscope);

826

827 static void oscilloscope_uninit(AVFilterContext *ctx)

828 {

829 OscilloscopeContext *s = ctx->priv;

830

831 av_freep(&s->values);

832 }

833

834 static void draw_line(FFDrawContext *draw, int x0, int y0, int x1, int y1,

835 AVFrame *out, FFDrawColor *color)

836 {

837 int dx = FFABS(x1 - x0), sx = x0 < x1 ? 1 : -1;

838 int dy = FFABS(y1 - y0), sy = y0 < y1 ? 1 : -1;

839 int err = (dx > dy ? dx : -dy) / 2, e2;

840 int p, i;

841

842 for (;;) {

843 if (x0 >= 0 && y0 >= 0 && x0 < out->width && y0 < out->height) {

844 for (p = 0; p < draw->nb_planes; p++) {

845 if (draw->desc->comp[p].depth == 8) {

846 if (draw->nb_planes == 1) {

847 for (i = 0; i < draw->desc->nb_components; i++) {

848 out->data[0][y0 * out->linesize[0] + x0 * draw->pixelstep[0] + i] = color->comp[0].u8[i];

849 }

850 } else {

851 out->data[p][out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p])] = color->comp[p].u8[0];

852 }

853 } else {

854 if (draw->nb_planes == 1) {

855 for (i = 0; i < draw->desc->nb_components; i++) {

856 AV_WN16(out->data[0] + y0 * out->linesize[0] + (x0 * draw->pixelstep[0] + i), color->comp[0].u16[i]);

857 }

858 } else {

859 AV_WN16(out->data[p] + out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p]) * 2, color->comp[p].u16[0]);

860 }

861 }

862 }

863 }

864

865 if (x0 == x1 && y0 == y1)

866 break;

867

868 e2 = err;

869

870 if (e2 >-dx) {

871 err -= dy;

872 x0 += sx;

873 }

874

875 if (e2 < dy) {

876 err += dx;

877 y0 += sy;

878 }

879 }

880 }

881

882 static void draw_trace8(OscilloscopeContext *s, AVFrame *frame)

883 {

884 int i, c;

885

886 for (i = 1; i < s->nb_values; i++) {

887 for (c = 0; c < s->nb_comps; c++) {

888 if ((1 << c) & s->components) {

889 int x = i * s->width / s->nb_values;

890 int px = (i - 1) * s->width / s->nb_values;

891 int py = s->height - s->values[i-1].p[s->rgba_map[c]] * s->height / 256;

892 int y = s->height - s->values[i].p[s->rgba_map[c]] * s->height / 256;

893

894 draw_line(&s->draw, s->ox + x, s->oy + y, s->ox + px, s->oy + py, frame, s->colors[c]);

895 }

896 }

897 }

898 }

899

900

901 static void draw_trace16(OscilloscopeContext *s, AVFrame *frame)

902 {

903 int i, c;

904

905 for (i = 1; i < s->nb_values; i++) {

906 for (c = 0; c < s->nb_comps; c++) {

907 if ((1 << c) & s->components) {

908 int x = i * s->width / s->nb_values;

909 int px = (i - 1) * s->width / s->nb_values;

910 int py = s->height - s->values[i-1].p[s->rgba_map[c]] * s->height / s->max;

911 int y = s->height - s->values[i].p[s->rgba_map[c]] * s->height / s->max;

912

913 draw_line(&s->draw, s->ox + x, s->oy + y, s->ox + px, s->oy + py, frame, s->colors[c]);

914 }

915 }

916 }

917 }

918

919 static void update_oscilloscope(AVFilterContext *ctx)

920 {

921 OscilloscopeContext *s = ctx->priv;

922 AVFilterLink *inlink = ctx->inputs[0];

923 int cx, cy, size;

924 double tilt;

925

926 ff_draw_color(&s->draw, &s->dark, (uint8_t[]){ 0, 0, 0, s->o * 255} );

927 s->height = s->theight * inlink->h;

928 s->width = s->twidth * inlink->w;

929 size = hypot(inlink->w, inlink->h);

930 size *= s->size;

931 tilt = (s->tilt - 0.5) * M_PI;

932 cx = s->xpos * (inlink->w - 1);

933 cy = s->ypos * (inlink->h - 1);

934 s->x1 = cx - size / 2.0 * cos(tilt);

935 s->x2 = cx + size / 2.0 * cos(tilt);

936 s->y1 = cy - size / 2.0 * sin(tilt);

937 s->y2 = cy + size / 2.0 * sin(tilt);

938 s->ox = (inlink->w - s->width) * s->tx;

939 s->oy = (inlink->h - s->height) * s->ty;

940 }

941

942 static int oscilloscope_config_input(AVFilterLink *inlink)

943 {

944 AVFilterContext *ctx = inlink->dst;

945 OscilloscopeContext *s = ctx->priv;

946 int size;

947 int ret;

948

949 s->nb_planes = av_pix_fmt_count_planes(inlink->format);

950 ret = ff_draw_init(&s->draw, inlink->format, 0);

951 if (ret < 0) {

952 av_log(ctx, AV_LOG_ERROR, "Failed to initialize FFDrawContext\n");

953 return ret;

954 }

955 ff_draw_color(&s->draw, &s->black, (uint8_t[]){ 0, 0, 0, 255} );

956 ff_draw_color(&s->draw, &s->white, (uint8_t[]){ 255, 255, 255, 255} );

957 ff_draw_color(&s->draw, &s->green, (uint8_t[]){ 0, 255, 0, 255} );

958 ff_draw_color(&s->draw, &s->blue, (uint8_t[]){ 0, 0, 255, 255} );

959 ff_draw_color(&s->draw, &s->red, (uint8_t[]){ 255, 0, 0, 255} );

960 ff_draw_color(&s->draw, &s->cyan, (uint8_t[]){ 0, 255, 255, 255} );

961 ff_draw_color(&s->draw, &s->magenta, (uint8_t[]){ 255, 0, 255, 255} );

962 ff_draw_color(&s->draw, &s->gray, (uint8_t[]){ 128, 128, 128, 255} );

963 s->nb_comps = s->draw.desc->nb_components;

964 s->is_rgb = s->draw.desc->flags & AV_PIX_FMT_FLAG_RGB;

965

966 if (s->is_rgb) {

967 s->colors[0] = &s->red;

968 s->colors[1] = &s->green;

969 s->colors[2] = &s->blue;

970 s->colors[3] = &s->white;

971 ff_fill_rgba_map(s->rgba_map, inlink->format);

972 } else {

973 s->colors[0] = &s->white;

974 s->colors[1] = &s->cyan;

975 s->colors[2] = &s->magenta;

976 s->colors[3] = &s->white;

977 s->rgba_map[0] = 0;

978 s->rgba_map[1] = 1;

979 s->rgba_map[2] = 2;

980 s->rgba_map[3] = 3;

981 }

982

983 if (s->draw.desc->comp[0].depth <= 8) {

984 s->pick_color = pick_color8;

985 s->draw_trace = draw_trace8;

986 } else {

987 s->pick_color = pick_color16;

988 s->draw_trace = draw_trace16;

989 }

990

991 s->max = (1 << s->draw.desc->comp[0].depth);

992 size = hypot(inlink->w, inlink->h);

993

994 s->values = av_calloc(size, sizeof(*s->values));

995 if (!s->values)

996 return AVERROR(ENOMEM);

997

998 update_oscilloscope(inlink->dst);

999

1000 return 0;

1001 }

1002

1003 static void draw_scope(OscilloscopeContext *s, int x0, int y0, int x1, int y1,

1004 AVFrame *out, PixelValues *p, int state)

1005 {

1006 int dx = FFABS(x1 - x0), sx = x0 < x1 ? 1 : -1;

1007 int dy = FFABS(y1 - y0), sy = y0 < y1 ? 1 : -1;

1008 int err = (dx > dy ? dx : -dy) / 2, e2;

1009

1010 for (;;) {

1011 if (x0 >= 0 && y0 >= 0 && x0 < out->width && y0 < out->height) {

1012 FFDrawColor color = { { 0 } };

1013 int value[4] = { 0 };

1014

1015 s->pick_color(&s->draw, &color, out, x0, y0, value);

1016 s->values[s->nb_values].p[0] = value[0];

1017 s->values[s->nb_values].p[1] = value[1];

1018 s->values[s->nb_values].p[2] = value[2];

1019 s->values[s->nb_values].p[3] = value[3];

1020 s->nb_values++;

1021

1022 if (s->scope) {

1023 if (s->draw.desc->comp[0].depth == 8) {

1024 if (s->draw.nb_planes == 1) {

1025 int i;

1026

1027 for (i = 0; i < s->nb_comps; i++)

1028 out->data[0][out->linesize[0] * y0 + x0 * s->draw.pixelstep[0] + i] = 255 * ((s->nb_values + state) & 1);

1029 } else {

1030 out->data[0][out->linesize[0] * y0 + x0] = 255 * ((s->nb_values + state) & 1);

1031 }

1032 } else {

1033 if (s->draw.nb_planes == 1) {

1034 int i;

1035

1036 for (i = 0; i < s->nb_comps; i++)

1037 AV_WN16(out->data[0] + out->linesize[0] * y0 + x0 * s->draw.pixelstep[0] + i, (s->max - 1) * ((s->nb_values + state) & 1));

1038 } else {

1039 AV_WN16(out->data[0] + out->linesize[0] * y0 + 2 * x0, (s->max - 1) * ((s->nb_values + state) & 1));

1040 }

1041 }

1042 }

1043 }

1044

1045 if (x0 == x1 && y0 == y1)

1046 break;

1047

1048 e2 = err;

1049

1050 if (e2 >-dx) {

1051 err -= dy;

1052 x0 += sx;

1053 }

1054

1055 if (e2 < dy) {

1056 err += dx;

1057 y0 += sy;

1058 }

1059 }

1060 }

1061

1062 static int oscilloscope_filter_frame(AVFilterLink *inlink, AVFrame *frame)

1063 {

1064 FilterLink *inl = ff_filter_link(inlink);

1065 AVFilterContext *ctx = inlink->dst;

1066 OscilloscopeContext *s = ctx->priv;

1067 AVFilterLink *outlink = ctx->outputs[0];

1068 float average[4] = { 0 };

1069 int max[4] = { 0 };

1070 int min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };

1071 int i, c;

1072

1073 s->nb_values = 0;

1074 draw_scope(s, s->x1, s->y1, s->x2, s->y2, frame, s->values, inl->frame_count_in & 1);

1075 ff_blend_rectangle(&s->draw, &s->dark, frame->data, frame->linesize,

1076 frame->width, frame->height,

1077 s->ox, s->oy, s->width, s->height + 20 * s->statistics);

1078

1079 if (s->grid && outlink->h >= 10) {

1080 ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,

1081 s->ox, s->oy, s->width - 1, 1);

1082

1083 for (i = 1; i < 5; i++) {

1084 ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,

1085 s->ox, s->oy + i * (s->height - 1) / 4, s->width, 1);

1086 }

1087

1088 for (i = 0; i < 10; i++) {

1089 ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,

1090 s->ox + i * (s->width - 1) / 10, s->oy, 1, s->height);

1091 }

1092

1093 ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,

1094 s->ox + s->width - 1, s->oy, 1, s->height);

1095 }

1096

1097 s->draw_trace(s, frame);

1098

1099 for (i = 0; i < s->nb_values; i++) {

1100 for (c = 0; c < s->nb_comps; c++) {

1101 if ((1 << c) & s->components) {

1102 max[c] = FFMAX(max[c], s->values[i].p[s->rgba_map[c]]);

1103 min[c] = FFMIN(min[c], s->values[i].p[s->rgba_map[c]]);

1104 average[c] += s->values[i].p[s->rgba_map[c]];

1105 }

1106 }

1107 }

1108 for (c = 0; c < s->nb_comps; c++) {

1109 average[c] /= s->nb_values;

1110 }

1111

1112 if (s->statistics && s->height > 10 && s->width > 280 * av_popcount(s->components)) {

1113 for (c = 0, i = 0; c < s->nb_comps; c++) {

1114 if ((1 << c) & s->components) {

1115 const char rgba[4] = { 'R', 'G', 'B', 'A' };

1116 const char yuva[4] = { 'Y', 'U', 'V', 'A' };

1117 char text[128];

1118

1119 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]);

1120 draw_text(&s->draw, frame, &s->white, s->ox + 2 + 280 * i++, s->oy + s->height + 4, text, 0);

1121 }

1122 }

1123 }

1124

1125 return ff_filter_frame(outlink, frame);

1126 }

1127

1128 static int oscilloscope_process_command(AVFilterContext *ctx, const char *cmd, const char *args,

1129 char *res, int res_len, int flags)

1130 {

1131 int ret;

1132

1133 ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);

1134 if (ret < 0)

1135 return ret;

1136

1137 update_oscilloscope(ctx);

1138

1139 return 0;

1140 }

1141

1142 static const AVFilterPad oscilloscope_inputs[] = {

1143 {

1144 .name = "default",

1145 .type = AVMEDIA_TYPE_VIDEO,

1146 .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,

1147 .filter_frame = oscilloscope_filter_frame,

1148 .config_props = oscilloscope_config_input,

1149 },

1150 };

1151

1152 const FFFilter ff_vf_oscilloscope = {

1153 .p.name = "oscilloscope",

1154 .p.description = NULL_IF_CONFIG_SMALL("2D Video Oscilloscope."),

1155 .p.priv_class = &oscilloscope_class,

1156 .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

1157 .priv_size = sizeof(OscilloscopeContext),

1158 .uninit = oscilloscope_uninit,

1159 FILTER_INPUTS(oscilloscope_inputs),

1160 FILTER_OUTPUTS(ff_video_default_filterpad),

1161 FILTER_QUERY_FUNC2(query_formats),

1162 .process_command = oscilloscope_process_command,

1163 };

flags

const SwsFlags flags[]

Definition: swscale.c:61

OscilloscopeContext::o

float o

Definition: vf_datascope.c:772

ff_get_video_buffer

AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)

Request a picture buffer with a specific set of permissions.

Definition: video.c:117

@ W

Definition: vf_addroi.c:27

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

PixscopeContext::colors

FFDrawColor * colors[4]

Definition: vf_datascope.c:496

FFDrawColor

Definition: drawutils.h:52

DatascopeContext::components

int components

Definition: vf_datascope.c:39

DatascopeContext::x

int x

Definition: vf_datascope.c:35

reverse_color8

static void reverse_color8(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)

Definition: vf_datascope.c:148

pixscope_inputs

static const AVFilterPad pixscope_inputs[]

Definition: vf_datascope.c:739

OscilloscopeContext::oy

int oy

Definition: vf_datascope.c:779

filter_mono

static int filter_mono(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_datascope.c:270

AVERROR

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

opt.h

OscilloscopeContext::components

int components

Definition: vf_datascope.c:773

PixscopeContext::x

int x

Definition: vf_datascope.c:482

out

FILE * out

Definition: movenc.c:55

DatascopeContext::dformat

int dformat

Definition: vf_datascope.c:37

PixscopeContext::rgba_map

uint8_t rgba_map[4]

Definition: vf_datascope.c:488

color

Definition: vf_paletteuse.c:513

pixscope_process_command

static int pixscope_process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)

Definition: vf_datascope.c:727

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1067

filter_color2

static int filter_color2(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_datascope.c:180

OscilloscopeContext::theight

float theight

Definition: vf_datascope.c:771

ff_set_common_formats2

int ff_set_common_formats2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *formats)

Definition: formats.c:1124

inlink

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

Definition: filter_design.txt:212

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:64

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:263

DatascopeContext::gray

FFDrawColor gray

Definition: vf_datascope.c:49

mode

Definition: swscale.c:56

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

PixscopeContext::draw

FFDrawContext draw

Definition: vf_datascope.c:489

pixdesc.h

AVFrame::width

int width

Definition: frame.h:499

uint8_t w

Definition: llviddspenc.c:38

FFDrawColor::u16

uint16_t u16[8]

Definition: drawutils.h:56

AVOption

AVOption.

Definition: opt.h:429

OscilloscopeContext::ox

int ox

Definition: vf_datascope.c:779

FFDrawColor::rgba

uint8_t rgba[4]

Definition: drawutils.h:53

DatascopeContext::opacity

float opacity

Definition: vf_datascope.c:40

ff_vf_datascope

const FFFilter ff_vf_datascope

Definition: vf_datascope.c:462

PixscopeContext::dark

FFDrawColor dark

Definition: vf_datascope.c:490

max

#define max(a, b)

Definition: cuda_runtime.h:33

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

PixscopeContext::y

int y

Definition: vf_datascope.c:482

OFFSET

#define OFFSET(x)

Definition: vf_datascope.c:56

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:220

OOFFSET

#define OOFFSET(x)

Definition: vf_datascope.c:806

av_popcount

#define av_popcount

Definition: common.h:154

ThreadData::out

AVFrame * out

Definition: af_adeclick.c:526

pick_color8

static void pick_color8(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)

Definition: vf_datascope.c:112

video.h

ThreadData::in

AVFrame * in

Definition: af_adecorrelate.c:155

AVFilterLink

A link between two filters.

Definition: avfilter.h:395

OscilloscopeContext::max

int max

Definition: vf_datascope.c:782

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:448

D(D(float, sse)

Definition: rematrix_init.c:30

FilterLink

Link properties exposed to filter code, but not external callers.

Definition: filters.h:128

formats.h

OscilloscopeContext::white

FFDrawColor white

Definition: vf_datascope.c:790

#define px

Definition: ops_tmpl_float.c:35

OscilloscopeContext::draw_trace

void(* draw_trace)(struct OscilloscopeContext *s, AVFrame *frame)

Definition: vf_datascope.c:803

av_pix_fmt_count_planes

int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3496

OscilloscopeContext::gray

FFDrawColor gray

Definition: vf_datascope.c:796

slice_end

static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)

Handle slice ends.

Definition: mpeg12dec.c:1688

AVFilterContext::priv

void * priv

private data for use by the filter

Definition: avfilter.h:289

ThreadData::yoff

int yoff

Definition: vf_datascope.c:177

DatascopeContext::chars

int chars

Definition: vf_datascope.c:44

OscilloscopeContext::y1

int y1

Definition: vf_datascope.c:778

process_command

static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)

Definition: vf_datascope.c:433

ff_blend_mask

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.

Definition: drawutils.c:557

PixscopeContext::is_rgb

int is_rgb

Definition: vf_datascope.c:487

PixscopeContext::blue

FFDrawColor blue

Definition: vf_datascope.c:494

DatascopeContext::reverse_color

void(* reverse_color)(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)

Definition: vf_datascope.c:52

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:39

state

static struct @542 state

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

Definition: writing_filters.txt:58

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

update_oscilloscope

static void update_oscilloscope(AVFilterContext *ctx)

Definition: vf_datascope.c:919

PixscopeContext::values

uint16_t values[4][80][80]

Definition: vf_datascope.c:498

OscilloscopeContext::ty

float ty

Definition: vf_datascope.c:768

ff_video_default_filterpad

const AVFilterPad ff_video_default_filterpad[1]

An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.

Definition: video.c:37

PixscopeContext::w

int w

Definition: vf_datascope.c:479

FFFilter

Definition: filters.h:266

filter_color

static int filter_color(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_datascope.c:227

OscilloscopeContext::y2

int y2

Definition: vf_datascope.c:778

DatascopeContext::filter

int(* filter)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_datascope.c:53

OscilloscopeContext::ypos

float ypos

Definition: vf_datascope.c:767

intreadwrite.h

oscilloscope_uninit

static void oscilloscope_uninit(AVFilterContext *ctx)

Definition: vf_datascope.c:827

#define s(width, name)

Definition: cbs_vp9.c:198

PixelValues::p

uint16_t p[4]

Definition: vf_datascope.c:761

PixscopeContext::wy

float wy

Definition: vf_datascope.c:478

config_input

static int config_input(AVFilterLink *inlink)

Definition: vf_datascope.c:384

AVFilterLink::sample_aspect_ratio

AVRational sample_aspect_ratio

agreed upon sample aspect ratio

Definition: avfilter.h:409

inputs

static const AVFilterPad inputs[]

Definition: vf_datascope.c:445

filters.h

OscilloscopeContext::nb_planes

int nb_planes

Definition: vf_datascope.c:783

PixscopeContext::red

FFDrawColor red

Definition: vf_datascope.c:495

#define P

ctx

AVFormatContext * ctx

Definition: movenc.c:49

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:94

OscilloscopeContext::height

int height

Definition: vf_datascope.c:780

ff_draw_init

int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)

Definition: drawutils.c:174

pick_color16

static void pick_color16(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)

Definition: vf_datascope.c:130

DatascopeContext::draw

FFDrawContext draw

Definition: vf_datascope.c:45

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:264

PixscopeContext::green

FFDrawColor green

Definition: vf_datascope.c:493

OscilloscopeContext::nb_values

int nb_values

Definition: vf_datascope.c:799

reverse_color16

static void reverse_color16(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)

Definition: vf_datascope.c:160

arg

const char * arg

Definition: jacosubdec.c:67

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:74

POFFSET

#define POFFSET(x)

Definition: vf_datascope.c:503

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

av_frame_copy_props

int av_frame_copy_props(AVFrame *dst, const AVFrame *src)

Copy only "metadata" fields from src to dst.

Definition: frame.c:599

format

New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format

Definition: swscale-v2.txt:14

PixscopeContext::white

FFDrawColor white

Definition: vf_datascope.c:492

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

OscilloscopeContext::magenta

FFDrawColor magenta

Definition: vf_datascope.c:795

AV_OPT_TYPE_IMAGE_SIZE

@ AV_OPT_TYPE_IMAGE_SIZE

Underlying C type is two consecutive integers.

Definition: opt.h:303

DatascopeContext

Definition: vf_datascope.c:32

OscilloscopeContext::colors

FFDrawColor * colors[4]

Definition: vf_datascope.c:797

DatascopeContext::oh

int oh

Definition: vf_datascope.c:34

datascope_options

static const AVOption datascope_options[]

Definition: vf_datascope.c:60

oscilloscope_options

static const AVOption oscilloscope_options[]

Definition: vf_datascope.c:808

double

Definition: af_crystalizer.c:132

PixscopeContext::nb_planes

int nb_planes

Definition: vf_datascope.c:485

FFDrawColor::u8

uint8_t u8[16]

Definition: drawutils.h:57

DatascopeContext::pick_color

void(* pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)

Definition: vf_datascope.c:51

OscilloscopeContext::tx

float tx

Definition: vf_datascope.c:768

draw_trace8

static void draw_trace8(OscilloscopeContext *s, AVFrame *frame)

Definition: vf_datascope.c:882

PixscopeContext::o

float o

Definition: vf_datascope.c:480

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

Definition: undefined.txt:32

AVFilterFormatsConfig

Lists of formats / etc.

Definition: avfilter.h:121

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:198

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(datascope)

OscilloscopeContext::red

FFDrawColor red

Definition: vf_datascope.c:793

draw_trace16

static void draw_trace16(OscilloscopeContext *s, AVFrame *frame)

Definition: vf_datascope.c:901

DatascopeContext::ow

int ow

Definition: vf_datascope.c:34

OscilloscopeContext::nb_comps

int nb_comps

Definition: vf_datascope.c:784

AVFILTERPAD_FLAG_NEEDS_WRITABLE

#define AVFILTERPAD_FLAG_NEEDS_WRITABLE

The filter expects writable frames from its input link, duplicating data buffers if needed.

Definition: filters.h:58

PixscopeContext::wh

int wh

Definition: vf_datascope.c:483

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:94

filter_frame

static int filter_frame(AVFilterLink *inlink, AVFrame *in)

Definition: vf_datascope.c:312

DatascopeContext::mode

int mode

Definition: vf_datascope.c:36

height

#define height

Definition: dsp.h:89

FLAGS

#define FLAGS

Definition: vf_datascope.c:57

AV_PIX_FMT_FLAG_RGB

#define AV_PIX_FMT_FLAG_RGB

The pixel format contains RGB-like data (as opposed to YUV/grayscale).

Definition: pixdesc.h:136

ThreadData::PP

int PP

Definition: vf_datascope.c:177

ff_blend_rectangle

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.

Definition: drawutils.c:378

av_frame_copy

int av_frame_copy(AVFrame *dst, const AVFrame *src)

Copy the frame data from src to dst.

Definition: frame.c:711

oscilloscope_process_command

static int oscilloscope_process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)

Definition: vf_datascope.c:1128

hypot

static av_const double hypot(double x, double y)

Definition: libm.h:368

FFDrawColor::comp

union FFDrawColor::@357 comp[MAX_PLANES]

outputs

static const AVFilterPad outputs[]

Definition: vf_datascope.c:454

size

int size

Definition: twinvq_data.h:10344

color

static const uint32_t color[16+AV_CLASS_CATEGORY_NB]

Definition: log.c:97

avpriv_cga_font_get

const uint8_t * avpriv_cga_font_get(void)

Definition: xga_font_data.c:163

draw_text

static void draw_text(FFDrawContext *draw, AVFrame *frame, FFDrawColor *color, int x0, int y0, const uint8_t *text, int vertical)

Definition: vf_datascope.c:88

oscilloscope_inputs

static const AVFilterPad oscilloscope_inputs[]

Definition: vf_datascope.c:1142

ff_fill_rectangle

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.

Definition: drawutils.c:258

OscilloscopeContext::cyan

FFDrawColor cyan

Definition: vf_datascope.c:794

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:396

ff_filter_process_command

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.

Definition: avfilter.c:905

pixscope_filter_frame

static int pixscope_filter_frame(AVFilterLink *inlink, AVFrame *in)

Definition: vf_datascope.c:582

@ X

Definition: vf_addroi.c:27

ff_vf_oscilloscope

const FFFilter ff_vf_oscilloscope

Definition: vf_datascope.c:1152

#define H

Definition: pixlet.c:39

OscilloscopeContext::pick_color

void(* pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)

Definition: vf_datascope.c:802

OscilloscopeContext::size

float size

Definition: vf_datascope.c:769

xga_font_data.h

OscilloscopeContext::x1

int x1

Definition: vf_datascope.c:778

DatascopeContext::nb_comps

int nb_comps

Definition: vf_datascope.c:43

M_PI

#define M_PI

Definition: mathematics.h:67

#define Y

Definition: boxblur.h:37

draw

static int draw(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: avf_showcwt.c:440

AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

Some filters support a generic "enable" expression option that can be used to enable or disable a fil...

Definition: avfilter.h:197

AV_OPT_TYPE_FLOAT

@ AV_OPT_TYPE_FLOAT

Underlying C type is float.

Definition: opt.h:271

OscilloscopeContext::scope

int scope

Definition: vf_datascope.c:776

uninit

static void uninit(AVBSFContext *ctx)

Definition: pcm_rechunk.c:68

OscilloscopeContext

Definition: vf_datascope.c:764

OscilloscopeContext::black

FFDrawColor black

Definition: vf_datascope.c:789

PixscopeContext

Definition: vf_datascope.c:474

OscilloscopeContext::rgba_map

uint8_t rgba_map[4]

Definition: vf_datascope.c:786

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

SQR

#define SQR(x)

Definition: vf_datascope.c:580

DatascopeContext::white

FFDrawColor white

Definition: vf_datascope.c:47

OscilloscopeContext::tilt

float tilt

Definition: vf_datascope.c:770

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:407

DatascopeContext::y

int y

Definition: vf_datascope.c:35

OscilloscopeContext::statistics

int statistics

Definition: vf_datascope.c:775

ff_draw_supported_pixel_formats

AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)

Return the list of pixel formats supported by the draw functions.

Definition: drawutils.c:670

ff_filter_get_nb_threads

int ff_filter_get_nb_threads(AVFilterContext *ctx)

Get number of threads for current filter instance.

Definition: avfilter.c:845

OscilloscopeContext::green

FFDrawColor green

Definition: vf_datascope.c:791

OscilloscopeContext::xpos

float xpos

Definition: vf_datascope.c:767

ThreadData

Used for passing data between threads.

Definition: dsddec.c:71

FILTER_QUERY_FUNC2

#define FILTER_QUERY_FUNC2(func)

Definition: filters.h:240

value

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

Definition: writing_filters.txt:86

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

DatascopeContext::black

FFDrawColor black

Definition: vf_datascope.c:48

DatascopeContext::axis

int axis

Definition: vf_datascope.c:38

FFDrawContext

Definition: drawutils.h:36

OscilloscopeContext::dark

FFDrawColor dark

Definition: vf_datascope.c:788

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:45

FLAGSR

#define FLAGSR

Definition: vf_datascope.c:58

OscilloscopeContext::is_rgb

int is_rgb

Definition: vf_datascope.c:785

DatascopeContext::nb_planes

int nb_planes

Definition: vf_datascope.c:42

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

ff_draw_color

void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])

Prepare a color.

Definition: drawutils.c:179

slice_start

static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)

Definition: dec.c:845

PixscopeContext::pick_color

void(* pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)

Definition: vf_datascope.c:500

ThreadData::xoff

int xoff

Definition: vf_datascope.c:177

ret

Definition: filter_design.txt:187

PixscopeContext::black

FFDrawColor black

Definition: vf_datascope.c:491

frame

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

Definition: filter_design.txt:265

OscilloscopeContext::draw

FFDrawContext draw

Definition: vf_datascope.c:787

OscilloscopeContext::twidth

float twidth

Definition: vf_datascope.c:771

AVFrame::height

int height

Definition: frame.h:499

OscilloscopeContext::grid

int grid