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 "libavutil/avstring.h"

27 #include "libavutil/bprint.h"

28 #include "libavutil/file.h"

29 #include "libavutil/opt.h"

30 #include "libavutil/parseutils.h"

31 #include "avfilter.h"

32 #include "internal.h"

33 #include "avfiltergraph.h"

34 #include "audio.h"

35 #include "video.h"

37 #define COMMAND_FLAG_ENTER 1

38 #define COMMAND_FLAG_LEAVE 2

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

41 {

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

43 int i, is_first = 1;

45 av_bprint_init(pbuf, 0, AV_BPRINT_SIZE_AUTOMATIC);

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

47 if (flags & 1<<i) {

48 if (!is_first)

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

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

51 is_first = 0;

52 }

53 }

55 return pbuf->str;

56 }

58 typedef struct {

59 int flags;

60 char *target, *command, *arg;

61 int index;

62 } Command;

64 typedef struct {

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

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

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

68 Command *commands;

69 int nb_commands;

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

71 } Interval;

73 typedef struct {

74 const AVClass *class;

75 Interval *intervals;

76 int nb_intervals;

78 char *commands_filename;

79 char *commands_str;

80 } SendCmdContext;

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

83 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM

84 static const AVOption options[] = {

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

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

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

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

89 { NULL }

90 };

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

94 static void skip_comments(const char **buf)

95 {

96 while (**buf) {

97 /* skip leading spaces */

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

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

100 break;

101

102 (*buf)++;

103

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

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

106 if (**buf)

107 (*buf)++;

108 }

109 }

110

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

112

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

114 const char **buf, void *log_ctx)

115 {

116 int ret;

117

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

119 cmd->index = cmd_count;

120

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

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

123

124 /* parse flags */

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

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

127

128 while (**buf) {

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

130

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

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

133 else {

134 char flag_buf[64];

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

136 av_log(log_ctx, AV_LOG_ERROR,

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

138 flag_buf, interval_count, cmd_count);

139 return AVERROR(EINVAL);

140 }

141 *buf += len;

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

143 break;

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

145 av_log(log_ctx, AV_LOG_ERROR,

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

147 **buf, interval_count, cmd_count);

148 return AVERROR(EINVAL);

149 }

150 if (**buf)

151 (*buf)++;

152 }

153

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

155 av_log(log_ctx, AV_LOG_ERROR,

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

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

158 return AVERROR(EINVAL);

159 }

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

161 } else {

162 cmd->flags = COMMAND_FLAG_ENTER;

163 }

164

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

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

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

168 av_log(log_ctx, AV_LOG_ERROR,

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

170 interval_count, cmd_count);

171 ret = AVERROR(EINVAL);

172 goto fail;

173 }

174

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

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

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

178 av_log(log_ctx, AV_LOG_ERROR,

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

180 interval_count, cmd_count);

181 ret = AVERROR(EINVAL);

182 goto fail;

183 }

184

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

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

187

188 return 1;

189

190 fail:

191 av_freep(&cmd->target);

192 av_freep(&cmd->command);

193 av_freep(&cmd->arg);

194 return ret;

195 }

196

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

198 const char **buf, void *log_ctx)

199 {

200 int cmd_count = 0;

201 int ret, n = 0;

202 AVBPrint pbuf;

203

204 *cmds = NULL;

205 *nb_cmds = 0;

206

207 while (**buf) {

208 Command cmd;

209

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

211 return ret;

212 cmd_count++;

213

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

215 if (*nb_cmds == n) {

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

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

218 if (!*cmds) {

219 av_log(log_ctx, AV_LOG_ERROR,

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

221 return AVERROR(ENOMEM);

222 }

223 }

224

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

226

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

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

229 av_log(log_ctx, AV_LOG_ERROR,

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

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

232 interval_count, cmd_count);

233 av_log(log_ctx, AV_LOG_ERROR,

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

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

236 return AVERROR(EINVAL);

237 }

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

239 break;

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

241 (*buf)++;

242 }

243

244 return 0;

245 }

246

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

248

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

250 const char **buf, void *log_ctx)

251 {

252 char *intervalstr;

253 int ret;

254

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

256 if (!**buf)

257 return 0;

258

259 /* reset data */

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

261 interval->index = interval_count;

262

263 /* format: INTERVAL COMMANDS */

264

265 /* parse interval */

266 intervalstr = av_get_token(buf, DELIMS);

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

268 char *start, *end;

269

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

271 if (!start) {

272 ret = AVERROR(EINVAL);

273 av_log(log_ctx, AV_LOG_ERROR,

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

275 intervalstr, interval_count);

276 goto end;

277 }

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

279 av_log(log_ctx, AV_LOG_ERROR,

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

281 start, interval_count);

282 goto end;

283 }

