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