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 void set_context_opts(void *ctx, void *opts_ctx, int flags)
 217 {
 218     int i;
 219     for(i=0; i<opt_name_count; i++){
 220         char buf[256];
 221         const AVOption *opt;
 222         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 223         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 224         if(str && ((opt->flags & flags) == flags))
 225             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 226     }
 227 }
 228
 229 void print_error(const char *filename, int err)
 230 {
 231     switch(err) {
 232     case AVERROR_NUMEXPECTED:
 233         fprintf(stderr, "%s: Incorrect image filename syntax.\n"
 234                 "Use '%%d' to specify the image number:\n"
 235                 "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
 236                 "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
 237                 filename);
 238         break;
 239     case AVERROR_INVALIDDATA:
 240         fprintf(stderr, "%s: Error while parsing header\n", filename);
 241         break;
 242     case AVERROR_NOFMT:
 243         fprintf(stderr, "%s: Unknown format\n", filename);
 244         break;
 245     case AVERROR(EIO):
 246         fprintf(stderr, "%s: I/O error occurred\n"
 247                 "Usually that means that input file is truncated and/or corrupted.\n",
 248                 filename);
 249         break;
 250     case AVERROR(ENOMEM):
 251         fprintf(stderr, "%s: memory allocation error occurred\n", filename);
 252         break;
 253     case AVERROR(ENOENT):
 254         fprintf(stderr, "%s: no such file or directory\n", filename);
 255         break;
 256 #if CONFIG_NETWORK
 257     case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
 258         fprintf(stderr, "%s: Unsupported network protocol\n", filename);
 259         break;
 260 #endif
 261     default:
 262         fprintf(stderr, "%s: Error while opening file\n", filename);
 263         break;
 264     }
 265 }
 266
 267 #define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
 268     version= libname##_version(); \
 269     fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
 270             LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
 271             version >> 16, version >> 8 & 0xff, version & 0xff);
 272
 273 static void print_all_lib_versions(FILE* outstream, int indent)
 274 {
 275     unsigned int version;
 276     PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
 277     PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
 278     PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
 279     PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
 280 #if CONFIG_AVFILTER
 281     PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
 282 #endif
 283     PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
 284 #if CONFIG_POSTPROC
 285     PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
 286 #endif
 287 }
 288
 289 void show_banner(void)
 290 {
 291     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d Fabrice Bellard, et al.\n",
 292             program_name, program_birth_year, this_year);
 293     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 294     print_all_lib_versions(stderr, 1);
 295     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
 296 #ifdef __GNUC__
 297     fprintf(stderr, ", gcc: " __VERSION__ "\n");
 298 #else
 299     fprintf(stderr, ", using a non-gcc compiler\n");
 300 #endif
 301 }
 302
 303 void show_version(void) {
 304     printf("%s " FFMPEG_VERSION "\n", program_name);
 305     print_all_lib_versions(stdout, 0);
 306 }
 307
 308 void show_license(void)
 309 {
 310     printf(
 311 #if CONFIG_NONFREE
 312     "This version of %s has nonfree parts compiled in.\n"
 313     "Therefore it is not legally redistributable.\n",
 314     program_name
 315 #elif CONFIG_GPLV3
 316     "%s is free software; you can redistribute it and/or modify\n"
 317     "it under the terms of the GNU General Public License as published by\n"
 318     "the Free Software Foundation; either version 3 of the License, or\n"
 319     "(at your option) any later version.\n"
 320     "\n"
 321     "%s is distributed in the hope that it will be useful,\n"
 322     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 323     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 324     "GNU General Public License for more details.\n"
 325     "\n"
 326     "You should have received a copy of the GNU General Public License\n"
 327     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 328     program_name, program_name, program_name
 329 #elif CONFIG_GPL
 330     "%s is free software; you can redistribute it and/or modify\n"
 331     "it under the terms of the GNU General Public License as published by\n"
 332     "the Free Software Foundation; either version 2 of the License, or\n"
 333     "(at your option) any later version.\n"
 334     "\n"
 335     "%s is distributed in the hope that it will be useful,\n"
 336     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 337     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 338     "GNU General Public License for more details.\n"
 339     "\n"
 340     "You should have received a copy of the GNU General Public License\n"
 341     "along with %s; if not, write to the Free Software\n"
 342     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 343     program_name, program_name, program_name
 344 #elif CONFIG_LGPLV3
 345     "%s is free software; you can redistribute it and/or modify\n"
 346     "it under the terms of the GNU Lesser General Public License as published by\n"
 347     "the Free Software Foundation; either version 3 of the License, or\n"
 348     "(at your option) any later version.\n"
 349     "\n"
 350     "%s is distributed in the hope that it will be useful,\n"
 351     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 352     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 353     "GNU Lesser General Public License for more details.\n"
 354     "\n"
 355     "You should have received a copy of the GNU Lesser General Public License\n"
 356     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 357     program_name, program_name, program_name
 358 #else
 359     "%s is free software; you can redistribute it and/or\n"
 360     "modify it under the terms of the GNU Lesser General Public\n"
 361     "License as published by the Free Software Foundation; either\n"
 362     "version 2.1 of the License, or (at your option) any later version.\n"
 363     "\n"
 364     "%s is distributed in the hope that it will be useful,\n"
 365     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 366     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 367     "Lesser General Public License for more details.\n"
 368     "\n"
 369     "You should have received a copy of the GNU Lesser General Public\n"
 370     "License along with %s; if not, write to the Free Software\n"
 371     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 372     program_name, program_name, program_name
 373 #endif
 374     );
 375 }
 376
 377 void show_formats(void)
 378 {
 379     AVInputFormat *ifmt=NULL;
 380     AVOutputFormat *ofmt=NULL;
 381     URLProtocol *up=NULL;
 382     AVCodec *p=NULL, *p2;
 383     AVBitStreamFilter *bsf=NULL;
 384     const char *last_name;
 385
 386     printf("File formats:\n");
 387     last_name= "000";
 388     for(;;){
 389         int decode=0;
 390         int encode=0;
 391         const char *name=NULL;
 392         const char *long_name=NULL;
 393
 394         while((ofmt= av_oformat_next(ofmt))) {
 395             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 396                 strcmp(ofmt->name, last_name)>0){
 397                 name= ofmt->name;
 398                 long_name= ofmt->long_name;
 399                 encode=1;
 400             }
 401         }
 402         while((ifmt= av_iformat_next(ifmt))) {
 403             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 404                 strcmp(ifmt->name, last_name)>0){
 405                 name= ifmt->name;
 406                 long_name= ifmt->long_name;
 407                 encode=0;
 408             }
 409             if(name && strcmp(ifmt->name, name)==0)
 410                 decode=1;
 411         }
 412         if(name==NULL)
 413             break;
 414         last_name= name;
 415
 416         printf(
 417             " %s%s %-15s %s\n",
 418             decode ? "D":" ",
 419             encode ? "E":" ",
 420             name,
 421             long_name ? long_name:" ");
 422     }
 423     printf("\n");
 424
 425     printf("Codecs:\n");
 426     last_name= "000";
 427     for(;;){
 428         int decode=0;
 429         int encode=0;
 430         int cap=0;
 431         const char *type_str;
 432
 433         p2=NULL;
 434         while((p= av_codec_next(p))) {
 435             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 436                 strcmp(p->name, last_name)>0){
 437                 p2= p;
 438                 decode= encode= cap=0;
 439             }
 440             if(p2 && strcmp(p->name, p2->name)==0){
 441                 if(p->decode) decode=1;
 442                 if(p->encode) encode=1;
 443                 cap |= p->capabilities;
 444             }
 445         }
 446         if(p2==NULL)
 447             break;
 448         last_name= p2->name;
 449
 450         switch(p2->type) {
 451         case CODEC_TYPE_VIDEO:
 452             type_str = "V";
 453             break;
 454         case CODEC_TYPE_AUDIO:
 455             type_str = "A";
 456             break;
 457         case CODEC_TYPE_SUBTITLE:
 458             type_str = "S";
 459             break;
 460         default:
 461             type_str = "?";
 462             break;
 463         }
 464         printf(
 465             " %s%s%s%s%s%s %-15s %s",
 466             decode ? "D": (/*p2->decoder ? "d":*/" "),
 467             encode ? "E":" ",
 468             type_str,
 469             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 470             cap & CODEC_CAP_DR1 ? "D":" ",
 471             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 472             p2->name,
 473             p2->long_name ? p2->long_name : "");
 474        /* if(p2->decoder && decode==0)
 475             printf(" use %s for decoding", p2->decoder->name);*/
 476         printf("\n");
 477     }
 478     printf("\n");
 479
 480     printf("Bitstream filters:\n");
 481     while((bsf = av_bitstream_filter_next(bsf)))
 482         printf(" %s", bsf->name);
 483     printf("\n");
 484
 485     printf("Supported file protocols:\n");
 486     while((up = av_protocol_next(up)))
 487         printf(" %s:", up->name);
 488     printf("\n");
 489
 490     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
 491     printf("\n");
 492     printf(
 493 "Note, the names of encoders and decoders do not always match, so there are\n"
 494 "several cases where the above table shows encoder only or decoder only entries\n"
 495 "even though both encoding and decoding are supported. For example, the h263\n"
 496 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 497 "worse.\n");
 498 }
 499
 500 int read_yesno(void)
 501 {
 502     int c = getchar();
 503     int yesno = (toupper(c) == 'Y');
 504
 505     while (c != '\n' && c != EOF)
 506         c = getchar();
 507
 508     return yesno;
 509 }