284

285 if (end) {

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

287 av_log(log_ctx, AV_LOG_ERROR,

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

289 end, interval_count);

290 goto end;

291 }

292 } else {

293 interval->end_ts = INT64_MAX;

294 }

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

296 av_log(log_ctx, AV_LOG_ERROR,

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

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

299 end, interval_count, start);

300 ret = AVERROR(EINVAL);

301 goto end;

302 }

303 } else {

304 av_log(log_ctx, AV_LOG_ERROR,

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

306 ret = AVERROR(EINVAL);

307 goto end;

308 }

309

310 /* parse commands */

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

312 interval_count, buf, log_ctx);

313

314 end:

315 av_free(intervalstr);

316 return ret;

317 }

318

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

320 const char *buf, void *log_ctx)

321 {

322 int interval_count = 0;

323 int ret, n = 0;

324

325 *intervals = NULL;

326 *nb_intervals = 0;

327

328 if (!buf)

329 return 0;

330

331 while (1) {

332 Interval interval;

333

334 skip_comments(&buf);

335 if (!(*buf))

336 break;

337

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

339 return ret;

340

341 buf += strspn(buf, SPACES);

342 if (*buf) {

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

344 av_log(log_ctx, AV_LOG_ERROR,

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

346 interval_count);

347 return AVERROR(EINVAL);

348 }

349 buf++; /* skip ';' */

350 }

351 interval_count++;

352

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

354 if (*nb_intervals == n) {

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

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

357 if (!*intervals) {

358 av_log(log_ctx, AV_LOG_ERROR,

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

360 return AVERROR(ENOMEM);

361 }

362 }

363

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

365 }

366

367 return 0;

368 }

369

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

371 {

372 const Interval *i1 = a;

373 const Interval *i2 = b;

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

375 }

376

377 static av_cold int init(AVFilterContext *ctx)

378 {

379 SendCmdContext *s = ctx->priv;

380 int ret, i, j;

381

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

383 av_log(ctx, AV_LOG_ERROR,

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

385 return AVERROR(EINVAL);

386 }

387

388 if (s->commands_filename) {

389 uint8_t *file_buf, *buf;

390 size_t file_bufsize;

391 ret = av_file_map(s->commands_filename,

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

393 if (ret < 0)

394 return ret;

395

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

397 buf = av_malloc(file_bufsize + 1);

398 if (!buf) {

399 av_file_unmap(file_buf, file_bufsize);

400 return AVERROR(ENOMEM);

401 }

402 memcpy(buf, file_buf, file_bufsize);

403 buf[file_bufsize] = 0;

404 av_file_unmap(file_buf, file_bufsize);

405 s->commands_str = buf;

406 }

407

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

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

410 return ret;

411

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

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

414 return AVERROR(EINVAL);

415 }

416

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

418

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

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

421 AVBPrint pbuf;

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

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

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

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

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

427 av_log(ctx, AV_LOG_VERBOSE,

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

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

430 }

431 }

432

433 return 0;

434 }

435

436 static av_cold void uninit(AVFilterContext *ctx)

437 {

438 SendCmdContext *s = ctx->priv;

439 int i, j;

440

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

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

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

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

445 av_freep(&cmd->target);

446 av_freep(&cmd->command);

447 av_freep(&cmd->arg);

448 }

449 av_freep(&interval->commands);

450 }

451 av_freep(&s->intervals);

452 }

453

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

455 {

456 AVFilterContext *ctx = inlink->dst;

457 SendCmdContext *s = ctx->priv;

458 int64_t ts;

459 int i, j, ret;

460

461 if (ref->pts == AV_NOPTS_VALUE)

462 goto end;

463

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

465

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

467

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

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

470 int flags = 0;

471

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

473 flags += COMMAND_FLAG_ENTER;

474 interval->enabled = 1;

475 }

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

477 flags += COMMAND_FLAG_LEAVE;

478 interval->enabled = 0;

479 }

480

481 if (flags) {

482 AVBPrint pbuf;

483 av_log(ctx, AV_LOG_VERBOSE,

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

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

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

487 (double)ts/1000000);

488

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

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

491 char buf[1024];

492

493 if (cmd->flags & flags) {

494 av_log(ctx, AV_LOG_VERBOSE,

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

496 cmd->index, cmd->target, cmd->command, cmd->arg);

497 ret = avfilter_graph_send_command(inlink->graph,

498 cmd->target, cmd->command, cmd->arg,

499 buf, sizeof(buf),

500 AVFILTER_CMD_FLAG_ONE);

501 av_log(ctx, AV_LOG_VERBOSE,

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

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

504 }

505 }

506 }

507 }

508

509 end:

