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