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