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 #include "libavformat/network.h"
  42
  43 #undef exit
  44
  45 const char **opt_names;
  46 static int opt_name_count;
  47 AVCodecContext *avctx_opts[CODEC_TYPE_NB];
  48 AVFormatContext *avformat_opts;
  49 struct SwsContext *sws_opts;
  50
  51 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
  52 {
  53     char *tail;
  54     const char *error;
  55     double d = strtod(numstr, &tail);
  56     if (*tail)
  57         error= "Expected number for %s but found: %s\n";
  58     else if (d < min || d > max)
  59         error= "The value for %s was %s which is not within %f - %f\n";
  60     else if(type == OPT_INT64 && (int64_t)d != d)
  61         error= "Expected int64 for %s but found %s\n";
  62     else
  63         return d;
  64     fprintf(stderr, error, context, numstr, min, max);
  65     exit(1);
  66 }
  67
  68 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
  69 {
  70     int64_t us = parse_date(timestr, is_duration);
  71     if (us == INT64_MIN) {
  72         fprintf(stderr, "Invalid %s specification for %s: %s\n",
  73                 is_duration ? "duration" : "date", context, timestr);
  74         exit(1);
  75     }
  76     return us;
  77 }
  78
  79 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
  80 {
  81     const OptionDef *po;
  82     int first;
  83
  84     first = 1;
  85     for(po = options; po->name != NULL; po++) {
  86         char buf[64];
  87         if ((po->flags & mask) == value) {
  88             if (first) {
  89                 printf("%s", msg);
  90                 first = 0;
  91             }
  92             av_strlcpy(buf, po->name, sizeof(buf));
  93             if (po->flags & HAS_ARG) {
  94                 av_strlcat(buf, " ", sizeof(buf));
  95                 av_strlcat(buf, po->argname, sizeof(buf));
  96             }
  97             printf("-%-17s  %s\n", buf, po->help);
  98         }
  99     }
 100 }
 101
 102 static const OptionDef* find_option(const OptionDef *po, const char *name){
 103     while (po->name != NULL) {
 104         if (!strcmp(name, po->name))
 105             break;
 106         po++;
 107     }
 108     return po;
 109 }
 110
 111 void parse_options(int argc, char **argv, const OptionDef *options,
 112                    void (* parse_arg_function)(const char*))
 113 {
 114     const char *opt, *arg;
 115     int optindex, handleoptions=1;
 116     const OptionDef *po;
 117
 118     /* parse options */
 119     optindex = 1;
 120     while (optindex < argc) {
 121         opt = argv[optindex++];
 122
 123         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 124             if (opt[1] == '-' && opt[2] == '\0') {
 125                 handleoptions = 0;
 126                 continue;
 127             }
 128             po= find_option(options, opt + 1);
 129             if (!po->name)
 130                 po= find_option(options, "default");
 131             if (!po->name) {
 132 unknown_opt:
 133                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 134                 exit(1);
 135             }
 136             arg = NULL;
 137             if (po->flags & HAS_ARG) {
 138                 arg = argv[optindex++];
 139                 if (!arg) {
 140                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 141                     exit(1);
 142                 }
 143             }
 144             if (po->flags & OPT_STRING) {
 145                 char *str;
 146                 str = av_strdup(arg);
 147                 *po->u.str_arg = str;
 148             } else if (po->flags & OPT_BOOL) {
 149                 *po->u.int_arg = 1;
 150             } else if (po->flags & OPT_INT) {
 151                 *po->u.int_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT_MIN, INT_MAX);
 152             } else if (po->flags & OPT_INT64) {
 153                 *po->u.int64_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 154             } else if (po->flags & OPT_FLOAT) {
 155                 *po->u.float_arg = parse_number_or_die(opt+1, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
 156             } else if (po->flags & OPT_FUNC2) {
 157                 if(po->u.func2_arg(opt+1, arg)<0)
 158                     goto unknown_opt;
 159             } else {
 160                 po->u.func_arg(arg);
 161             }
 162             if(po->flags & OPT_EXIT)
 163                 exit(0);
 164         } else {
 165             if (parse_arg_function)
 166                 parse_arg_function(opt);
 167         }
 168     }
 169 }
 170
 171 int opt_default(const char *opt, const char *arg){
 172     int type;
 173     int ret= 0;
 174     const AVOption *o= NULL;
 175     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 176
 177     for(type=0; type<CODEC_TYPE_NB && ret>= 0; type++){
 178         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 179         if(o2)
 180             ret = av_set_string3(avctx_opts[type], opt, arg, 1, &o);
 181     }
 182     if(!o)
 183         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 184     if(!o)
 185         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 186     if(!o){
 187         if(opt[0] == 'a')
 188             ret = av_set_string3(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1, &o);
 189         else if(opt[0] == 'v')
 190             ret = av_set_string3(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1, &o);
 191         else if(opt[0] == 's')
 192             ret = av_set_string3(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 193     }
 194     if (o && ret < 0) {
 195         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 196         exit(1);
 197     }
 198     if(!o)
 199         return -1;
 200
 201 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
 202
 203     //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
 204     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 205     opt_names[opt_name_count++]= o->name;
 206
 207     if(avctx_opts[0]->debug || avformat_opts->debug)
 208         av_log_set_level(AV_LOG_DEBUG);
 209     return 0;
 210 }
 211
 212 void set_context_opts(void *ctx, void *opts_ctx, int flags)
 213 {
 214     int i;
 215     for(i=0; i<opt_name_count; i++){
 216         char buf[256];
 217         const AVOption *opt;
 218         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 219         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 220         if(str && ((opt->flags & flags) == flags))
 221             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 222     }
 223 }
 224
 225 void print_error(const char *filename, int err)
 226 {
 227     switch(err) {
 228     case AVERROR_NUMEXPECTED:
 229         fprintf(stderr, "%s: Incorrect image filename syntax.\n"
 230                 "Use '%%d' to specify the image number:\n"
 231                 "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
 232                 "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
 233                 filename);
 234         break;
 235     case AVERROR_INVALIDDATA:
 236         fprintf(stderr, "%s: Error while parsing header\n", filename);
 237         break;
 238     case AVERROR_NOFMT:
 239         fprintf(stderr, "%s: Unknown format\n", filename);
 240         break;
 241     case AVERROR(EIO):
 242         fprintf(stderr, "%s: I/O error occurred\n"
 243                 "Usually that means that input file is truncated and/or corrupted.\n",
 244                 filename);
 245         break;
 246     case AVERROR(ENOMEM):
 247         fprintf(stderr, "%s: memory allocation error occurred\n", filename);
 248         break;
 249     case AVERROR(ENOENT):
 250         fprintf(stderr, "%s: no such file or directory\n", filename);
 251         break;
 252 #if CONFIG_NETWORK
 253     case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
 254         fprintf(stderr, "%s: Unsupported network protocol\n", filename);
 255         break;
 256 #endif
 257     default:
 258         fprintf(stderr, "%s: Error while opening file\n", filename);
 259         break;
 260     }
 261 }
 262
 263 #define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
 264     version= libname##_version(); \
 265     fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
 266             LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
 267             version >> 16, version >> 8 & 0xff, version & 0xff);
 268
 269 static void print_all_lib_versions(FILE* outstream, int indent)
 270 {
 271     unsigned int version;
 272     PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
 273     PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
 274     PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
 275     PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
 276 #if CONFIG_AVFILTER
 277     PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
 278 #endif
 279 #if CONFIG_SWSCALE
 280     PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
 281 #endif
 282 #if CONFIG_POSTPROC
 283     PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
 284 #endif
 285 }
 286
 287 void show_banner(void)
 288 {
 289     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-2009 Fabrice Bellard, et al.\n",
 290             program_name, program_birth_year);
 291     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 292     print_all_lib_versions(stderr, 1);
 293     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
 294 #ifdef __GNUC__
 295     fprintf(stderr, ", gcc: " __VERSION__ "\n");
 296 #else
 297     fprintf(stderr, ", using a non-gcc compiler\n");
 298 #endif
 299 }
 300
 301 void show_version(void) {
 302     printf("%s " FFMPEG_VERSION "\n", program_name);
 303     print_all_lib_versions(stdout, 0);
 304 }
 305
 306 void show_license(void)
 307 {
 308 #if CONFIG_NONFREE
 309     printf(
 310     "This version of %s has nonfree parts compiled in.\n"
 311     "Therefore it is not legally redistributable.\n",
 312     program_name
 313     );
 314 #elif CONFIG_GPL
 315     printf(
 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 2 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, write to the Free Software\n"
 328     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 329     program_name, program_name, program_name
 330     );
 331 #else
 332     printf(
 333     "%s is free software; you can redistribute it and/or\n"
 334     "modify it under the terms of the GNU Lesser General Public\n"
 335     "License as published by the Free Software Foundation; either\n"
 336     "version 2.1 of the License, or (at your option) any later version.\n"
 337     "\n"
 338     "%s is distributed in the hope that it will be useful,\n"
 339     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 340     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 341     "Lesser General Public License for more details.\n"
 342     "\n"
 343     "You should have received a copy of the GNU Lesser General Public\n"
 344     "License along with %s; if not, write to the Free Software\n"
 345     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 346     program_name, program_name, program_name
 347     );
 348 #endif
 349 }
 350
 351 void show_formats(void)
 352 {
 353     AVInputFormat *ifmt=NULL;
 354     AVOutputFormat *ofmt=NULL;
 355     URLProtocol *up=NULL;
 356     AVCodec *p=NULL, *p2;
 357     AVBitStreamFilter *bsf=NULL;
 358     const char *last_name;
 359
 360     printf("File formats:\n");
 361     last_name= "000";
 362     for(;;){
 363         int decode=0;
 364         int encode=0;
 365         const char *name=NULL;
 366         const char *long_name=NULL;
 367
 368         while((ofmt= av_oformat_next(ofmt))) {
 369             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 370                 strcmp(ofmt->name, last_name)>0){
 371                 name= ofmt->name;
 372                 long_name= ofmt->long_name;
 373                 encode=1;
 374             }
 375         }
 376         while((ifmt= av_iformat_next(ifmt))) {
 377             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 378                 strcmp(ifmt->name, last_name)>0){
 379                 name= ifmt->name;
 380                 long_name= ifmt->long_name;
 381                 encode=0;
 382             }
 383             if(name && strcmp(ifmt->name, name)==0)
 384                 decode=1;
 385         }
 386         if(name==NULL)
 387             break;
 388         last_name= name;
 389
 390         printf(
 391             " %s%s %-15s %s\n",
 392             decode ? "D":" ",
 393             encode ? "E":" ",
 394             name,
 395             long_name ? long_name:" ");
 396     }
 397     printf("\n");
 398
 399     printf("Codecs:\n");
 400     last_name= "000";
 401     for(;;){
 402         int decode=0;
 403         int encode=0;
 404         int cap=0;
 405         const char *type_str;
 406
 407         p2=NULL;
 408         while((p= av_codec_next(p))) {
 409             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 410                 strcmp(p->name, last_name)>0){
 411                 p2= p;
 412                 decode= encode= cap=0;
 413             }
 414             if(p2 && strcmp(p->name, p2->name)==0){
 415                 if(p->decode) decode=1;
 416                 if(p->encode) encode=1;
 417                 cap |= p->capabilities;
 418             }
 419         }
 420         if(p2==NULL)
 421             break;
 422         last_name= p2->name;
 423
 424         switch(p2->type) {
 425         case CODEC_TYPE_VIDEO:
 426             type_str = "V";
 427             break;
 428         case CODEC_TYPE_AUDIO:
 429             type_str = "A";
 430             break;
 431         case CODEC_TYPE_SUBTITLE:
 432             type_str = "S";
 433             break;
 434         default:
 435             type_str = "?";
 436             break;
 437         }
 438         printf(
 439             " %s%s%s%s%s%s %-15s %s",
 440             decode ? "D": (/*p2->decoder ? "d":*/" "),
 441             encode ? "E":" ",
 442             type_str,
 443             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 444             cap & CODEC_CAP_DR1 ? "D":" ",
 445             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 446             p2->name,
 447             p2->long_name ? p2->long_name : "");
 448        /* if(p2->decoder && decode==0)
 449             printf(" use %s for decoding", p2->decoder->name);*/
 450         printf("\n");
 451     }
 452     printf("\n");
 453
 454     printf("Bitstream filters:\n");
 455     while((bsf = av_bitstream_filter_next(bsf)))
 456         printf(" %s", bsf->name);
 457     printf("\n");
 458
 459     printf("Supported file protocols:\n");
 460     while((up = av_protocol_next(up)))
 461         printf(" %s:", up->name);
 462     printf("\n");
 463
 464     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
 465     printf("\n");
 466     printf(
 467 "Note, the names of encoders and decoders do not always match, so there are\n"
 468 "several cases where the above table shows encoder only or decoder only entries\n"
 469 "even though both encoding and decoding are supported. For example, the h263\n"
 470 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 471 "worse.\n");
 472 }