FFmpeg: libavfilter/f_sendcmd.c Source File

FFmpeg

[フレーム]

libavfilter

f_sendcmd.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 /**

22 * @file

23 * send commands filter

24 */

26 #include "config_components.h"

28 #include "libavutil/avstring.h"

29 #include "libavutil/bprint.h"

30 #include "libavutil/eval.h"

31 #include "libavutil/file.h"

32 #include "libavutil/mem.h"

33 #include "libavutil/opt.h"

34 #include "libavutil/parseutils.h"

35 #include "avfilter.h"

36 #include "filters.h"

37 #include "audio.h"

38 #include "video.h"

40 #define COMMAND_FLAG_ENTER 1

41 #define COMMAND_FLAG_LEAVE 2

42 #define COMMAND_FLAG_EXPR 4

44 static const char *const var_names[] = {

45 "N", /* frame number */

46 "T", /* frame time in seconds */

47 #if FF_API_FRAME_PKT

48 "POS", /* original position in the file of the frame */

49 #endif

50 "PTS", /* frame pts */

51 "TS", /* interval start time in seconds */

52 "TE", /* interval end time in seconds */

53 "TI", /* interval interpolated value: TI = (T - TS) / (TE - TS) */

54 "W", /* width for video frames */

55 "H", /* height for video frames */

56 NULL

57 };

59 enum var_name {

60 VAR_N,

61 VAR_T,

62 #if FF_API_FRAME_PKT

63 VAR_POS,

64 #endif

65 VAR_PTS,

66 VAR_TS,

67 VAR_TE,

68 VAR_TI,

69 VAR_W,

70 VAR_H,

71 VAR_VARS_NB

72 };

74 static inline char *make_command_flags_str(AVBPrint *pbuf, int flags)

75 {

76 static const char * const flag_strings[] = { "enter", "leave", "expr" };

77 int i, is_first = 1;

79 av_bprint_init(pbuf, 0, AV_BPRINT_SIZE_AUTOMATIC);

80 for (i = 0; i < FF_ARRAY_ELEMS(flag_strings); i++) {

81 if (flags & 1<<i) {

82 if (!is_first)

83 av_bprint_chars(pbuf, '+', 1);

84 av_bprintf(pbuf, "%s", flag_strings[i]);

85 is_first = 0;

86 }

87 }

89 return pbuf->str;

90 }

92 typedef struct Command {

93 int flags;

94 char *target, *command, *arg;

95 int index;

96 } Command;

98 typedef struct Interval {

99 int64_t start_ts; ///< start timestamp expressed as microseconds units

100 int64_t end_ts; ///< end timestamp expressed as microseconds units

101 int index; ///< unique index for these interval commands

102 Command *commands;

103 int nb_commands;

104 int enabled; ///< current time detected inside this interval

105 } Interval;

106

107 typedef struct SendCmdContext {

108 const AVClass *class;

109 Interval *intervals;

110 int nb_intervals;

111

112 char *commands_filename;

113 char *commands_str;

114 } SendCmdContext;

115

116 #define OFFSET(x) offsetof(SendCmdContext, x)

117 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM

