cmdutils.c

   1 /*
   2  * Various utilities for command line tools
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <math.h>
  26
  27 /* Include only the enabled headers since some compilers (namely, Sun
  28    Studio) will not omit unused inline functions and create undefined
  29    references to libraries that are not being built. */
  30
  31 #include "config.h"
  32 #include "libavformat/avformat.h"
  33 #include "libavfilter/avfilter.h"
  34 #include "libavdevice/avdevice.h"
  35 #include "libswscale/swscale.h"
  36 #include "libpostproc/postprocess.h"
  37 #include "libavutil/avstring.h"
  38 #include "libavcodec/opt.h"
  39 #include "cmdutils.h"
  40 #include "version.h"
  41 #if CONFIG_NETWORK
  42 #include "libavformat/network.h"
  43 #endif
  44
  45 #undef exit
  46
  47 const char **opt_names;
  48 static int opt_name_count;
  49 AVCodecContext *avcodec_opts[CODEC_TYPE_NB];
  50 AVFormatContext *avformat_opts;
  51 struct SwsContext *sws_opts;
  52
  53 const int this_year = 2009;
  54
  55 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
  56 {
  57     char *tail;
  58     const char *error;
  59     double d = strtod(numstr, &tail);
  60     if (*tail)
  61         error= "Expected number for %s but found: %s\n";
  62     else if (d < min || d > max)
  63         error= "The value for %s was %s which is not within %f - %f\n";
  64     else if(type == OPT_INT64 && (int64_t)d != d)
  65         error= "Expected int64 for %s but found %s\n";
  66     else
  67         return d;
  68     fprintf(stderr, error, context, numstr, min, max);
  69     exit(1);
  70 }
  71
  72 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
  73 {
  74     int64_t us = parse_date(timestr, is_duration);
  75     if (us == INT64_MIN) {
  76         fprintf(stderr, "Invalid %s specification for %s: %s\n",
  77                 is_duration ? "duration" : "date", context, timestr);
  78         exit(1);
  79     }
  80     return us;
  81 }
  82
  83 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
  84 {
  85     const OptionDef *po;
  86     int first;
  87
  88     first = 1;
  89     for(po = options; po->name != NULL; po++) {
  90         char buf[64];
  91         if ((po->flags & mask) == value) {
  92             if (first) {
  93                 printf("%s", msg);
  94                 first = 0;
  95             }
  96             av_strlcpy(buf, po->name, sizeof(buf));
  97             if (po->flags & HAS_ARG) {
  98                 av_strlcat(buf, " ", sizeof(buf));
  99                 av_strlcat(buf, po->argname, sizeof(buf));
 100             }
 101             printf("-%-17s  %s\n", buf, po->help);
 102         }
 103     }
 104 }
 105
 106 static const OptionDef* find_option(const OptionDef *po, const char *name){
 107     while (po->name != NULL) {
 108         if (!strcmp(name, po->name))
 109             break;
 110         po++;
 111     }
 112     return po;
 113 }
 114
 115 void parse_options(int argc, char **argv, const OptionDef *options,
 116                    void (* parse_arg_function)(const char*))
 117 {
 118     const char *opt, *arg;
 119     int optindex, handleoptions=1;
 120     const OptionDef *po;
 121
 122     /* parse options */
 123     optindex = 1;
 124     while (optindex < argc) {
 125         opt = argv[optindex++];
 126
 127         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 128             int bool_val = 1;
 129             if (opt[1] == '-' && opt[2] == '\0') {
 130                 handleoptions = 0;
 131                 continue;
 132             }
 133             po= find_option(options, opt + 1);
 134             if (!po->name && opt[1] == 'n' && opt[2] == 'o') {
 135                 /* handle 'no' bool option */
 136                 po = find_option(options, opt + 3);
 137                 if (!(po->name && (po->flags & OPT_BOOL)))
 138                     goto unknown_opt;
 139                 bool_val = 0;
 140             }
 141             if (!po->name)
 142                 po= find_option(options, "default");
 143             if (!po->name) {
 144 unknown_opt:
 145                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 146                 exit(1);
 147             }
 148             arg = NULL;
 149             if (po->flags & HAS_ARG) {
 150                 arg = argv[optindex++];
 151                 if (!arg) {
 152                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 153                     exit(1);
 154                 }
 155             }
 156             if (po->flags & OPT_STRING) {
 157                 char *str;
 158                 str = av_strdup(arg);
 159                 *po->u.str_arg = str;
 160             } else if (po->flags & OPT_BOOL) {
 161                 *po->u.int_arg = bool_val;
 162             } else if (po->flags & OPT_INT) {
 163                 *po->u.int_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT_MIN, INT_MAX);
 164             } else if (po->flags & OPT_INT64) {
 165                 *po->u.int64_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 166             } else if (po->flags & OPT_FLOAT) {
 167                 *po->u.float_arg = parse_number_or_die(opt+1, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
 168             } else if (po->flags & OPT_FUNC2) {
 169                 if(po->u.func2_arg(opt+1, arg)<0)
 170                     goto unknown_opt;
 171             } else {
 172                 po->u.func_arg(arg);
 173             }
 174             if(po->flags & OPT_EXIT)
 175                 exit(0);
 176         } else {
 177             if (parse_arg_function)
 178                 parse_arg_function(opt);
 179         }
 180     }
 181 }
 182
 183 int opt_default(const char *opt, const char *arg){
 184     int type;
 185     int ret= 0;
 186     const AVOption *o= NULL;
 187     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 188
 189     for(type=0; type<CODEC_TYPE_NB && ret>= 0; type++){
 190         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 191         if(o2)
 192             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 193     }
 194     if(!o)
 195         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 196     if(!o)
 197         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 198     if(!o){
 199         if(opt[0] == 'a')
 200             ret = av_set_string3(avcodec_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1, &o);
 201         else if(opt[0] == 'v')
 202             ret = av_set_string3(avcodec_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1, &o);
 203         else if(opt[0] == 's')
 204             ret = av_set_string3(avcodec_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 205     }
 206     if (o && ret < 0) {
 207         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 208         exit(1);
 209     }
 210     if(!o)
 211         return -1;
 212
 213 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avcodec_opts, opt, NULL), (int)av_get_int(avcodec_opts, opt, NULL));
 214
 215     //FIXME we should always use avcodec_opts, ... for storing options so there will not be any need to keep track of what i set over this
 216     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 217     opt_names[opt_name_count++]= o->name;
 218
 219     if(avcodec_opts[0]->debug || avformat_opts->debug)
 220         av_log_set_level(AV_LOG_DEBUG);
 221     return 0;
 222 }
 223
 224 int opt_loglevel(const char *opt, const char *arg)
 225 {
 226     const struct { const char *name; int level; } log_levels[] = {
 227         { "quiet"  , AV_LOG_QUIET   },
 228         { "panic"  , AV_LOG_PANIC   },
 229         { "fatal"  , AV_LOG_FATAL   },
 230         { "error"  , AV_LOG_ERROR   },
 231         { "warning", AV_LOG_WARNING },
 232         { "info"   , AV_LOG_INFO    },
 233         { "verbose", AV_LOG_VERBOSE },
 234         { "debug"  , AV_LOG_DEBUG   },
 235     };
 236     char *tail;
 237     int level;
 238     int i;
 239
 240     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 241         if (!strcmp(log_levels[i].name, arg)) {
 242             av_log_set_level(log_levels[i].level);
 243             return 0;
 244         }
 245     }
 246
 247     level = strtol(arg, &tail, 10);
 248     if (*tail) {
 249         fprintf(stderr, "Invalid loglevel \"%s\". "
 250                         "Possible levels are numbers or:\n", arg);
 251         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 252             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 253         exit(1);
 254     }
 255     av_log_set_level(level);
 256     return 0;
 257 }
 258
 259 void set_context_opts(void *ctx, void *opts_ctx, int flags)
 260 {
 261     int i;
 262     for(i=0; i<opt_name_count; i++){
 263         char buf[256];
 264         const AVOption *opt;
 265         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 266         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 267         if(str && ((opt->flags & flags) == flags))
 268             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 269     }
 270 }
 271
 272 void print_error(const char *filename, int err)
 273 {
 274     switch(err) {
 275     case AVERROR_NUMEXPECTED:
 276         fprintf(stderr, "%s: Incorrect image filename syntax.\n"
 277                 "Use '%%d' to specify the image number:\n"
 278                 "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
 279                 "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
 280                 filename);
 281         break;
 282     case AVERROR_INVALIDDATA:
 283         fprintf(stderr, "%s: Error while parsing header\n", filename);
 284         break;
 285     case AVERROR_NOFMT:
 286         fprintf(stderr, "%s: Unknown format\n", filename);
 287         break;
 288     case AVERROR(EIO):
 289         fprintf(stderr, "%s: I/O error occurred\n"
 290                 "Usually that means that input file is truncated and/or corrupted.\n",
 291                 filename);
 292         break;
 293     case AVERROR(ENOMEM):
 294         fprintf(stderr, "%s: memory allocation error occurred\n", filename);
 295         break;
 296     case AVERROR(ENOENT):
 297         fprintf(stderr, "%s: no such file or directory\n", filename);
 298         break;
 299 #if CONFIG_NETWORK
 300     case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
 301         fprintf(stderr, "%s: Unsupported network protocol\n", filename);
 302         break;
 303 #endif
 304     default:
 305         fprintf(stderr, "%s: Error while opening file\n", filename);
 306         break;
 307     }
 308 }
 309
 310 #define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
 311     version= libname##_version(); \
 312     fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
 313             LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
 314             version >> 16, version >> 8 & 0xff, version & 0xff);
 315
 316 static void print_all_lib_versions(FILE* outstream, int indent)
 317 {
 318     unsigned int version;
 319     PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
 320     PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
 321     PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
 322     PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
 323 #if CONFIG_AVFILTER
 324     PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
 325 #endif
 326     PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
 327 #if CONFIG_POSTPROC
 328     PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
 329 #endif
 330 }
 331
 332 void show_banner(void)
 333 {
 334     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d Fabrice Bellard, et al.\n",
 335             program_name, program_birth_year, this_year);
 336     fprintf(stderr, "  built on %s %s with %s %s\n",
 337             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 338     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 339     print_all_lib_versions(stderr, 1);
 340 }
 341
 342 void show_version(void) {
 343     printf("%s " FFMPEG_VERSION "\n", program_name);
 344     print_all_lib_versions(stdout, 0);
 345 }
 346
 347 void show_license(void)
 348 {
 349     printf(
 350 #if CONFIG_NONFREE
 351     "This version of %s has nonfree parts compiled in.\n"
 352     "Therefore it is not legally redistributable.\n",
 353     program_name
 354 #elif CONFIG_GPLV3
 355     "%s is free software; you can redistribute it and/or modify\n"
 356     "it under the terms of the GNU General Public License as published by\n"
 357     "the Free Software Foundation; either version 3 of the License, or\n"
 358     "(at your option) any later version.\n"
 359     "\n"
 360     "%s is distributed in the hope that it will be useful,\n"
 361     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 362     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 363     "GNU General Public License for more details.\n"
 364     "\n"
 365     "You should have received a copy of the GNU General Public License\n"
 366     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 367     program_name, program_name, program_name
 368 #elif CONFIG_GPL
 369     "%s is free software; you can redistribute it and/or modify\n"
 370     "it under the terms of the GNU General Public License as published by\n"
 371     "the Free Software Foundation; either version 2 of the License, or\n"
 372     "(at your option) any later version.\n"
 373     "\n"
 374     "%s is distributed in the hope that it will be useful,\n"
 375     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 376     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 377     "GNU General Public License for more details.\n"
 378     "\n"
 379     "You should have received a copy of the GNU General Public License\n"
 380     "along with %s; if not, write to the Free Software\n"
 381     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 382     program_name, program_name, program_name
 383 #elif CONFIG_LGPLV3
 384     "%s is free software; you can redistribute it and/or modify\n"
 385     "it under the terms of the GNU Lesser General Public License as published by\n"
 386     "the Free Software Foundation; either version 3 of the License, or\n"
 387     "(at your option) any later version.\n"
 388     "\n"
 389     "%s is distributed in the hope that it will be useful,\n"
 390     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 391     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 392     "GNU Lesser General Public License for more details.\n"
 393     "\n"
 394     "You should have received a copy of the GNU Lesser General Public License\n"
 395     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 396     program_name, program_name, program_name
 397 #else
 398     "%s is free software; you can redistribute it and/or\n"
 399     "modify it under the terms of the GNU Lesser General Public\n"
 400     "License as published by the Free Software Foundation; either\n"
 401     "version 2.1 of the License, or (at your option) any later version.\n"
 402     "\n"
 403     "%s is distributed in the hope that it will be useful,\n"
 404     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 405     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 406     "Lesser General Public License for more details.\n"
 407     "\n"
 408     "You should have received a copy of the GNU Lesser General Public\n"
 409     "License along with %s; if not, write to the Free Software\n"
 410     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 411     program_name, program_name, program_name
 412 #endif
 413     );
 414 }
 415
 416 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
 417 {
 418     int i;
 419     char fmt_str[128];
 420     for (i=-1; i < nb_fmts; i++) {
 421         get_fmt_string (fmt_str, sizeof(fmt_str), i);
 422         fprintf(stdout, "%s\n", fmt_str);
 423     }
 424 }
 425
 426 void show_formats(void)
 427 {
 428     AVInputFormat *ifmt=NULL;
 429     AVOutputFormat *ofmt=NULL;
 430     const char *last_name;
 431
 432     printf(
 433         "File formats:\n"
 434         " D. = Demuxing supported\n"
 435         " .E = Muxing supported\n"
 436         " --\n");
 437     last_name= "000";
 438     for(;;){
 439         int decode=0;
 440         int encode=0;
 441         const char *name=NULL;
 442         const char *long_name=NULL;
 443
 444         while((ofmt= av_oformat_next(ofmt))) {
 445             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 446                 strcmp(ofmt->name, last_name)>0){
 447                 name= ofmt->name;
 448                 long_name= ofmt->long_name;
 449                 encode=1;
 450             }
 451         }
 452         while((ifmt= av_iformat_next(ifmt))) {
 453             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 454                 strcmp(ifmt->name, last_name)>0){
 455                 name= ifmt->name;
 456                 long_name= ifmt->long_name;
 457                 encode=0;
 458             }
 459             if(name && strcmp(ifmt->name, name)==0)
 460                 decode=1;
 461         }
 462         if(name==NULL)
 463             break;
 464         last_name= name;
 465
 466         printf(
 467             " %s%s %-15s %s\n",
 468             decode ? "D":" ",
 469             encode ? "E":" ",
 470             name,
 471             long_name ? long_name:" ");
 472     }
 473 }
 474
 475 void show_codecs(void)
 476 {
 477     AVCodec *p=NULL, *p2;
 478     const char *last_name;
 479     printf(
 480         "Codecs:\n"
 481         " D..... = Decoding supported\n"
 482         " .E.... = Encoding supported\n"
 483         " ..V... = Video codec\n"
 484         " ..A... = Audio codec\n"
 485         " ..S... = Subtitle codec\n"
 486         " ...S.. = Supports draw_horiz_band\n"
 487         " ....D. = Supports direct rendering method 1\n"
 488         " .....T = Supports weird frame truncation\n"
 489         " ------\n");
 490     last_name= "000";
 491     for(;;){
 492         int decode=0;
 493         int encode=0;
 494         int cap=0;
 495         const char *type_str;
 496
 497         p2=NULL;
 498         while((p= av_codec_next(p))) {
 499             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 500                 strcmp(p->name, last_name)>0){
 501                 p2= p;
 502                 decode= encode= cap=0;
 503             }
 504             if(p2 && strcmp(p->name, p2->name)==0){
 505                 if(p->decode) decode=1;
 506                 if(p->encode) encode=1;
 507                 cap |= p->capabilities;
 508             }
 509         }
 510         if(p2==NULL)
 511             break;
 512         last_name= p2->name;
 513
 514         switch(p2->type) {
 515         case CODEC_TYPE_VIDEO:
 516             type_str = "V";
 517             break;
 518         case CODEC_TYPE_AUDIO:
 519             type_str = "A";
 520             break;
 521         case CODEC_TYPE_SUBTITLE:
 522             type_str = "S";
 523             break;
 524         default:
 525             type_str = "?";
 526             break;
 527         }
 528         printf(
 529             " %s%s%s%s%s%s %-15s %s",
 530             decode ? "D": (/*p2->decoder ? "d":*/" "),
 531             encode ? "E":" ",
 532             type_str,
 533             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 534             cap & CODEC_CAP_DR1 ? "D":" ",
 535             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 536             p2->name,
 537             p2->long_name ? p2->long_name : "");
 538        /* if(p2->decoder && decode==0)
 539             printf(" use %s for decoding", p2->decoder->name);*/
 540         printf("\n");
 541     }
 542     printf("\n");
 543     printf(
 544 "Note, the names of encoders and decoders do not always match, so there are\n"
 545 "several cases where the above table shows encoder only or decoder only entries\n"
 546 "even though both encoding and decoding are supported. For example, the h263\n"
 547 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 548 "worse.\n");
 549 }
 550
 551 void show_bsfs(void)
 552 {
 553     AVBitStreamFilter *bsf=NULL;
 554
 555     printf("Bitstream filters:\n");
 556     while((bsf = av_bitstream_filter_next(bsf)))
 557         printf("%s\n", bsf->name);
 558     printf("\n");
 559 }
 560
 561 void show_protocols(void)
 562 {
 563     URLProtocol *up=NULL;
 564
 565     printf("Supported file protocols:\n");
 566     while((up = av_protocol_next(up)))
 567         printf("%s\n", up->name);
 568     printf("\n");
 569
 570     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
 571 }
 572
 573 void show_filters(void)
 574 {
 575     AVFilter **filter = NULL;
 576
 577     printf("Filters:\n");
 578 #if CONFIG_AVFILTER
 579     while ((filter = av_filter_next(filter)) && *filter)
 580         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 581 #endif
 582 }
 583
 584 int read_yesno(void)
 585 {
 586     int c = getchar();
 587     int yesno = (toupper(c) == 'Y');
 588
 589     while (c != '\n' && c != EOF)
 590         c = getchar();
 591
 592     return yesno;
 593 }