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