510 switch (inlink->type) {

511 case AVMEDIA_TYPE_VIDEO:

512 case AVMEDIA_TYPE_AUDIO:

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

514 }

515

516 return AVERROR(ENOSYS);

517 }

518

519 #if CONFIG_SENDCMD_FILTER

520

521 #define sendcmd_options options

522 AVFILTER_DEFINE_CLASS(sendcmd);

523

524 static const AVFilterPad sendcmd_inputs[] = {

525 {

526 .name = "default",

527 .type = AVMEDIA_TYPE_VIDEO,

528 .filter_frame = filter_frame,

529 },

530 { NULL }

531 };

532

533 static const AVFilterPad sendcmd_outputs[] = {

534 {

535 .name = "default",

536 .type = AVMEDIA_TYPE_VIDEO,

537 },

538 { NULL }

539 };

540

541 AVFilter ff_vf_sendcmd = {

542 .name = "sendcmd",

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

544 .init = init,

545 .uninit = uninit,

546 .priv_size = sizeof(SendCmdContext),

547 .inputs = sendcmd_inputs,

548 .outputs = sendcmd_outputs,

549 .priv_class = &sendcmd_class,

550 };

551

552 #endif

553

554 #if CONFIG_ASENDCMD_FILTER

555

556 #define asendcmd_options options

557 AVFILTER_DEFINE_CLASS(asendcmd);

558

559 static const AVFilterPad asendcmd_inputs[] = {

560 {

561 .name = "default",

562 .type = AVMEDIA_TYPE_AUDIO,

563 .filter_frame = filter_frame,

564 },

565 { NULL }

566 };

567

568 static const AVFilterPad asendcmd_outputs[] = {

569 {

570 .name = "default",

571 .type = AVMEDIA_TYPE_AUDIO,

572 },

573 { NULL }

574 };

575

576 AVFilter ff_af_asendcmd = {

577 .name = "asendcmd",

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

579 .init = init,

580 .uninit = uninit,

581 .priv_size = sizeof(SendCmdContext),

582 .inputs = asendcmd_inputs,

583 .outputs = asendcmd_outputs,

584 .priv_class = &asendcmd_class,

585 };

586

587 #endif

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:768

audio.h

DELIMS

#define DELIMS

Definition: f_sendcmd.c:247

av_bprintf

void av_bprintf(AVBPrint *buf, const char *fmt,...)

Definition: bprint.c:94

AVFrame

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

Definition: frame.h:187

av_realloc_f

#define av_realloc_f(p, o, n)

Definition: tableprint_vlc.h:33

cmp_intervals

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

Definition: f_sendcmd.c:370

AVOption

AVOption.

Definition: opt.h:246

avfilter.h

Main libavfilter public API header.

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:587

SendCmdContext::nb_intervals

int nb_intervals

Definition: f_sendcmd.c:76

SendCmdContext::commands_str

char * commands_str

Definition: f_sendcmd.c:79

Interval::index

int index

unique index for these interval commands

Definition: f_sendcmd.c:67

const char * b

Definition: vf_curves.c:113

Command::command

char * command

Definition: f_sendcmd.c:60

avstring.h

parse_commands

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

Definition: f_sendcmd.c:197

parse_interval

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

Definition: f_sendcmd.c:249

AVFilterPad::name

const char * name

Pad name.

Definition: internal.h:60

cmds

static const char *const cmds[]

Definition: jacosubdec.c:72

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1125

SendCmdContext::commands_filename

char * commands_filename

Definition: f_sendcmd.c:78

Command

Definition: f_sendcmd.c:58

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

opt.h

AVOptions.

skip_comments

static void skip_comments(const char **buf)

Definition: f_sendcmd.c:94

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

AVFrame::pts

int64_t pts

Presentation timestamp in time_base units (time when frame should be shown to user).

Definition: frame.h:271

file.h

Misc file utilities.

AV_OPT_TYPE_STRING

Definition: opt.h:227

flags

static int flags

Definition: log.c:57

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

Interval::nb_commands

int nb_commands

Definition: f_sendcmd.c:69

parse_intervals

static int parse_intervals(Interval **intervals, int *nb_intervals, const char *buf, void *log_ctx)

Definition: f_sendcmd.c:319

Command::index

int index

Definition: f_sendcmd.c:61

video.h

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

Command::target

char * target

Definition: f_sendcmd.c:60

AVFilterPad

A filter pad used for either input or output.

Definition: internal.h:54

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

AVFilterLink

A link between two filters.

Definition: avfilter.h:408

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

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:129

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:49

SendCmdContext

Definition: f_sendcmd.c:73

SPACES

#define SPACES

Definition: f_sendcmd.c:92

AVERROR

#define AVERROR(e)

