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