git.sesse.net Git - ffmpeg/blob - libavfilter/f_sendcmd.c

   1 /*
   2  * Copyright (c) 2012 Stefano Sabatini
   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  */
  20
  21 /**
  22  * @file
  23  * send commands filter
  24  */
  25
  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 "audio.h"
  34 #include "video.h"
  35
  36 #define COMMAND_FLAG_ENTER 1
  37 #define COMMAND_FLAG_LEAVE 2
  38
  39 static inline char *make_command_flags_str(AVBPrint *pbuf, int flags)
  40 {
  41     static const char * const flag_strings[] = { "enter", "leave" };
  42     int i, is_first = 1;
  43
  44     av_bprint_init(pbuf, 0, AV_BPRINT_SIZE_AUTOMATIC);
  45     for (i = 0; i < FF_ARRAY_ELEMS(flag_strings); i++) {
  46         if (flags & 1<<i) {
  47             if (!is_first)
  48                 av_bprint_chars(pbuf, '+', 1);
  49             av_bprintf(pbuf, "%s", flag_strings[i]);
  50             is_first = 0;
  51         }
  52     }
  53
  54     return pbuf->str;
  55 }
  56
  57 typedef struct Command {
  58     int flags;
  59     char *target, *command, *arg;
  60     int index;
  61 } Command;
  62
  63 typedef struct Interval {
  64     int64_t start_ts;          ///< start timestamp expressed as microseconds units
  65     int64_t end_ts;            ///< end   timestamp expressed as microseconds units
  66     int index;                 ///< unique index for these interval commands
  67     Command *commands;
  68     int   nb_commands;
  69     int enabled;               ///< current time detected inside this interval
  70 } Interval;
  71
  72 typedef struct SendCmdContext {
  73     const AVClass *class;
  74     Interval *intervals;
  75     int   nb_intervals;
  76
  77     char *commands_filename;
  78     char *commands_str;
  79 } SendCmdContext;
  80
  81 #define OFFSET(x) offsetof(SendCmdContext, x)
  82 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
  83 static const AVOption options[] = {
  84     { "commands", "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
  85     { "c",        "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
  86     { "filename", "set commands file",  OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
  87     { "f",        "set commands file",  OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
  88     { NULL }
  89 };
  90
  91 #define SPACES " \f\t\n\r"
  92
  93 static void skip_comments(const char **buf)
  94 {
  95     while (**buf) {
  96         /* skip leading spaces */
  97         *buf += strspn(*buf, SPACES);
  98         if (**buf != '#')
  99             break;
 100
 101         (*buf)++;
 102
 103         /* skip comment until the end of line */
 104         *buf += strcspn(*buf, "\n");
 105         if (**buf)
 106             (*buf)++;
 107     }
 108 }
 109
 110 #define COMMAND_DELIMS " \f\t\n\r,;"
 111
 112 static int parse_command(Command *cmd, int cmd_count, int interval_count,
 113                          const char **buf, void *log_ctx)
 114 {
 115     int ret;
 116
 117     memset(cmd, 0, sizeof(Command));
 118     cmd->index = cmd_count;
 119
 120     /* format: [FLAGS] target command arg */
 121     *buf += strspn(*buf, SPACES);
 122
 123     /* parse flags */
 124     if (**buf == '[') {
 125         (*buf)++; /* skip "[" */
 126
 127         while (**buf) {
 128             int len = strcspn(*buf, "|+]");
 129
 130             if      (!strncmp(*buf, "enter", strlen("enter"))) cmd->flags |= COMMAND_FLAG_ENTER;
 131             else if (!strncmp(*buf, "leave", strlen("leave"))) cmd->flags |= COMMAND_FLAG_LEAVE;
 132             else {
 133                 char flag_buf[64];
 134                 av_strlcpy(flag_buf, *buf, sizeof(flag_buf));
 135                 av_log(log_ctx, AV_LOG_ERROR,
 136                        "Unknown flag '%s' in interval #%d, command #%d\n",
 137                        flag_buf, interval_count, cmd_count);
 138                 return AVERROR(EINVAL);
 139             }
 140             *buf += len;
 141             if (**buf == ']')
 142                 break;
 143             if (!strspn(*buf, "+|")) {
 144                 av_log(log_ctx, AV_LOG_ERROR,
 145                        "Invalid flags char '%c' in interval #%d, command #%d\n",
 146                        **buf, interval_count, cmd_count);
 147                 return AVERROR(EINVAL);
 148             }
 149             if (**buf)
 150                 (*buf)++;
 151         }
 152
 153         if (**buf != ']') {
 154             av_log(log_ctx, AV_LOG_ERROR,
 155                    "Missing flag terminator or extraneous data found at the end of flags "
 156                    "in interval #%d, command #%d\n", interval_count, cmd_count);
 157             return AVERROR(EINVAL);
 158         }
 159         (*buf)++; /* skip "]" */
 160     } else {
 161         cmd->flags = COMMAND_FLAG_ENTER;
 162     }
 163
 164     *buf += strspn(*buf, SPACES);
 165     cmd->target = av_get_token(buf, COMMAND_DELIMS);
 166     if (!cmd->target || !cmd->target[0]) {
 167         av_log(log_ctx, AV_LOG_ERROR,
 168                "No target specified in interval #%d, command #%d\n",
 169                interval_count, cmd_count);
 170         ret = AVERROR(EINVAL);
 171         goto fail;
 172     }
 173
 174     *buf += strspn(*buf, SPACES);
 175     cmd->command = av_get_token(buf, COMMAND_DELIMS);
 176     if (!cmd->command || !cmd->command[0]) {
 177         av_log(log_ctx, AV_LOG_ERROR,
 178                "No command specified in interval #%d, command #%d\n",
 179                interval_count, cmd_count);
 180         ret = AVERROR(EINVAL);
 181         goto fail;
 182     }
 183
 184     *buf += strspn(*buf, SPACES);
 185     cmd->arg = av_get_token(buf, COMMAND_DELIMS);
 186
 187     return 1;
 188
 189 fail:
 190     av_freep(&cmd->target);
 191     av_freep(&cmd->command);
 192     av_freep(&cmd->arg);
 193     return ret;
 194 }
 195
 196 static int parse_commands(Command **cmds, int *nb_cmds, int interval_count,
 197                           const char **buf, void *log_ctx)
 198 {
 199     int cmd_count = 0;
 200     int ret, n = 0;
 201     AVBPrint pbuf;
 202
 203     *cmds = NULL;
 204     *nb_cmds = 0;
 205
 206     while (**buf) {
 207         Command cmd;
 208
 209         if ((ret = parse_command(&cmd, cmd_count, interval_count, buf, log_ctx)) < 0)
 210             return ret;
 211         cmd_count++;
 212
 213         /* (re)allocate commands array if required */
 214         if (*nb_cmds == n) {
 215             n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */
 216             *cmds = av_realloc_f(*cmds, n, 2*sizeof(Command));
 217             if (!*cmds) {
 218                 av_log(log_ctx, AV_LOG_ERROR,
 219                        "Could not (re)allocate command array\n");
 220                 return AVERROR(ENOMEM);
 221             }
 222         }
 223
 224         (*cmds)[(*nb_cmds)++] = cmd;
 225
 226         *buf += strspn(*buf, SPACES);
 227         if (**buf && **buf != ';' && **buf != ',') {
 228             av_log(log_ctx, AV_LOG_ERROR,
 229                    "Missing separator or extraneous data found at the end of "
 230                    "interval #%d, in command #%d\n",
 231                    interval_count, cmd_count);
 232             av_log(log_ctx, AV_LOG_ERROR,
 233                    "Command was parsed as: flags:[%s] target:%s command:%s arg:%s\n",
 234                    make_command_flags_str(&pbuf, cmd.flags), cmd.target, cmd.command, cmd.arg);
 235             return AVERROR(EINVAL);
 236         }
 237         if (**buf == ';')
 238             break;
 239         if (**buf == ',')
 240             (*buf)++;
 241     }
 242
 243     return 0;
 244 }
 245
 246 #define DELIMS " \f\t\n\r,;"
 247
 248 static int parse_interval(Interval *interval, int interval_count,
 249                           const char **buf, void *log_ctx)
 250 {
 251     char *intervalstr;
 252     int ret;
 253
 254     *buf += strspn(*buf, SPACES);
 255     if (!**buf)
 256         return 0;
 257
 258     /* reset data */
 259     memset(interval, 0, sizeof(Interval));
 260     interval->index = interval_count;
 261
 262     /* format: INTERVAL COMMANDS */
 263
 264     /* parse interval */
 265     intervalstr = av_get_token(buf, DELIMS);
 266     if (intervalstr && intervalstr[0]) {
 267         char *start, *end;
 268
 269         start = av_strtok(intervalstr, "-", &end);
 270         if (!start) {
 271             ret = AVERROR(EINVAL);
 272             av_log(log_ctx, AV_LOG_ERROR,
 273                    "Invalid interval specification '%s' in interval #%d\n",
 274                    intervalstr, interval_count);
 275             goto end;
 276         }
 277         if ((ret = av_parse_time(&interval->start_ts, start, 1)) < 0) {
 278             av_log(log_ctx, AV_LOG_ERROR,
 279                    "Invalid start time specification '%s' in interval #%d\n",
 280                    start, interval_count);
 281             goto end;
 282         }
 283
 284         if (end) {
 285             if ((ret = av_parse_time(&interval->end_ts, end, 1)) < 0) {
 286                 av_log(log_ctx, AV_LOG_ERROR,
 287                        "Invalid end time specification '%s' in interval #%d\n",
 288                        end, interval_count);
 289                 goto end;
 290             }
 291         } else {
 292             interval->end_ts = INT64_MAX;
 293         }
 294         if (interval->end_ts < interval->start_ts) {
 295             av_log(log_ctx, AV_LOG_ERROR,
 296                    "Invalid end time '%s' in interval #%d: "
 297                    "cannot be lesser than start time '%s'\n",
 298                    end, interval_count, start);
 299             ret = AVERROR(EINVAL);
 300             goto end;
 301         }
 302     } else {
 303         av_log(log_ctx, AV_LOG_ERROR,
 304                "No interval specified for interval #%d\n", interval_count);
 305         ret = AVERROR(EINVAL);
 306         goto end;
 307     }
 308
 309     /* parse commands */
 310     ret = parse_commands(&interval->commands, &interval->nb_commands,
 311                          interval_count, buf, log_ctx);
 312
 313 end:
 314     av_free(intervalstr);
 315     return ret;
 316 }
 317
 318 static int parse_intervals(Interval **intervals, int *nb_intervals,
 319                            const char *buf, void *log_ctx)
 320 {
 321     int interval_count = 0;
 322     int ret, n = 0;
 323
 324     *intervals = NULL;
 325     *nb_intervals = 0;
 326
 327     if (!buf)
 328         return 0;
 329
 330     while (1) {
 331         Interval interval;
 332
 333         skip_comments(&buf);
 334         if (!(*buf))
 335             break;
 336
 337         if ((ret = parse_interval(&interval, interval_count, &buf, log_ctx)) < 0)
 338             return ret;
 339
 340         buf += strspn(buf, SPACES);
 341         if (*buf) {
 342             if (*buf != ';') {
 343                 av_log(log_ctx, AV_LOG_ERROR,
 344                        "Missing terminator or extraneous data found at the end of interval #%d\n",
 345                        interval_count);
 346                 return AVERROR(EINVAL);
 347             }
 348             buf++; /* skip ';' */
 349         }
 350         interval_count++;
 351
 352         /* (re)allocate commands array if required */
 353         if (*nb_intervals == n) {
 354             n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */
 355             *intervals = av_realloc_f(*intervals, n, 2*sizeof(Interval));
 356             if (!*intervals) {
 357                 av_log(log_ctx, AV_LOG_ERROR,
 358                        "Could not (re)allocate intervals array\n");
 359                 return AVERROR(ENOMEM);
 360             }
 361         }
 362
 363         (*intervals)[(*nb_intervals)++] = interval;
 364     }
 365
 366     return 0;
 367 }
 368
 369 static int cmp_intervals(const void *a, const void *b)
 370 {
 371     const Interval *i1 = a;
 372     const Interval *i2 = b;
 373     return 2 * FFDIFFSIGN(i1->start_ts, i2->start_ts) + FFDIFFSIGN(i1->index, i2->index);
 374 }
 375
 376 static av_cold int init(AVFilterContext *ctx)
 377 {
 378     SendCmdContext *s = ctx->priv;
 379     int ret, i, j;
 380
 381     if ((!!s->commands_filename + !!s->commands_str) != 1) {
 382         av_log(ctx, AV_LOG_ERROR,
 383                "One and only one of the filename or commands options must be specified\n");
 384         return AVERROR(EINVAL);
 385     }
 386
 387     if (s->commands_filename) {
 388         uint8_t *file_buf, *buf;
 389         size_t file_bufsize;
 390         ret = av_file_map(s->commands_filename,
 391                           &file_buf, &file_bufsize, 0, ctx);
 392         if (ret < 0)
 393             return ret;
 394
 395         /* create a 0-terminated string based on the read file */
 396         buf = av_malloc(file_bufsize + 1);
 397         if (!buf) {
 398             av_file_unmap(file_buf, file_bufsize);
 399             return AVERROR(ENOMEM);
 400         }
 401         memcpy(buf, file_buf, file_bufsize);
 402         buf[file_bufsize] = 0;
 403         av_file_unmap(file_buf, file_bufsize);
 404         s->commands_str = buf;
 405     }
 406
 407     if ((ret = parse_intervals(&s->intervals, &s->nb_intervals,
 408                                s->commands_str, ctx)) < 0)
 409         return ret;
 410
 411     if (s->nb_intervals == 0) {
 412         av_log(ctx, AV_LOG_ERROR, "No commands were specified\n");
 413         return AVERROR(EINVAL);
 414     }
 415
 416     qsort(s->intervals, s->nb_intervals, sizeof(Interval), cmp_intervals);
 417
 418     av_log(ctx, AV_LOG_DEBUG, "Parsed commands:\n");
 419     for (i = 0; i < s->nb_intervals; i++) {
 420         AVBPrint pbuf;
 421         Interval *interval = &s->intervals[i];
 422         av_log(ctx, AV_LOG_VERBOSE, "start_time:%f end_time:%f index:%d\n",
 423                (double)interval->start_ts/1000000, (double)interval->end_ts/1000000, interval->index);
 424         for (j = 0; j < interval->nb_commands; j++) {
 425             Command *cmd = &interval->commands[j];
 426             av_log(ctx, AV_LOG_VERBOSE,
 427                    "    [%s] target:%s command:%s arg:%s index:%d\n",
 428                    make_command_flags_str(&pbuf, cmd->flags), cmd->target, cmd->command, cmd->arg, cmd->index);
 429         }
 430     }
 431
 432     return 0;
 433 }
 434
 435 static av_cold void uninit(AVFilterContext *ctx)
 436 {
 437     SendCmdContext *s = ctx->priv;
 438     int i, j;
 439
 440     for (i = 0; i < s->nb_intervals; i++) {
 441         Interval *interval = &s->intervals[i];
 442         for (j = 0; j < interval->nb_commands; j++) {
 443             Command *cmd = &interval->commands[j];
 444             av_freep(&cmd->target);
 445             av_freep(&cmd->command);
 446             av_freep(&cmd->arg);
 447         }
 448         av_freep(&interval->commands);
 449     }
 450     av_freep(&s->intervals);
 451 }
 452
 453 static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
 454 {
 455     AVFilterContext *ctx = inlink->dst;
 456     SendCmdContext *s = ctx->priv;
 457     int64_t ts;
 458     int i, j, ret;
 459
 460     if (ref->pts == AV_NOPTS_VALUE)
 461         goto end;
 462
 463     ts = av_rescale_q(ref->pts, inlink->time_base, AV_TIME_BASE_Q);
 464
 465 #define WITHIN_INTERVAL(ts, start_ts, end_ts) ((ts) >= (start_ts) && (ts) < (end_ts))
 466
 467     for (i = 0; i < s->nb_intervals; i++) {
 468         Interval *interval = &s->intervals[i];
 469         int flags = 0;
 470
 471         if (!interval->enabled && WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {
 472             flags += COMMAND_FLAG_ENTER;
 473             interval->enabled = 1;
 474         }
 475         if (interval->enabled && !WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {
 476             flags += COMMAND_FLAG_LEAVE;
 477             interval->enabled = 0;
 478         }
 479
 480         if (flags) {
 481             AVBPrint pbuf;
 482             av_log(ctx, AV_LOG_VERBOSE,
 483                    "[%s] interval #%d start_ts:%f end_ts:%f ts:%f\n",
 484                    make_command_flags_str(&pbuf, flags), interval->index,
 485                    (double)interval->start_ts/1000000, (double)interval->end_ts/1000000,
 486                    (double)ts/1000000);
 487
 488             for (j = 0; flags && j < interval->nb_commands; j++) {
 489                 Command *cmd = &interval->commands[j];
 490                 char buf[1024];
 491
 492                 if (cmd->flags & flags) {
 493                     av_log(ctx, AV_LOG_VERBOSE,
 494                            "Processing command #%d target:%s command:%s arg:%s\n",
 495                            cmd->index, cmd->target, cmd->command, cmd->arg);
 496                     ret = avfilter_graph_send_command(inlink->graph,
 497                                                       cmd->target, cmd->command, cmd->arg,
 498                                                       buf, sizeof(buf),
 499                                                       AVFILTER_CMD_FLAG_ONE);
 500                     av_log(ctx, AV_LOG_VERBOSE,
 501                            "Command reply for command #%d: ret:%s res:%s\n",
 502                            cmd->index, av_err2str(ret), buf);
 503                 }
 504             }
 505         }
 506     }
 507
 508 end:
 509     switch (inlink->type) {
 510     case AVMEDIA_TYPE_VIDEO:
 511     case AVMEDIA_TYPE_AUDIO:
 512         return ff_filter_frame(inlink->dst->outputs[0], ref);
 513     }
 514
 515     return AVERROR(ENOSYS);
 516 }
 517
 518 #if CONFIG_SENDCMD_FILTER
 519
 520 #define sendcmd_options options
 521 AVFILTER_DEFINE_CLASS(sendcmd);
 522
 523 static const AVFilterPad sendcmd_inputs[] = {
 524     {
 525         .name         = "default",
 526         .type         = AVMEDIA_TYPE_VIDEO,
 527         .filter_frame = filter_frame,
 528     },
 529     { NULL }
 530 };
 531
 532 static const AVFilterPad sendcmd_outputs[] = {
 533     {
 534         .name = "default",
 535         .type = AVMEDIA_TYPE_VIDEO,
 536     },
 537     { NULL }
 538 };
 539
 540 AVFilter ff_vf_sendcmd = {
 541     .name        = "sendcmd",
 542     .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
 543     .init        = init,
 544     .uninit      = uninit,
 545     .priv_size   = sizeof(SendCmdContext),
 546     .inputs      = sendcmd_inputs,
 547     .outputs     = sendcmd_outputs,
 548     .priv_class  = &sendcmd_class,
 549 };
 550
 551 #endif
 552
 553 #if CONFIG_ASENDCMD_FILTER
 554
 555 #define asendcmd_options options
 556 AVFILTER_DEFINE_CLASS(asendcmd);
 557
 558 static const AVFilterPad asendcmd_inputs[] = {
 559     {
 560         .name         = "default",
 561         .type         = AVMEDIA_TYPE_AUDIO,
 562         .filter_frame = filter_frame,
 563     },
 564     { NULL }
 565 };
 566
 567 static const AVFilterPad asendcmd_outputs[] = {
 568     {
 569         .name = "default",
 570         .type = AVMEDIA_TYPE_AUDIO,
 571     },
 572     { NULL }
 573 };
 574
 575 AVFilter ff_af_asendcmd = {
 576     .name        = "asendcmd",
 577     .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
 578     .init        = init,
 579     .uninit      = uninit,
 580     .priv_size   = sizeof(SendCmdContext),
 581     .inputs      = asendcmd_inputs,
 582     .outputs     = asendcmd_outputs,
 583     .priv_class  = &asendcmd_class,
 584 };
 585
 586 #endif