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 "libavutil/pixdesc.h"
  39 #include "libavutil/eval.h"
  40 #include "libavcodec/opt.h"
  41 #include "libavcore/avcore.h"
  42 #include "cmdutils.h"
  43 #include "version.h"
  44 #if CONFIG_NETWORK
  45 #include "libavformat/network.h"
  46 #endif
  47 #if HAVE_SYS_RESOURCE_H
  48 #include <sys/resource.h>
  49 #endif
  50
  51 const char **opt_names;
  52 const char **opt_values;
  53 static int opt_name_count;
  54 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
  55 AVFormatContext *avformat_opts;
  56 struct SwsContext *sws_opts;
  57
  58 static const int this_year = 2011;
  59
  60 void init_opts(void)
  61 {
  62     int i;
  63     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
  64         avcodec_opts[i] = avcodec_alloc_context2(i);
  65     avformat_opts = avformat_alloc_context();
  66 #if CONFIG_SWSCALE
  67     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
  68 #endif
  69 }
  70
  71 void uninit_opts(void)
  72 {
  73     int i;
  74     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
  75         av_freep(&avcodec_opts[i]);
  76     av_freep(&avformat_opts->key);
  77     av_freep(&avformat_opts);
  78 #if CONFIG_SWSCALE
  79     av_freep(&sws_opts);
  80 #endif
  81     av_freep(&opt_names);
  82     av_freep(&opt_values);
  83 }
  84
  85 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
  86 {
  87     vfprintf(stdout, fmt, vl);
  88 }
  89
  90 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
  91 {
  92     char *tail;
  93     const char *error;
  94     double d = av_strtod(numstr, &tail);
  95     if (*tail)
  96         error= "Expected number for %s but found: %s\n";
  97     else if (d < min || d > max)
  98         error= "The value for %s was %s which is not within %f - %f\n";
  99     else if(type == OPT_INT64 && (int64_t)d != d)
 100         error= "Expected int64 for %s but found %s\n";
 101     else
 102         return d;
 103     fprintf(stderr, error, context, numstr, min, max);
 104     exit(1);
 105 }
 106
 107 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
 108 {
 109     int64_t us = parse_date(timestr, is_duration);
 110     if (us == INT64_MIN) {
 111         fprintf(stderr, "Invalid %s specification for %s: %s\n",
 112                 is_duration ? "duration" : "date", context, timestr);
 113         exit(1);
 114     }
 115     return us;
 116 }
 117
 118 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
 119 {
 120     const OptionDef *po;
 121     int first;
 122
 123     first = 1;
 124     for(po = options; po->name != NULL; po++) {
 125         char buf[64];
 126         if ((po->flags & mask) == value) {
 127             if (first) {
 128                 printf("%s", msg);
 129                 first = 0;
 130             }
 131             av_strlcpy(buf, po->name, sizeof(buf));
 132             if (po->flags & HAS_ARG) {
 133                 av_strlcat(buf, " ", sizeof(buf));
 134                 av_strlcat(buf, po->argname, sizeof(buf));
 135             }
 136             printf("-%-17s  %s\n", buf, po->help);
 137         }
 138     }
 139 }
 140
 141 static const OptionDef* find_option(const OptionDef *po, const char *name){
 142     while (po->name != NULL) {
 143         if (!strcmp(name, po->name))
 144             break;
 145         po++;
 146     }
 147     return po;
 148 }
 149
 150 void parse_options(int argc, char **argv, const OptionDef *options,
 151                    void (* parse_arg_function)(const char*))
 152 {
 153     const char *opt, *arg;
 154     int optindex, handleoptions=1;
 155     const OptionDef *po;
 156
 157     /* parse options */
 158     optindex = 1;
 159     while (optindex < argc) {
 160         opt = argv[optindex++];
 161
 162         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 163             int bool_val = 1;
 164             if (opt[1] == '-' && opt[2] == '\0') {
 165                 handleoptions = 0;
 166                 continue;
 167             }
 168             opt++;
 169             po= find_option(options, opt);
 170             if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
 171                 /* handle 'no' bool option */
 172                 po = find_option(options, opt + 2);
 173                 if (!(po->name && (po->flags & OPT_BOOL)))
 174                     goto unknown_opt;
 175                 bool_val = 0;
 176             }
 177             if (!po->name)
 178                 po= find_option(options, "default");
 179             if (!po->name) {
 180 unknown_opt:
 181                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 182                 exit(1);
 183             }
 184             arg = NULL;
 185             if (po->flags & HAS_ARG) {
 186                 arg = argv[optindex++];
 187                 if (!arg) {
 188                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 189                     exit(1);
 190                 }
 191             }
 192             if (po->flags & OPT_STRING) {
 193                 char *str;
 194                 str = av_strdup(arg);
 195                 *po->u.str_arg = str;
 196             } else if (po->flags & OPT_BOOL) {
 197                 *po->u.int_arg = bool_val;
 198             } else if (po->flags & OPT_INT) {
 199                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 200             } else if (po->flags & OPT_INT64) {
 201                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 202             } else if (po->flags & OPT_FLOAT) {
 203                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
 204             } else if (po->flags & OPT_FUNC2) {
 205                 if (po->u.func2_arg(opt, arg) < 0) {
 206                     fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
 207                     exit(1);
 208                 }
 209             } else {
 210                 po->u.func_arg(arg);
 211             }
 212             if(po->flags & OPT_EXIT)
 213                 exit(0);
 214         } else {
 215             if (parse_arg_function)
 216                 parse_arg_function(opt);
 217         }
 218     }
 219 }
 220
 221 int opt_default(const char *opt, const char *arg){
 222     int type;
 223     int ret= 0;
 224     const AVOption *o= NULL;
 225     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 226
 227     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
 228         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 229         if(o2)
 230             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 231     }
 232     if(!o && avformat_opts)
 233         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 234     if(!o && sws_opts)
 235         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 236     if(!o){
 237         if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
 238             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
 239         else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
 240             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
 241         else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
 242             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 243     }
 244     if (o && ret < 0) {
 245         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 246         exit(1);
 247     }
 248     if (!o) {
 249         AVCodec *p = NULL;
 250         AVOutputFormat *oformat = NULL;
 251         while ((p=av_codec_next(p))){
 252             AVClass *c= p->priv_class;
 253             if(c && av_find_opt(&c, opt, NULL, 0, 0))
 254                 break;
 255         }
 256         if (!p) {
 257             while ((oformat = av_oformat_next(oformat))) {
 258                 const AVClass *c = oformat->priv_class;
 259                 if (c && av_find_opt(&c, opt, NULL, 0, 0))
 260                     break;
 261             }
 262         }
 263         if(!p && !oformat){
 264             fprintf(stderr, "Unrecognized option '%s'\n", opt);
 265             exit(1);
 266         }
 267     }
 268
 269 //    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));
 270
 271     //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
 272     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
 273     opt_values[opt_name_count]= o ? NULL : arg;
 274     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 275     opt_names[opt_name_count++]= o ? o->name : opt;
 276
 277     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
 278         av_log_set_level(AV_LOG_DEBUG);
 279     return 0;
 280 }
 281
 282 int opt_loglevel(const char *opt, const char *arg)
 283 {
 284     const struct { const char *name; int level; } log_levels[] = {
 285         { "quiet"  , AV_LOG_QUIET   },
 286         { "panic"  , AV_LOG_PANIC   },
 287         { "fatal"  , AV_LOG_FATAL   },
 288         { "error"  , AV_LOG_ERROR   },
 289         { "warning", AV_LOG_WARNING },
 290         { "info"   , AV_LOG_INFO    },
 291         { "verbose", AV_LOG_VERBOSE },
 292         { "debug"  , AV_LOG_DEBUG   },
 293     };
 294     char *tail;
 295     int level;
 296     int i;
 297
 298     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 299         if (!strcmp(log_levels[i].name, arg)) {
 300             av_log_set_level(log_levels[i].level);
 301             return 0;
 302         }
 303     }
 304
 305     level = strtol(arg, &tail, 10);
 306     if (*tail) {
 307         fprintf(stderr, "Invalid loglevel \"%s\". "
 308                         "Possible levels are numbers or:\n", arg);
 309         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 310             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 311         exit(1);
 312     }
 313     av_log_set_level(level);
 314     return 0;
 315 }
 316
 317 int opt_timelimit(const char *opt, const char *arg)
 318 {
 319 #if HAVE_SETRLIMIT
 320     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 321     struct rlimit rl = { lim, lim + 1 };
 322     if (setrlimit(RLIMIT_CPU, &rl))
 323         perror("setrlimit");
 324 #else
 325     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 326 #endif
 327     return 0;
 328 }
 329
 330 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
 331 {
 332     int i;
 333     void *priv_ctx=NULL;
 334     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
 335         AVCodecContext *avctx= ctx;
 336         if(codec && codec->priv_class && avctx->priv_data){
 337             priv_ctx= avctx->priv_data;
 338         }
 339     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
 340         AVFormatContext *avctx = ctx;
 341         if (avctx->oformat && avctx->oformat->priv_class) {
 342             priv_ctx = avctx->priv_data;
 343         }
 344     }
 345
 346     for(i=0; i<opt_name_count; i++){
 347         char buf[256];
 348         const AVOption *opt;
 349         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 350         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 351         if(str && ((opt->flags & flags) == flags))
 352             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 353         /* We need to use a differnt system to pass options to the private context because
 354            it is not known which codec and thus context kind that will be when parsing options
 355            we thus use opt_values directly instead of opts_ctx */
 356         if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
 357             av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
 358         }
 359     }
 360 }
 361
 362 void print_error(const char *filename, int err)
 363 {
 364     char errbuf[128];
 365     const char *errbuf_ptr = errbuf;
 366
 367     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 368         errbuf_ptr = strerror(AVUNERROR(err));
 369     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
 370 }
 371
 372 static int warned_cfg = 0;
 373
 374 #define INDENT        1
 375 #define SHOW_VERSION  2
 376 #define SHOW_CONFIG   4
 377
 378 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 379     if (CONFIG_##LIBNAME) {                                             \
 380         const char *indent = flags & INDENT? "  " : "";                 \
 381         if (flags & SHOW_VERSION) {                                     \
 382             unsigned int version = libname##_version();                 \
 383             fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
 384                     indent, #libname,                                   \
 385                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 386                     LIB##LIBNAME##_VERSION_MINOR,                       \
 387                     LIB##LIBNAME##_VERSION_MICRO,                       \
 388                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 389         }                                                               \
 390         if (flags & SHOW_CONFIG) {                                      \
 391             const char *cfg = libname##_configuration();                \
 392             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 393                 if (!warned_cfg) {                                      \
 394                     fprintf(outstream,                                  \
 395                             "%sWARNING: library configuration mismatch\n", \
 396                             indent);                                    \
 397                     warned_cfg = 1;                                     \
 398                 }                                                       \
 399                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 400                         indent, #libname, cfg);                         \
 401             }                                                           \
 402         }                                                               \
 403     }                                                                   \
 404
 405 static void print_all_libs_info(FILE* outstream, int flags)
 406 {
 407     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 408     PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);
 409     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 410     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 411     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 412     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 413     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 414     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 415 }
 416
 417 void show_banner(void)
 418 {
 419     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
 420             program_name, program_birth_year, this_year);
 421     fprintf(stderr, "  built on %s %s with %s %s\n",
 422             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 423     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 424     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 425     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 426 }
 427
 428 void show_version(void) {
 429     printf("%s " FFMPEG_VERSION "\n", program_name);
 430     print_all_libs_info(stdout, SHOW_VERSION);
 431 }
 432
 433 void show_license(void)
 434 {
 435     printf(
 436 #if CONFIG_NONFREE
 437     "This version of %s has nonfree parts compiled in.\n"
 438     "Therefore it is not legally redistributable.\n",
 439     program_name
 440 #elif CONFIG_GPLV3
 441     "%s is free software; you can redistribute it and/or modify\n"
 442     "it under the terms of the GNU General Public License as published by\n"
 443     "the Free Software Foundation; either version 3 of the License, or\n"
 444     "(at your option) any later version.\n"
 445     "\n"
 446     "%s is distributed in the hope that it will be useful,\n"
 447     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 448     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 449     "GNU General Public License for more details.\n"
 450     "\n"
 451     "You should have received a copy of the GNU General Public License\n"
 452     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 453     program_name, program_name, program_name
 454 #elif CONFIG_GPL
 455     "%s is free software; you can redistribute it and/or modify\n"
 456     "it under the terms of the GNU General Public License as published by\n"
 457     "the Free Software Foundation; either version 2 of the License, or\n"
 458     "(at your option) any later version.\n"
 459     "\n"
 460     "%s is distributed in the hope that it will be useful,\n"
 461     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 462     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 463     "GNU General Public License for more details.\n"
 464     "\n"
 465     "You should have received a copy of the GNU General Public License\n"
 466     "along with %s; if not, write to the Free Software\n"
 467     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 468     program_name, program_name, program_name
 469 #elif CONFIG_LGPLV3
 470     "%s is free software; you can redistribute it and/or modify\n"
 471     "it under the terms of the GNU Lesser General Public License as published by\n"
 472     "the Free Software Foundation; either version 3 of the License, or\n"
 473     "(at your option) any later version.\n"
 474     "\n"
 475     "%s is distributed in the hope that it will be useful,\n"
 476     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 477     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 478     "GNU Lesser General Public License for more details.\n"
 479     "\n"
 480     "You should have received a copy of the GNU Lesser General Public License\n"
 481     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 482     program_name, program_name, program_name
 483 #else
 484     "%s is free software; you can redistribute it and/or\n"
 485     "modify it under the terms of the GNU Lesser General Public\n"
 486     "License as published by the Free Software Foundation; either\n"
 487     "version 2.1 of the License, or (at your option) any later version.\n"
 488     "\n"
 489     "%s is distributed in the hope that it will be useful,\n"
 490     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 491     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 492     "Lesser General Public License for more details.\n"
 493     "\n"
 494     "You should have received a copy of the GNU Lesser General Public\n"
 495     "License along with %s; if not, write to the Free Software\n"
 496     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 497     program_name, program_name, program_name
 498 #endif
 499     );
 500 }
 501
 502 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
 503 {
 504     int i;
 505     char fmt_str[128];
 506     for (i=-1; i < nb_fmts; i++) {
 507         get_fmt_string (fmt_str, sizeof(fmt_str), i);
 508         fprintf(stdout, "%s\n", fmt_str);
 509     }
 510 }
 511
 512 void show_formats(void)
 513 {
 514     AVInputFormat *ifmt=NULL;
 515     AVOutputFormat *ofmt=NULL;
 516     const char *last_name;
 517
 518     printf(
 519         "File formats:\n"
 520         " D. = Demuxing supported\n"
 521         " .E = Muxing supported\n"
 522         " --\n");
 523     last_name= "000";
 524     for(;;){
 525         int decode=0;
 526         int encode=0;
 527         const char *name=NULL;
 528         const char *long_name=NULL;
 529
 530         while((ofmt= av_oformat_next(ofmt))) {
 531             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 532                 strcmp(ofmt->name, last_name)>0){
 533                 name= ofmt->name;
 534                 long_name= ofmt->long_name;
 535                 encode=1;
 536             }
 537         }
 538         while((ifmt= av_iformat_next(ifmt))) {
 539             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 540                 strcmp(ifmt->name, last_name)>0){
 541                 name= ifmt->name;
 542                 long_name= ifmt->long_name;
 543                 encode=0;
 544             }
 545             if(name && strcmp(ifmt->name, name)==0)
 546                 decode=1;
 547         }
 548         if(name==NULL)
 549             break;
 550         last_name= name;
 551
 552         printf(
 553             " %s%s %-15s %s\n",
 554             decode ? "D":" ",
 555             encode ? "E":" ",
 556             name,
 557             long_name ? long_name:" ");
 558     }
 559 }
 560
 561 void show_codecs(void)
 562 {
 563     AVCodec *p=NULL, *p2;
 564     const char *last_name;
 565     printf(
 566         "Codecs:\n"
 567         " D..... = Decoding supported\n"
 568         " .E.... = Encoding supported\n"
 569         " ..V... = Video codec\n"
 570         " ..A... = Audio codec\n"
 571         " ..S... = Subtitle codec\n"
 572         " ...S.. = Supports draw_horiz_band\n"
 573         " ....D. = Supports direct rendering method 1\n"
 574         " .....T = Supports weird frame truncation\n"
 575         " ------\n");
 576     last_name= "000";
 577     for(;;){
 578         int decode=0;
 579         int encode=0;
 580         int cap=0;
 581         const char *type_str;
 582
 583         p2=NULL;
 584         while((p= av_codec_next(p))) {
 585             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 586                 strcmp(p->name, last_name)>0){
 587                 p2= p;
 588                 decode= encode= cap=0;
 589             }
 590             if(p2 && strcmp(p->name, p2->name)==0){
 591                 if(p->decode) decode=1;
 592                 if(p->encode) encode=1;
 593                 cap |= p->capabilities;
 594             }
 595         }
 596         if(p2==NULL)
 597             break;
 598         last_name= p2->name;
 599
 600         switch(p2->type) {
 601         case AVMEDIA_TYPE_VIDEO:
 602             type_str = "V";
 603             break;
 604         case AVMEDIA_TYPE_AUDIO:
 605             type_str = "A";
 606             break;
 607         case AVMEDIA_TYPE_SUBTITLE:
 608             type_str = "S";
 609             break;
 610         default:
 611             type_str = "?";
 612             break;
 613         }
 614         printf(
 615             " %s%s%s%s%s%s %-15s %s",
 616             decode ? "D": (/*p2->decoder ? "d":*/" "),
 617             encode ? "E":" ",
 618             type_str,
 619             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 620             cap & CODEC_CAP_DR1 ? "D":" ",
 621             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 622             p2->name,
 623             p2->long_name ? p2->long_name : "");
 624        /* if(p2->decoder && decode==0)
 625             printf(" use %s for decoding", p2->decoder->name);*/
 626         printf("\n");
 627     }
 628     printf("\n");
 629     printf(
 630 "Note, the names of encoders and decoders do not always match, so there are\n"
 631 "several cases where the above table shows encoder only or decoder only entries\n"
 632 "even though both encoding and decoding are supported. For example, the h263\n"
 633 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 634 "worse.\n");
 635 }
 636
 637 void show_bsfs(void)
 638 {
 639     AVBitStreamFilter *bsf=NULL;
 640
 641     printf("Bitstream filters:\n");
 642     while((bsf = av_bitstream_filter_next(bsf)))
 643         printf("%s\n", bsf->name);
 644     printf("\n");
 645 }
 646
 647 void show_protocols(void)
 648 {
 649     URLProtocol *up=NULL;
 650
 651     printf("Supported file protocols:\n"
 652            "I.. = Input  supported\n"
 653            ".O. = Output supported\n"
 654            "..S = Seek   supported\n"
 655            "FLAGS NAME\n"
 656            "----- \n");
 657     while((up = av_protocol_next(up)))
 658         printf("%c%c%c   %s\n",
 659                up->url_read  ? 'I' : '.',
 660                up->url_write ? 'O' : '.',
 661                up->url_seek  ? 'S' : '.',
 662                up->name);
 663 }
 664
 665 void show_filters(void)
 666 {
 667     AVFilter av_unused(**filter) = NULL;
 668
 669     printf("Filters:\n");
 670 #if CONFIG_AVFILTER
 671     while ((filter = av_filter_next(filter)) && *filter)
 672         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 673 #endif
 674 }
 675
 676 void show_pix_fmts(void)
 677 {
 678     enum PixelFormat pix_fmt;
 679
 680     printf(
 681         "Pixel formats:\n"
 682         "I.... = Supported Input  format for conversion\n"
 683         ".O... = Supported Output format for conversion\n"
 684         "..H.. = Hardware accelerated format\n"
 685         "...P. = Paletted format\n"
 686         "....B = Bitstream format\n"
 687         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 688         "-----\n");
 689
 690 #if !CONFIG_SWSCALE
 691 #   define sws_isSupportedInput(x)  0
 692 #   define sws_isSupportedOutput(x) 0
 693 #endif
 694
 695     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 696         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 697         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 698                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 699                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 700                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 701                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 702                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 703                pix_desc->name,
 704                pix_desc->nb_components,
 705                av_get_bits_per_pixel(pix_desc));
 706     }
 707 }
 708
 709 int read_yesno(void)
 710 {
 711     int c = getchar();
 712     int yesno = (toupper(c) == 'Y');
 713
 714     while (c != '\n' && c != EOF)
 715         c = getchar();
 716
 717     return yesno;
 718 }
 719
 720 int read_file(const char *filename, char **bufptr, size_t *size)
 721 {
 722     FILE *f = fopen(filename, "rb");
 723
 724     if (!f) {
 725         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 726         return AVERROR(errno);
 727     }
 728     fseek(f, 0, SEEK_END);
 729     *size = ftell(f);
 730     fseek(f, 0, SEEK_SET);
 731     *bufptr = av_malloc(*size + 1);
 732     if (!*bufptr) {
 733         fprintf(stderr, "Could not allocate file buffer\n");
 734         fclose(f);
 735         return AVERROR(ENOMEM);
 736     }
 737     fread(*bufptr, 1, *size, f);
 738     (*bufptr)[*size++] = '\0';
 739
 740     fclose(f);
 741     return 0;
 742 }
 743
 744 void init_pts_correction(PtsCorrectionContext *ctx)
 745 {
 746     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
 747     ctx->last_pts = ctx->last_dts = INT64_MIN;
 748 }
 749
 750 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
 751 {
 752     int64_t pts = AV_NOPTS_VALUE;
 753
 754     if (dts != AV_NOPTS_VALUE) {
 755         ctx->num_faulty_dts += dts <= ctx->last_dts;
 756         ctx->last_dts = dts;
 757     }
 758     if (reordered_pts != AV_NOPTS_VALUE) {
 759         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
 760         ctx->last_pts = reordered_pts;
 761     }
 762     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
 763        && reordered_pts != AV_NOPTS_VALUE)
 764         pts = reordered_pts;
 765     else
 766         pts = dts;
 767
 768     return pts;
 769 }
 770
 771 FILE *get_preset_file(char *filename, size_t filename_size,
 772                       const char *preset_name, int is_path, const char *codec_name)
 773 {
 774     FILE *f = NULL;
 775     int i;
 776     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 777                            getenv("HOME"),
 778                            FFMPEG_DATADIR,
 779                          };
 780
 781     if (is_path) {
 782         av_strlcpy(filename, preset_name, filename_size);
 783         f = fopen(filename, "r");
 784     } else {
 785         for (i = 0; i < 3 && !f; i++) {
 786             if (!base[i])
 787                 continue;
 788             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 789             f = fopen(filename, "r");
 790             if (!f && codec_name) {
 791                 snprintf(filename, filename_size,
 792                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 793                 f = fopen(filename, "r");
 794             }
 795         }
 796     }
 797
 798     return f;
 799 }
 800
 801 #if CONFIG_AVFILTER
 802
 803 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
 804 {
 805     FFSinkContext *priv = ctx->priv;
 806
 807     if (!opaque)
 808         return AVERROR(EINVAL);
 809     *priv = *(FFSinkContext *)opaque;
 810
 811     return 0;
 812 }
 813
 814 static void null_end_frame(AVFilterLink *inlink) { }
 815
 816 static int ffsink_query_formats(AVFilterContext *ctx)
 817 {
 818     FFSinkContext *priv = ctx->priv;
 819     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
 820
 821     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
 822     return 0;
 823 }
 824
 825 AVFilter ffsink = {
 826     .name      = "ffsink",
 827     .priv_size = sizeof(FFSinkContext),
 828     .init      = ffsink_init,
 829
 830     .query_formats = ffsink_query_formats,
 831
 832     .inputs    = (AVFilterPad[]) {{ .name          = "default",
 833                                     .type          = AVMEDIA_TYPE_VIDEO,
 834                                     .end_frame     = null_end_frame,
 835                                     .min_perms     = AV_PERM_READ, },
 836                                   { .name = NULL }},
 837     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
 838 };
 839
 840 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
 841                              AVFilterBufferRef **picref_ptr, AVRational *tb)
 842 {
 843     int ret;
 844     AVFilterBufferRef *picref;
 845
 846     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
 847         return ret;
 848     if (!(picref = ctx->inputs[0]->cur_buf))
 849         return AVERROR(ENOENT);
 850     *picref_ptr = picref;
 851     ctx->inputs[0]->cur_buf = NULL;
 852     *tb = ctx->inputs[0]->time_base;
 853
 854     memcpy(frame->data,     picref->data,     sizeof(frame->data));
 855     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
 856     frame->interlaced_frame = picref->video->interlaced;
 857     frame->top_field_first  = picref->video->top_field_first;
 858
 859     return 1;
 860 }
 861
 862 #endif /* CONFIG_AVFILTER */