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             if (opt[1] == '-' && opt[2] == '\0') {
 129                 handleoptions = 0;
 130                 continue;
 131             }
 132             po= find_option(options, opt + 1);
 133             if (!po->name)
 134                 po= find_option(options, "default");
 135             if (!po->name) {
 136 unknown_opt:
 137                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 138                 exit(1);
 139             }
 140             arg = NULL;
 141             if (po->flags & HAS_ARG) {
 142                 arg = argv[optindex++];
 143                 if (!arg) {
 144                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 145                     exit(1);
 146                 }
 147             }
 148             if (po->flags & OPT_STRING) {
 149                 char *str;
 150                 str = av_strdup(arg);
 151                 *po->u.str_arg = str;
 152             } else if (po->flags & OPT_BOOL) {
 153                 *po->u.int_arg = 1;
 154             } else if (po->flags & OPT_INT) {
 155                 *po->u.int_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT_MIN, INT_MAX);
 156             } else if (po->flags & OPT_INT64) {
 157                 *po->u.int64_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 158             } else if (po->flags & OPT_FLOAT) {
 159                 *po->u.float_arg = parse_number_or_die(opt+1, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
 160             } else if (po->flags & OPT_FUNC2) {
 161                 if(po->u.func2_arg(opt+1, arg)<0)
 162                     goto unknown_opt;
 163             } else {
 164                 po->u.func_arg(arg);
 165             }
 166             if(po->flags & OPT_EXIT)
 167                 exit(0);
 168         } else {
 169             if (parse_arg_function)
 170                 parse_arg_function(opt);
 171         }
 172     }
 173 }
 174
 175 int opt_default(const char *opt, const char *arg){
 176     int type;
 177     int ret= 0;
 178     const AVOption *o= NULL;
 179     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 180
 181     for(type=0; type<CODEC_TYPE_NB && ret>= 0; type++){
 182         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 183         if(o2)
 184             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 185     }
 186     if(!o)
 187         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 188     if(!o)
 189         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 190     if(!o){
 191         if(opt[0] == 'a')
 192             ret = av_set_string3(avcodec_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1, &o);
 193         else if(opt[0] == 'v')
 194             ret = av_set_string3(avcodec_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1, &o);
 195         else if(opt[0] == 's')
 196             ret = av_set_string3(avcodec_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 197     }
 198     if (o && ret < 0) {
 199         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 200         exit(1);
 201     }
 202     if(!o)
 203         return -1;
 204
 205 //    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));
 206
 207     //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
 208     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 209     opt_names[opt_name_count++]= o->name;
 210
 211     if(avcodec_opts[0]->debug || avformat_opts->debug)
 212         av_log_set_level(AV_LOG_DEBUG);
 213     return 0;
 214 }
 215
 216 int opt_loglevel(const char *opt, const char *arg)
 217 {
 218     const struct { const char *name; int level; } const log_levels[] = {
 219         { "quiet"  , AV_LOG_QUIET   },
 220         { "panic"  , AV_LOG_PANIC   },
 221         { "fatal"  , AV_LOG_FATAL   },
 222         { "error"  , AV_LOG_ERROR   },
 223         { "warning", AV_LOG_WARNING },
 224         { "info"   , AV_LOG_INFO    },
 225         { "verbose", AV_LOG_VERBOSE },
 226         { "debug"  , AV_LOG_DEBUG   },
 227     };
 228     char *tail;
 229     int level;
 230     int i;
 231
 232     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 233         if (!strcmp(log_levels[i].name, arg)) {
 234             av_log_set_level(log_levels[i].level);
 235             return 0;
 236         }
 237     }
 238
 239     level = strtol(arg, &tail, 10);
 240     if (*tail) {
 241         fprintf(stderr, "Invalid loglevel \"%s\". "
 242                         "Possible levels are numbers or:\n", arg);
 243         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 244             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 245         exit(1);
 246     }
 247     av_log_set_level(level);
 248     return 0;
 249 }
 250
 251 void set_context_opts(void *ctx, void *opts_ctx, int flags)
 252 {
 253     int i;
 254     for(i=0; i<opt_name_count; i++){
 255         char buf[256];
 256         const AVOption *opt;
 257         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 258         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 259         if(str && ((opt->flags & flags) == flags))
 260             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 261     }
 262 }
 263
 264 void print_error(const char *filename, int err)
 265 {
 266     switch(err) {
 267     case AVERROR_NUMEXPECTED:
 268         fprintf(stderr, "%s: Incorrect image filename syntax.\n"
 269                 "Use '%%d' to specify the image number:\n"
 270                 "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
 271                 "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
 272                 filename);
 273         break;
 274     case AVERROR_INVALIDDATA:
 275         fprintf(stderr, "%s: Error while parsing header\n", filename);
 276         break;
 277     case AVERROR_NOFMT:
 278         fprintf(stderr, "%s: Unknown format\n", filename);
 279         break;
 280     case AVERROR(EIO):
 281         fprintf(stderr, "%s: I/O error occurred\n"
 282                 "Usually that means that input file is truncated and/or corrupted.\n",
 283                 filename);
 284         break;
 285     case AVERROR(ENOMEM):
 286         fprintf(stderr, "%s: memory allocation error occurred\n", filename);
 287         break;
 288     case AVERROR(ENOENT):
 289         fprintf(stderr, "%s: no such file or directory\n", filename);
 290         break;
 291 #if CONFIG_NETWORK
 292     case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
 293         fprintf(stderr, "%s: Unsupported network protocol\n", filename);
 294         break;
 295 #endif
 296     default:
 297         fprintf(stderr, "%s: Error while opening file\n", filename);
 298         break;
 299     }
 300 }
 301
 302 #define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
 303     version= libname##_version(); \
 304     fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
 305             LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
 306             version >> 16, version >> 8 & 0xff, version & 0xff);
 307
 308 static void print_all_lib_versions(FILE* outstream, int indent)
 309 {
 310     unsigned int version;
 311     PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
 312     PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
 313     PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
 314     PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
 315 #if CONFIG_AVFILTER
 316     PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
 317 #endif
 318     PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
 319 #if CONFIG_POSTPROC
 320     PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
 321 #endif
 322 }
 323
 324 void show_banner(void)
 325 {
 326     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d Fabrice Bellard, et al.\n",
 327             program_name, program_birth_year, this_year);
 328     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 329     print_all_lib_versions(stderr, 1);
 330     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
 331 #ifdef __GNUC__
 332     fprintf(stderr, ", gcc: " __VERSION__ "\n");
 333 #else
 334     fprintf(stderr, ", using a non-gcc compiler\n");
 335 #endif
 336 }
 337
 338 void show_version(void) {
 339     printf("%s " FFMPEG_VERSION "\n", program_name);
 340     print_all_lib_versions(stdout, 0);
 341 }
 342
 343 void show_license(void)
 344 {
 345     printf(
 346 #if CONFIG_NONFREE
 347     "This version of %s has nonfree parts compiled in.\n"
 348     "Therefore it is not legally redistributable.\n",
 349     program_name
 350 #elif CONFIG_GPLV3
 351     "%s is free software; you can redistribute it and/or modify\n"
 352     "it under the terms of the GNU General Public License as published by\n"
 353     "the Free Software Foundation; either version 3 of the License, or\n"
 354     "(at your option) any later version.\n"
 355     "\n"
 356     "%s is distributed in the hope that it will be useful,\n"
 357     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 358     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 359     "GNU General Public License for more details.\n"
 360     "\n"
 361     "You should have received a copy of the GNU General Public License\n"
 362     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 363     program_name, program_name, program_name
 364 #elif CONFIG_GPL
 365     "%s is free software; you can redistribute it and/or modify\n"
 366     "it under the terms of the GNU General Public License as published by\n"
 367     "the Free Software Foundation; either version 2 of the License, or\n"
 368     "(at your option) any later version.\n"
 369     "\n"
 370     "%s is distributed in the hope that it will be useful,\n"
 371     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 372     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 373     "GNU General Public License for more details.\n"
 374     "\n"
 375     "You should have received a copy of the GNU General Public License\n"
 376     "along with %s; if not, write to the Free Software\n"
 377     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 378     program_name, program_name, program_name
 379 #elif CONFIG_LGPLV3
 380     "%s is free software; you can redistribute it and/or modify\n"
 381     "it under the terms of the GNU Lesser General Public License as published by\n"
 382     "the Free Software Foundation; either version 3 of the License, or\n"
 383     "(at your option) any later version.\n"
 384     "\n"
 385     "%s is distributed in the hope that it will be useful,\n"
 386     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 387     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 388     "GNU Lesser General Public License for more details.\n"
 389     "\n"
 390     "You should have received a copy of the GNU Lesser General Public License\n"
 391     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 392     program_name, program_name, program_name
 393 #else
 394     "%s is free software; you can redistribute it and/or\n"
 395     "modify it under the terms of the GNU Lesser General Public\n"
 396     "License as published by the Free Software Foundation; either\n"
 397     "version 2.1 of the License, or (at your option) any later version.\n"
 398     "\n"
 399     "%s is distributed in the hope that it will be useful,\n"
 400     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 401     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 402     "Lesser General Public License for more details.\n"
 403     "\n"
 404     "You should have received a copy of the GNU Lesser General Public\n"
 405     "License along with %s; if not, write to the Free Software\n"
 406     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 407     program_name, program_name, program_name
 408 #endif
 409     );
 410 }
 411
 412 void show_formats(void)
 413 {
 414     AVInputFormat *ifmt=NULL;
 415     AVOutputFormat *ofmt=NULL;
 416     URLProtocol *up=NULL;
 417     AVCodec *p=NULL, *p2;
 418     AVBitStreamFilter *bsf=NULL;
 419     const char *last_name;
 420
 421     printf("File formats:\n");
 422     last_name= "000";
 423     for(;;){
 424         int decode=0;
 425         int encode=0;
 426         const char *name=NULL;
 427         const char *long_name=NULL;
 428
 429         while((ofmt= av_oformat_next(ofmt))) {
 430             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 431                 strcmp(ofmt->name, last_name)>0){
 432                 name= ofmt->name;
 433                 long_name= ofmt->long_name;
 434                 encode=1;
 435             }
 436         }
 437         while((ifmt= av_iformat_next(ifmt))) {
 438             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 439                 strcmp(ifmt->name, last_name)>0){
 440                 name= ifmt->name;
 441                 long_name= ifmt->long_name;
 442                 encode=0;
 443             }
 444             if(name && strcmp(ifmt->name, name)==0)
 445                 decode=1;
 446         }
 447         if(name==NULL)
 448             break;
 449         last_name= name;
 450
 451         printf(
 452             " %s%s %-15s %s\n",
 453             decode ? "D":" ",
 454             encode ? "E":" ",
 455             name,
 456             long_name ? long_name:" ");
 457     }
 458     printf("\n");
 459
 460     printf("Codecs:\n");
 461     last_name= "000";
 462     for(;;){
 463         int decode=0;
 464         int encode=0;
 465         int cap=0;
 466         const char *type_str;
 467
 468         p2=NULL;
 469         while((p= av_codec_next(p))) {
 470             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 471                 strcmp(p->name, last_name)>0){
 472                 p2= p;
 473                 decode= encode= cap=0;
 474             }
 475             if(p2 && strcmp(p->name, p2->name)==0){
 476                 if(p->decode) decode=1;
 477                 if(p->encode) encode=1;
 478                 cap |= p->capabilities;
 479             }
 480         }
 481         if(p2==NULL)
 482             break;
 483         last_name= p2->name;
 484
 485         switch(p2->type) {
 486         case CODEC_TYPE_VIDEO:
 487             type_str = "V";
 488             break;
 489         case CODEC_TYPE_AUDIO:
 490             type_str = "A";
 491             break;
 492         case CODEC_TYPE_SUBTITLE:
 493             type_str = "S";
 494             break;
 495         default:
 496             type_str = "?";
 497             break;
 498         }
 499         printf(
 500             " %s%s%s%s%s%s %-15s %s",
 501             decode ? "D": (/*p2->decoder ? "d":*/" "),
 502             encode ? "E":" ",
 503             type_str,
 504             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 505             cap & CODEC_CAP_DR1 ? "D":" ",
 506             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 507             p2->name,
 508             p2->long_name ? p2->long_name : "");
 509        /* if(p2->decoder && decode==0)
 510             printf(" use %s for decoding", p2->decoder->name);*/
 511         printf("\n");
 512     }
 513     printf("\n");
 514
 515     printf("Bitstream filters:\n");
 516     while((bsf = av_bitstream_filter_next(bsf)))
 517         printf(" %s", bsf->name);
 518     printf("\n");
 519
 520     printf("Supported file protocols:\n");
 521     while((up = av_protocol_next(up)))
 522         printf(" %s:", up->name);
 523     printf("\n");
 524
 525     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
 526     printf("\n");
 527     printf(
 528 "Note, the names of encoders and decoders do not always match, so there are\n"
 529 "several cases where the above table shows encoder only or decoder only entries\n"
 530 "even though both encoding and decoding are supported. For example, the h263\n"
 531 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 532 "worse.\n");
 533 }
 534
 535 int read_yesno(void)
 536 {
 537     int c = getchar();
 538     int yesno = (toupper(c) == 'Y');
 539
 540     while (c != '\n' && c != EOF)
 541         c = getchar();
 542
 543     return yesno;
 544 }