Definition: error.h:43

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:179

av_bprint_init

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

Definition: bprint.c:69

AVFilterContext::priv

void * priv

private data for use by the filter

Definition: avfilter.h:338

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

arg

const char * arg

Definition: jacosubdec.c:66

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AVFilterLink::time_base

AVRational time_base

Define the time base used by the PTS of the frames/samples which will pass through this link...

Definition: avfilter.h:434

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

av_strlcpy

size_t av_strlcpy(char *dst, const char *src, size_t size)

Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.

Definition: avstring.c:83

fail

#define fail()

Definition: checkasm.h:89

av_get_token

char * av_get_token(const char **buf, const char *term)

Unescape the given string until a non escaped terminating char, and return the token corresponding to...

Definition: avstring.c:149

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: f_sendcmd.c:436

Interval

Definition: f_sendcmd.c:64

FFDIFFSIGN

#define FFDIFFSIGN(x, y)

Comparator.

Definition: common.h:92

Interval::enabled

int enabled

current time detected inside this interval

Definition: f_sendcmd.c:70

COMMAND_DELIMS

#define COMMAND_DELIMS

Definition: f_sendcmd.c:111

parse_command

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

Definition: f_sendcmd.c:113

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:119

ctx

AVFormatContext * ctx

Definition: movenc.c:48

COMMAND_FLAG_LEAVE

#define COMMAND_FLAG_LEAVE

Definition: f_sendcmd.c:38

int n

Definition: avisynth_c.h:684

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:656

outputs

static const AVFilterPad outputs[]

Definition: af_afftfilt.c:386

bprint.h

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen_template.c:36

avfiltergraph.h

inputs

static const AVFilterPad inputs[]

Definition: af_afftfilt.c:376

AV_BPRINT_SIZE_AUTOMATIC

#define AV_BPRINT_SIZE_AUTOMATIC

AV_TIME_BASE_Q

#define AV_TIME_BASE_Q

Internal time base represented as fractional value.

Definition: avutil.h:260

Command::arg

char * arg

Definition: f_sendcmd.c:60

command

static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)

Definition: vf_drawtext.c:770

buf

void * buf

Definition: avisynth_c.h:690

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

AVFilter

Filter definition.

Definition: avfilter.h:144

init

static av_cold int init(AVFilterContext *ctx)

Definition: f_sendcmd.c:377

COMMAND_FLAG_ENTER

#define COMMAND_FLAG_ENTER

Definition: f_sendcmd.c:37

Command::flags

int flags

Definition: f_sendcmd.c:59

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:148

SendCmdContext::intervals

Interval * intervals

Definition: f_sendcmd.c:75

make_command_flags_str

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

Definition: f_sendcmd.c:40

parseutils.h

misc parsing utilities

Interval::end_ts

int64_t end_ts

end timestamp expressed as microseconds units

Definition: f_sendcmd.c:66

AVFilterContext::outputs

AVFilterLink ** outputs

array of pointers to output links

Definition: avfilter.h:335

AVFilterLink::type

enum AVMediaType type

filter media type

Definition: avfilter.h:415

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:184

AVFilterLink::graph

struct AVFilterGraph * graph

Graph the filter belongs to.

Definition: avfilter.h:481

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:107

Interval::start_ts

int64_t start_ts

start timestamp expressed as microseconds units

Definition: f_sendcmd.c:65

Interval::commands

Command * commands

Definition: f_sendcmd.c:68

avfilter_graph_send_command

int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)

Send a command to one or more filter instances.

Definition: avfiltergraph.c:1282

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

len

int len

Definition: vorbis_enc_data.h:452

AVFilterLink::dst

AVFilterContext * dst

dest filter

Definition: avfilter.h:412

AVFILTER_DEFINE_CLASS

#define AVFILTER_DEFINE_CLASS(fname)

Definition: internal.h:342

WITHIN_INTERVAL

#define WITHIN_INTERVAL(ts, start_ts, end_ts)

AVFilterContext

An instance of a filter.

Definition: avfilter.h:323

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

start

void INT64 start

Definition: avisynth_c.h:690

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

internal.h

internal API functions

OFFSET

#define OFFSET(x)

Definition: f_sendcmd.c:82

filter_frame

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

Definition: f_sendcmd.c:454

FLAGS

#define FLAGS

Definition: f_sendcmd.c:83

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

options

static const AVOption options[]

Definition: f_sendcmd.c:84

Definition: h264pred_template.c:468

av_bprint_chars

void av_bprint_chars(AVBPrint *buf, char c, unsigned n)

Append char c n times to a print buffer.

Definition: bprint.c:140

Generated on Fri Jan 12 2018 01:45:52 for FFmpeg by doxygen 1.8.6