118 static const AVOption options[] = {

119 { "commands", "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

120 { "c", "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

121 { "filename", "set commands file", OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

122 { "f", "set commands file", OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

123 { NULL }

124 };

125

126 #define SPACES " \f\t\n\r"

127

128 static void skip_comments(const char **buf)

129 {

130 while (**buf) {

131 /* skip leading spaces */

132 *buf += strspn(*buf, SPACES);

133 if (**buf != '#')

134 break;

135

136 (*buf)++;

137

138 /* skip comment until the end of line */

139 *buf += strcspn(*buf, "\n");

140 if (**buf)

141 (*buf)++;

142 }

143 }

144

145 #define COMMAND_DELIMS " \f\t\n\r,;"

146

147 static int parse_command(Command *cmd, int cmd_count, int interval_count,

148 const char **buf, void *log_ctx)

149 {

150 int ret;

151

152 memset(cmd, 0, sizeof(Command));

153 cmd->index = cmd_count;

154

155 /* format: [FLAGS] target command arg */

156 *buf += strspn(*buf, SPACES);

157

158 /* parse flags */

159 if (**buf == '[') {

160 (*buf)++; /* skip "[" */

161

162 while (**buf) {

163 int len = strcspn(*buf, "|+]");

164

165 if (!strncmp(*buf, "enter", strlen("enter"))) cmd->flags |= COMMAND_FLAG_ENTER;

166 else if (!strncmp(*buf, "leave", strlen("leave"))) cmd->flags |= COMMAND_FLAG_LEAVE;

167 else if (!strncmp(*buf, "expr", strlen("expr"))) cmd->flags |= COMMAND_FLAG_EXPR;

168 else {

169 char flag_buf[64];

170 av_strlcpy(flag_buf, *buf, sizeof(flag_buf));

171 av_log(log_ctx, AV_LOG_ERROR,

172 "Unknown flag '%s' in interval #%d, command #%d\n",

173 flag_buf, interval_count, cmd_count);

174 return AVERROR(EINVAL);

175 }

176 *buf += len;

177 if (**buf == ']')

178 break;

179 if (!strspn(*buf, "+|")) {

180 av_log(log_ctx, AV_LOG_ERROR,

181 "Invalid flags char '%c' in interval #%d, command #%d\n",

182 **buf, interval_count, cmd_count);

183 return AVERROR(EINVAL);

184 }

185 if (**buf)

186 (*buf)++;

187 }

188

189 if (**buf != ']') {

190 av_log(log_ctx, AV_LOG_ERROR,

191 "Missing flag terminator or extraneous data found at the end of flags "

192 "in interval #%d, command #%d\n", interval_count, cmd_count);

193 return AVERROR(EINVAL);

194 }

195 (*buf)++; /* skip "]" */

196 } else {

197 cmd->flags = COMMAND_FLAG_ENTER;

198 }

199

200 *buf += strspn(*buf, SPACES);

201 cmd->target = av_get_token(buf, COMMAND_DELIMS);

202 if (!cmd->target || !cmd->target[0]) {

203 av_log(log_ctx, AV_LOG_ERROR,

204 "No target specified in interval #%d, command #%d\n",

205 interval_count, cmd_count);

206 ret = AVERROR(EINVAL);

207 goto fail;

208 }

209

210 *buf += strspn(*buf, SPACES);

211 cmd->command = av_get_token(buf, COMMAND_DELIMS);

212 if (!cmd->command || !cmd->command[0]) {

213 av_log(log_ctx, AV_LOG_ERROR,

214 "No command specified in interval #%d, command #%d\n",

215 interval_count, cmd_count);

216 ret = AVERROR(EINVAL);

217 goto fail;

218 }

219

220 *buf += strspn(*buf, SPACES);

221 cmd->arg = av_get_token(buf, COMMAND_DELIMS);

222

223 return 1;

224

225 fail:

226 av_freep(&cmd->target);

227 av_freep(&cmd->command);

228 av_freep(&cmd->arg);

229 return ret;

230 }

231

232 static int parse_commands(Command **cmds, int *nb_cmds, int interval_count,

233 const char **buf, void *log_ctx)

234 {

235 int cmd_count = 0;

236 int ret, n = 0;

237 AVBPrint pbuf;

238

239 *cmds = NULL;

240 *nb_cmds = 0;

241

242 while (**buf) {

243 Command cmd;

244

245 if ((ret = parse_command(&cmd, cmd_count, interval_count, buf, log_ctx)) < 0)

246 return ret;

247 cmd_count++;

248

249 /* (re)allocate commands array if required */

250 if (*nb_cmds == n) {

251 n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */

252 *cmds = av_realloc_f(*cmds, n, 2*sizeof(Command));

253 if (!*cmds) {

254 av_log(log_ctx, AV_LOG_ERROR,

255 "Could not (re)allocate command array\n");

256 return AVERROR(ENOMEM);

257 }

258 }

259

260 (*cmds)[(*nb_cmds)++] = cmd;

261

262 *buf += strspn(*buf, SPACES);

263 if (**buf && **buf != ';' && **buf != ',') {

264 av_log(log_ctx, AV_LOG_ERROR,

265 "Missing separator or extraneous data found at the end of "

266 "interval #%d, in command #%d\n",

267 interval_count, cmd_count);

268 av_log(log_ctx, AV_LOG_ERROR,

269 "Command was parsed as: flags:[%s] target:%s command:%s arg:%s\n",

270 make_command_flags_str(&pbuf, cmd.flags), cmd.target, cmd.command, cmd.arg);

271 return AVERROR(EINVAL);

272 }

273 if (**buf == ';')

274 break;

275 if (**buf == ',')

276 (*buf)++;

277 }

278

279 return 0;

280 }

281

282 #define DELIMS " \f\t\n\r,;"

283

284 static int parse_interval(Interval *interval, int interval_count,

285 const char **buf, void *log_ctx)

286 {

287 char *intervalstr;

288 int ret;

289

290 *buf += strspn(*buf, SPACES);

291 if (!**buf)

292 return 0;

293

294 /* reset data */

295 memset(interval, 0, sizeof(Interval));

296 interval->index = interval_count;

297

298 /* format: INTERVAL COMMANDS */

299

300 /* parse interval */

301 intervalstr = av_get_token(buf, DELIMS);

302 if (intervalstr && intervalstr[0]) {

303 char *start, *end;

304

305 start = av_strtok(intervalstr, "-", &end);

306 if (!start) {

307 ret = AVERROR(EINVAL);

308 av_log(log_ctx, AV_LOG_ERROR,

309 "Invalid interval specification '%s' in interval #%d\n",

310 intervalstr, interval_count);

311 goto end;

312 }

313 if ((ret = av_parse_time(&interval->start_ts, start, 1)) < 0) {

314 av_log(log_ctx, AV_LOG_ERROR,

315 "Invalid start time specification '%s' in interval #%d\n",

316 start, interval_count);

317 goto end;

318 }

319

320 if (end) {

321 if ((ret = av_parse_time(&interval->end_ts, end, 1)) < 0) {

322 av_log(log_ctx, AV_LOG_ERROR,

323 "Invalid end time specification '%s' in interval #%d\n",

324 end, interval_count);

325 goto end;

326 }

327 } else {

328 interval->end_ts = INT64_MAX;

329 }

330 if (interval->end_ts < interval->start_ts) {

331 av_log(log_ctx, AV_LOG_ERROR,

332 "Invalid end time '%s' in interval #%d: "

333 "cannot be lesser than start time '%s'\n",

334 end, interval_count, start);

335 ret = AVERROR(EINVAL);

336 goto end;

337 }

338 } else {

339 av_log(log_ctx, AV_LOG_ERROR,

340 "No interval specified for interval #%d\n", interval_count);

341 ret = AVERROR(EINVAL);

342 goto end;

343 }

344

345 /* parse commands */

346 ret = parse_commands(&interval->commands, &interval->nb_commands,

347 interval_count, buf, log_ctx);

348

349 end:

350 av_free(intervalstr);

351 return ret;

352 }

353

354 static int parse_intervals(Interval **intervals, int *nb_intervals,

355 const char *buf, void *log_ctx)

356 {

357 int interval_count = 0;

358 int ret, n = 0;

359

360 *intervals = NULL;

361 *nb_intervals = 0;

362

363 if (!buf)

364 return 0;

365

366 while (1) {

367 Interval interval;

368

369 skip_comments(&buf);

370 if (!(*buf))

371 break;

372

373 if ((ret = parse_interval(&interval, interval_count, &buf, log_ctx)) < 0)

374 return ret;

375

376 buf += strspn(buf, SPACES);

377 if (*buf) {

378 if (*buf != ';') {

379 av_log(log_ctx, AV_LOG_ERROR,

380 "Missing terminator or extraneous data found at the end of interval #%d\n",

381 interval_count);

382 return AVERROR(EINVAL);

383 }

384 buf++; /* skip ';' */

385 }

386 interval_count++;

387

388 /* (re)allocate commands array if required */

389 if (*nb_intervals == n) {

390 n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */

391 *intervals = av_realloc_f(*intervals, n, 2*sizeof(Interval));

392 if (!*intervals) {

393 av_log(log_ctx, AV_LOG_ERROR,

394 "Could not (re)allocate intervals array\n");

395 return AVERROR(ENOMEM);

396 }

397 }

398

399 (*intervals)[(*nb_intervals)++] = interval;

400 }

401

402 return 0;

403 }

404

405 static int cmp_intervals(const void *a, const void *b)

406 {

407 const Interval *i1 = a;

408 const Interval *i2 = b;

409 return 2 * FFDIFFSIGN(i1->start_ts, i2->start_ts) + FFDIFFSIGN(i1->index, i2->index);

410 }

411

412 static av_cold int init(AVFilterContext *ctx)

413 {

414 SendCmdContext *s = ctx->priv;

415 int ret, i, j;

416

417 if ((!!s->commands_filename + !!s->commands_str) != 1) {

418 av_log(ctx, AV_LOG_ERROR,

419 "One and only one of the filename or commands options must be specified\n");

420 return AVERROR(EINVAL);

421 }

422

423 if (s->commands_filename) {

424 uint8_t *file_buf, *buf;

425 size_t file_bufsize;

426 ret = av_file_map(s->commands_filename,

427 &file_buf, &file_bufsize, 0, ctx);

428 if (ret < 0)

429 return ret;

430

431 /* create a 0-terminated string based on the read file */

432 buf = av_malloc(file_bufsize + 1);

433 if (!buf) {

434 av_file_unmap(file_buf, file_bufsize);

435 return AVERROR(ENOMEM);

436 }

437 memcpy(buf, file_buf, file_bufsize);

438 buf[file_bufsize] = 0;

439 av_file_unmap(file_buf, file_bufsize);

440 s->commands_str = buf;

441 }

442

443 if ((ret = parse_intervals(&s->intervals, &s->nb_intervals,

444 s->commands_str, ctx)) < 0)

445 return ret;

446

447 if (s->nb_intervals == 0) {

448 av_log(ctx, AV_LOG_ERROR, "No commands were specified\n");

449 return AVERROR(EINVAL);

450 }

451

452 qsort(s->intervals, s->nb_intervals, sizeof(Interval), cmp_intervals);

453

454 av_log(ctx, AV_LOG_DEBUG, "Parsed commands:\n");

455 for (i = 0; i < s->nb_intervals; i++) {

456 AVBPrint pbuf;

457 Interval *interval = &s->intervals[i];

458 av_log(ctx, AV_LOG_VERBOSE, "start_time:%f end_time:%f index:%d\n",

459 (double)interval->start_ts/1000000, (double)interval->end_ts/1000000, interval->index);

460 for (j = 0; j < interval->nb_commands; j++) {

461 Command *cmd = &interval->commands[j];

462 av_log(ctx, AV_LOG_VERBOSE,

463 " [%s] target:%s command:%s arg:%s index:%d\n",

464 make_command_flags_str(&pbuf, cmd->flags), cmd->target, cmd->command, cmd->arg, cmd->index);

465 }

466 }

467

468 return 0;

469 }

470

471 static av_cold void uninit(AVFilterContext *ctx)

472 {

473 SendCmdContext *s = ctx->priv;

474 int i, j;

475

476 for (i = 0; i < s->nb_intervals; i++) {

477 Interval *interval = &s->intervals[i];

478 for (j = 0; j < interval->nb_commands; j++) {

479 Command *cmd = &interval->commands[j];

480 av_freep(&cmd->target);

481 av_freep(&cmd->command);

482 av_freep(&cmd->arg);

483 }

484 av_freep(&interval->commands);

485 }

486 av_freep(&s->intervals);

487 }

488

489 static int filter_frame(AVFilterLink *inlink, AVFrame *ref)

490 {

491 FilterLink *inl = ff_filter_link(inlink);

492 AVFilterContext *ctx = inlink->dst;

493 SendCmdContext *s = ctx->priv;

494 int64_t ts;

495 int i, j, ret;

496

497 if (ref->pts == AV_NOPTS_VALUE)

498 goto end;

499

500 ts = av_rescale_q(ref->pts, inlink->time_base, AV_TIME_BASE_Q);

501

502 #define WITHIN_INTERVAL(ts, start_ts, end_ts) ((ts) >= (start_ts) && (ts) < (end_ts))

503

504 for (i = 0; i < s->nb_intervals; i++) {

505 Interval *interval = &s->intervals[i];

506 int flags = 0;

507

508 if (!interval->enabled && WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {

509 flags += COMMAND_FLAG_ENTER;

510 interval->enabled = 1;

511 }

512 if (interval->enabled && !WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {

513 flags += COMMAND_FLAG_LEAVE;

514 interval->enabled = 0;

515 }

516 if (interval->enabled)

517 flags += COMMAND_FLAG_EXPR;

518

519 if (flags) {

520 AVBPrint pbuf;

521 av_log(ctx, AV_LOG_VERBOSE,

522 "[%s] interval #%d start_ts:%f end_ts:%f ts:%f\n",

523 make_command_flags_str(&pbuf, flags), interval->index,

524 (double)interval->start_ts/1000000, (double)interval->end_ts/1000000,

525 (double)ts/1000000);

526

527 for (j = 0; flags && j < interval->nb_commands; j++) {

528 Command *cmd = &interval->commands[j];

529 char *cmd_arg = cmd->arg;

530 char buf[1024];

531

532 if (cmd->flags & flags) {

533 if (cmd->flags & COMMAND_FLAG_EXPR) {

534 double var_values[VAR_VARS_NB], res;

535 double start = TS2T(interval->start_ts, AV_TIME_BASE_Q);

536 double end = TS2T(interval->end_ts, AV_TIME_BASE_Q);

537 double current = TS2T(ref->pts, inlink->time_base);

538

539 var_values[VAR_N] = inl->frame_count_in;

540 #if FF_API_FRAME_PKT

541 FF_DISABLE_DEPRECATION_WARNINGS

542 var_values[VAR_POS] = ref->pkt_pos == -1 ? NAN : ref->pkt_pos;

543 FF_ENABLE_DEPRECATION_WARNINGS

544 #endif

545 var_values[VAR_PTS] = TS2D(ref->pts);

546 var_values[VAR_T] = current;

547 var_values[VAR_TS] = start;

548 var_values[VAR_TE] = end;

549 var_values[VAR_TI] = (current - start) / (end - start);

550 var_values[VAR_W] = ref->width;

551 var_values[VAR_H] = ref->height;

552

553 if ((ret = av_expr_parse_and_eval(&res, cmd->arg, var_names, var_values,

554 NULL, NULL, NULL, NULL, NULL, 0, NULL)) < 0) {

555 av_log(ctx, AV_LOG_ERROR, "Invalid expression '%s' for command argument.\n", cmd->arg);

556 av_frame_free(&ref);

557 return AVERROR(EINVAL);

558 }

559

560 cmd_arg = av_asprintf("%g", res);

561 if (!cmd_arg) {

562 av_frame_free(&ref);

563 return AVERROR(ENOMEM);

564 }

565 }

566 av_log(ctx, AV_LOG_VERBOSE,

567 "Processing command #%d target:%s command:%s arg:%s\n",

568 cmd->index, cmd->target, cmd->command, cmd_arg);

569 ret = avfilter_graph_send_command(inl->graph,

570 cmd->target, cmd->command, cmd_arg,

571 buf, sizeof(buf),

572 AVFILTER_CMD_FLAG_ONE);

573 av_log(ctx, AV_LOG_VERBOSE,

574 "Command reply for command #%d: ret:%s res:%s\n",

575 cmd->index, av_err2str(ret), buf);

576 if (cmd->flags & COMMAND_FLAG_EXPR)

577 av_freep(&cmd_arg);

578 }

579 }

580 }

581 }

582

583 end:

584 switch (inlink->type) {

585 case AVMEDIA_TYPE_VIDEO:

586 case AVMEDIA_TYPE_AUDIO:

587 return ff_filter_frame(inlink->dst->outputs[0], ref);

588 }

589

590 return AVERROR(ENOSYS);

591 }

592

593 AVFILTER_DEFINE_CLASS_EXT(sendcmd, "(a)sendcmd", options);

594

595 #if CONFIG_SENDCMD_FILTER

596

597 static const AVFilterPad sendcmd_inputs[] = {

598 {

599 .name = "default",

600 .type = AVMEDIA_TYPE_VIDEO,

601 .filter_frame = filter_frame,

602 },

603 };

604

605 const AVFilter ff_vf_sendcmd = {

606 .name = "sendcmd",

607 .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),

608 .init = init,

609 .uninit = uninit,

610 .priv_size = sizeof(SendCmdContext),

611 .flags = AVFILTER_FLAG_METADATA_ONLY,

612 FILTER_INPUTS(sendcmd_inputs),

613 FILTER_OUTPUTS(ff_video_default_filterpad),

614 .priv_class = &sendcmd_class,

615 };

616

617 #endif

618

619 #if CONFIG_ASENDCMD_FILTER

620

621 static const AVFilterPad asendcmd_inputs[] = {

622 {

623 .name = "default",

624 .type = AVMEDIA_TYPE_AUDIO,

625 .filter_frame = filter_frame,

626 },

627 };

628

629 const AVFilter ff_af_asendcmd = {

630 .name = "asendcmd",

631 .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),

632 .priv_class = &sendcmd_class,

633 .init = init,

634 .uninit = uninit,

635 .priv_size = sizeof(SendCmdContext),

636 .flags = AVFILTER_FLAG_METADATA_ONLY,

637 FILTER_INPUTS(asendcmd_inputs),

638 FILTER_OUTPUTS(ff_audio_default_filterpad),

639 };

640

641 #endif

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:73

AVFILTER_CMD_FLAG_ONE

#define AVFILTER_CMD_FLAG_ONE

Stop once a filter understood the command (for target=all for example), fast filters are favored auto...

Definition: avfilter.h:640

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

WITHIN_INTERVAL

#define WITHIN_INTERVAL(ts, start_ts, end_ts)

var_name

Definition: noise.c:47

VAR_T

@ VAR_T

Definition: f_sendcmd.c:61

av_bprint_init

void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)

Definition: bprint.c:69

make_command_flags_str

static char * make_command_flags_str(AVBPrint *pbuf, int flags)

Definition: f_sendcmd.c:74

VAR_TE

@ VAR_TE

Definition: f_sendcmd.c:67

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1023

COMMAND_DELIMS

#define COMMAND_DELIMS

Definition: f_sendcmd.c:145

cmp_intervals

static int cmp_intervals(const void *a, const void *b)

Definition: f_sendcmd.c:405

parse_command

static int parse_command(Command *cmd, int cmd_count, int interval_count, const char **buf, void *log_ctx)

Definition: f_sendcmd.c:147

AV_TIME_BASE_Q

#define AV_TIME_BASE_Q

Internal time base represented as fractional value.

Definition: avutil.h:264

int64_t

long long int64_t

Definition: coverity.c:34

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_asprintf

char * av_asprintf(const char *fmt,...)

Definition: avstring.c:115

VAR_H

@ VAR_H

Definition: f_sendcmd.c:70

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:162

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:262

AVFrame

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

Definition: frame.h:389

VAR_TI

@ VAR_TI

Definition: f_sendcmd.c:68

AVOption

AVOption.

Definition: opt.h:429

#define b

Definition: input.c:41

DELIMS

#define DELIMS

Definition: f_sendcmd.c:282

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

Interval::index

int index

unique index for these interval commands

Definition: f_sendcmd.c:101

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:205

video.h

AVFilterLink

A link between two filters.

Definition: avfilter.h:557

SendCmdContext::commands_str

char * commands_str

Definition: f_sendcmd.c:113

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

FilterLink

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

Definition: filters.h:127

COMMAND_FLAG_LEAVE

#define COMMAND_FLAG_LEAVE

Definition: f_sendcmd.c:41

Command::target

char * target

Definition: f_sendcmd.c:94

av_file_map

int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, int log_offset, void *log_ctx)

Read the file with name filename, and put its content in a newly allocated buffer or map it with mmap...

Definition: file.c:55

Command::command

char * command

Definition: f_sendcmd.c:94

fail

#define fail()

Definition: checkasm.h:188

AV_BPRINT_SIZE_AUTOMATIC

#define AV_BPRINT_SIZE_AUTOMATIC

Interval::nb_commands

int nb_commands

Definition: f_sendcmd.c:103

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:38

FFDIFFSIGN

#define FFDIFFSIGN(x, y)

Comparator.

Definition: macros.h:45

OFFSET

#define OFFSET(x)

Definition: f_sendcmd.c:116

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

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

#define s(width, name)

Definition: cbs_vp9.c:198

VAR_TS

@ VAR_TS

Definition: f_sendcmd.c:66

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

COMMAND_FLAG_ENTER

#define COMMAND_FLAG_ENTER

Definition: f_sendcmd.c:40

av_strtok

char * av_strtok(char *s, const char *delim, char **saveptr)

Split the string into several tokens which can be accessed by successive calls to av_strtok().

Definition: avstring.c:178

filters.h

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

ctx

AVFormatContext * ctx

Definition: movenc.c:49

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

parse_interval

static int parse_interval(Interval *interval, int interval_count, const char **buf, void *log_ctx)

Definition: f_sendcmd.c:284

Command

Definition: f_sendcmd.c:92

SendCmdContext::commands_filename

char * commands_filename

Definition: f_sendcmd.c:112

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:263

NAN

#define NAN

Definition: mathematics.h:115

av_file_unmap

void av_file_unmap(uint8_t *bufptr, size_t size)

Unmap or free the buffer bufptr created by av_file_map().

Definition: file.c:142

options

static const AVOption options[]

Definition: f_sendcmd.c:118

av_realloc_f

#define av_realloc_f(p, o, n)

Definition: tableprint_vlc.h:32

FLAGS

#define FLAGS

Definition: f_sendcmd.c:117

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: f_sendcmd.c:471

NULL

#define NULL

Definition: coverity.c:32

SendCmdContext

Definition: f_sendcmd.c:107

VAR_POS

@ VAR_POS

Definition: noise.c:56

cmds

static const char *const cmds[]

Definition: jacosubdec.c:72

parseutils.h

ff_audio_default_filterpad

const AVFilterPad ff_audio_default_filterpad[1]

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

Definition: audio.c:34

av_parse_time

int av_parse_time(int64_t *timeval, const char *timestr, int duration)

Parse timestr and return in *time a corresponding number of microseconds.

Definition: parseutils.c:589

Interval::end_ts

int64_t end_ts

end timestamp expressed as microseconds units

Definition: f_sendcmd.c:100

VAR_VARS_NB

@ VAR_VARS_NB

Definition: f_sendcmd.c:71

var_names

static const char *const var_names[]

Definition: f_sendcmd.c:44

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:197

filter_frame

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

Definition: f_sendcmd.c:489

TS2D

#define TS2D(ts)

Definition: filters.h:277

VAR_W

@ VAR_W

Definition: f_sendcmd.c:69

VAR_PTS

@ VAR_PTS

Definition: f_sendcmd.c:65

eval.h

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

av_expr_parse_and_eval

int av_expr_parse_and_eval(double *d, const char *s, const char *const *const_names, const double *const_values, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), void *opaque, int log_offset, void *log_ctx)

Parse and evaluate an expression.

Definition: eval.c:803

av_err2str

#define av_err2str(errnum)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: error.h:122

SPACES

#define SPACES

Definition: f_sendcmd.c:126

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

TS2T

#define TS2T(ts, tb)

Definition: filters.h:278

init

static av_cold int init(AVFilterContext *ctx)

Definition: f_sendcmd.c:412

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

Interval

Definition: f_sendcmd.c:98

Interval::commands

Command * commands

Definition: f_sendcmd.c:102

bprint.h

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

Definition: cbs_h2645.c:256

parse_commands

static int parse_commands(Command **cmds, int *nb_cmds, int interval_count, const char **buf, void *log_ctx)

Definition: f_sendcmd.c:232