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/parseutils.h"
  39 #include "libavutil/pixdesc.h"
  40 #include "libavutil/eval.h"
  41 #include "libavcodec/opt.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;
 118     if (av_parse_time(&us, timestr, is_duration) < 0) {
 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, avcodec,  AVCODEC,  flags);
 417     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 418     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 419     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 420     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 421     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 422 }
 423
 424 void show_banner(void)
 425 {
 426     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
 427             program_name, program_birth_year, this_year);
 428     fprintf(stderr, "  built on %s %s with %s %s\n",
 429             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 430     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 431     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 432     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 433 }
 434
 435 void show_version(void) {
 436     printf("%s " FFMPEG_VERSION "\n", program_name);
 437     print_all_libs_info(stdout, SHOW_VERSION);
 438 }
 439
 440 void show_license(void)
 441 {
 442     printf(
 443 #if CONFIG_NONFREE
 444     "This version of %s has nonfree parts compiled in.\n"
 445     "Therefore it is not legally redistributable.\n",
 446     program_name
 447 #elif CONFIG_GPLV3
 448     "%s is free software; you can redistribute it and/or modify\n"
 449     "it under the terms of the GNU General Public License as published by\n"
 450     "the Free Software Foundation; either version 3 of the License, or\n"
 451     "(at your option) any later version.\n"
 452     "\n"
 453     "%s is distributed in the hope that it will be useful,\n"
 454     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 455     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 456     "GNU General Public License for more details.\n"
 457     "\n"
 458     "You should have received a copy of the GNU General Public License\n"
 459     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 460     program_name, program_name, program_name
 461 #elif CONFIG_GPL
 462     "%s is free software; you can redistribute it and/or modify\n"
 463     "it under the terms of the GNU General Public License as published by\n"
 464     "the Free Software Foundation; either version 2 of the License, or\n"
 465     "(at your option) any later version.\n"
 466     "\n"
 467     "%s is distributed in the hope that it will be useful,\n"
 468     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 469     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 470     "GNU General Public License for more details.\n"
 471     "\n"
 472     "You should have received a copy of the GNU General Public License\n"
 473     "along with %s; if not, write to the Free Software\n"
 474     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 475     program_name, program_name, program_name
 476 #elif CONFIG_LGPLV3
 477     "%s is free software; you can redistribute it and/or modify\n"
 478     "it under the terms of the GNU Lesser General Public License as published by\n"
 479     "the Free Software Foundation; either version 3 of the License, or\n"
 480     "(at your option) any later version.\n"
 481     "\n"
 482     "%s is distributed in the hope that it will be useful,\n"
 483     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 484     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 485     "GNU Lesser General Public License for more details.\n"
 486     "\n"
 487     "You should have received a copy of the GNU Lesser General Public License\n"
 488     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 489     program_name, program_name, program_name
 490 #else
 491     "%s is free software; you can redistribute it and/or\n"
 492     "modify it under the terms of the GNU Lesser General Public\n"
 493     "License as published by the Free Software Foundation; either\n"
 494     "version 2.1 of the License, or (at your option) any later version.\n"
 495     "\n"
 496     "%s is distributed in the hope that it will be useful,\n"
 497     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 498     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 499     "Lesser General Public License for more details.\n"
 500     "\n"
 501     "You should have received a copy of the GNU Lesser General Public\n"
 502     "License along with %s; if not, write to the Free Software\n"
 503     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 504     program_name, program_name, program_name
 505 #endif
 506     );
 507 }
 508
 509 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
 510 {
 511     int i;
 512     char fmt_str[128];
 513     for (i=-1; i < nb_fmts; i++) {
 514         get_fmt_string (fmt_str, sizeof(fmt_str), i);
 515         fprintf(stdout, "%s\n", fmt_str);
 516     }
 517 }
 518
 519 void show_formats(void)
 520 {
 521     AVInputFormat *ifmt=NULL;
 522     AVOutputFormat *ofmt=NULL;
 523     const char *last_name;
 524
 525     printf(
 526         "File formats:\n"
 527         " D. = Demuxing supported\n"
 528         " .E = Muxing supported\n"
 529         " --\n");
 530     last_name= "000";
 531     for(;;){
 532         int decode=0;
 533         int encode=0;
 534         const char *name=NULL;
 535         const char *long_name=NULL;
 536
 537         while((ofmt= av_oformat_next(ofmt))) {
 538             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 539                 strcmp(ofmt->name, last_name)>0){
 540                 name= ofmt->name;
 541                 long_name= ofmt->long_name;
 542                 encode=1;
 543             }
 544         }
 545         while((ifmt= av_iformat_next(ifmt))) {
 546             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 547                 strcmp(ifmt->name, last_name)>0){
 548                 name= ifmt->name;
 549                 long_name= ifmt->long_name;
 550                 encode=0;
 551             }
 552             if(name && strcmp(ifmt->name, name)==0)
 553                 decode=1;
 554         }
 555         if(name==NULL)
 556             break;
 557         last_name= name;
 558
 559         printf(
 560             " %s%s %-15s %s\n",
 561             decode ? "D":" ",
 562             encode ? "E":" ",
 563             name,
 564             long_name ? long_name:" ");
 565     }
 566 }
 567
 568 void show_codecs(void)
 569 {
 570     AVCodec *p=NULL, *p2;
 571     const char *last_name;
 572     printf(
 573         "Codecs:\n"
 574         " D..... = Decoding supported\n"
 575         " .E.... = Encoding supported\n"
 576         " ..V... = Video codec\n"
 577         " ..A... = Audio codec\n"
 578         " ..S... = Subtitle codec\n"
 579         " ...S.. = Supports draw_horiz_band\n"
 580         " ....D. = Supports direct rendering method 1\n"
 581         " .....T = Supports weird frame truncation\n"
 582         " ------\n");
 583     last_name= "000";
 584     for(;;){
 585         int decode=0;
 586         int encode=0;
 587         int cap=0;
 588         const char *type_str;
 589
 590         p2=NULL;
 591         while((p= av_codec_next(p))) {
 592             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 593                 strcmp(p->name, last_name)>0){
 594                 p2= p;
 595                 decode= encode= cap=0;
 596             }
 597             if(p2 && strcmp(p->name, p2->name)==0){
 598                 if(p->decode) decode=1;
 599                 if(p->encode) encode=1;
 600                 cap |= p->capabilities;
 601             }
 602         }
 603         if(p2==NULL)
 604             break;
 605         last_name= p2->name;
 606
 607         switch(p2->type) {
 608         case AVMEDIA_TYPE_VIDEO:
 609             type_str = "V";
 610             break;
 611         case AVMEDIA_TYPE_AUDIO:
 612             type_str = "A";
 613             break;
 614         case AVMEDIA_TYPE_SUBTITLE:
 615             type_str = "S";
 616             break;
 617         default:
 618             type_str = "?";
 619             break;
 620         }
 621         printf(
 622             " %s%s%s%s%s%s %-15s %s",
 623             decode ? "D": (/*p2->decoder ? "d":*/" "),
 624             encode ? "E":" ",
 625             type_str,
 626             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 627             cap & CODEC_CAP_DR1 ? "D":" ",
 628             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 629             p2->name,
 630             p2->long_name ? p2->long_name : "");
 631        /* if(p2->decoder && decode==0)
 632             printf(" use %s for decoding", p2->decoder->name);*/
 633         printf("\n");
 634     }
 635     printf("\n");
 636     printf(
 637 "Note, the names of encoders and decoders do not always match, so there are\n"
 638 "several cases where the above table shows encoder only or decoder only entries\n"
 639 "even though both encoding and decoding are supported. For example, the h263\n"
 640 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 641 "worse.\n");
 642 }
 643
 644 void show_bsfs(void)
 645 {
 646     AVBitStreamFilter *bsf=NULL;
 647
 648     printf("Bitstream filters:\n");
 649     while((bsf = av_bitstream_filter_next(bsf)))
 650         printf("%s\n", bsf->name);
 651     printf("\n");
 652 }
 653
 654 void show_protocols(void)
 655 {
 656     URLProtocol *up=NULL;
 657
 658     printf("Supported file protocols:\n"
 659            "I.. = Input  supported\n"
 660            ".O. = Output supported\n"
 661            "..S = Seek   supported\n"
 662            "FLAGS NAME\n"
 663            "----- \n");
 664     while((up = av_protocol_next(up)))
 665         printf("%c%c%c   %s\n",
 666                up->url_read  ? 'I' : '.',
 667                up->url_write ? 'O' : '.',
 668                up->url_seek  ? 'S' : '.',
 669                up->name);
 670 }
 671
 672 void show_filters(void)
 673 {
 674     AVFilter av_unused(**filter) = NULL;
 675
 676     printf("Filters:\n");
 677 #if CONFIG_AVFILTER
 678     while ((filter = av_filter_next(filter)) && *filter)
 679         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 680 #endif
 681 }
 682
 683 void show_pix_fmts(void)
 684 {
 685     enum PixelFormat pix_fmt;
 686
 687     printf(
 688         "Pixel formats:\n"
 689         "I.... = Supported Input  format for conversion\n"
 690         ".O... = Supported Output format for conversion\n"
 691         "..H.. = Hardware accelerated format\n"
 692         "...P. = Paletted format\n"
 693         "....B = Bitstream format\n"
 694         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 695         "-----\n");
 696
 697 #if !CONFIG_SWSCALE
 698 #   define sws_isSupportedInput(x)  0
 699 #   define sws_isSupportedOutput(x) 0
 700 #endif
 701
 702     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 703         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 704         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 705                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 706                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 707                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 708                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 709                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 710                pix_desc->name,
 711                pix_desc->nb_components,
 712                av_get_bits_per_pixel(pix_desc));
 713     }
 714 }
 715
 716 int read_yesno(void)
 717 {
 718     int c = getchar();
 719     int yesno = (toupper(c) == 'Y');
 720
 721     while (c != '\n' && c != EOF)
 722         c = getchar();
 723
 724     return yesno;
 725 }
 726
 727 int read_file(const char *filename, char **bufptr, size_t *size)
 728 {
 729     FILE *f = fopen(filename, "rb");
 730
 731     if (!f) {
 732         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 733         return AVERROR(errno);
 734     }
 735     fseek(f, 0, SEEK_END);
 736     *size = ftell(f);
 737     fseek(f, 0, SEEK_SET);
 738     *bufptr = av_malloc(*size + 1);
 739     if (!*bufptr) {
 740         fprintf(stderr, "Could not allocate file buffer\n");
 741         fclose(f);
 742         return AVERROR(ENOMEM);
 743     }
 744     fread(*bufptr, 1, *size, f);
 745     (*bufptr)[*size++] = '\0';
 746
 747     fclose(f);
 748     return 0;
 749 }
 750
 751 void init_pts_correction(PtsCorrectionContext *ctx)
 752 {
 753     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
 754     ctx->last_pts = ctx->last_dts = INT64_MIN;
 755 }
 756
 757 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
 758 {
 759     int64_t pts = AV_NOPTS_VALUE;
 760
 761     if (dts != AV_NOPTS_VALUE) {
 762         ctx->num_faulty_dts += dts <= ctx->last_dts;
 763         ctx->last_dts = dts;
 764     }
 765     if (reordered_pts != AV_NOPTS_VALUE) {
 766         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
 767         ctx->last_pts = reordered_pts;
 768     }
 769     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
 770        && reordered_pts != AV_NOPTS_VALUE)
 771         pts = reordered_pts;
 772     else
 773         pts = dts;
 774
 775     return pts;
 776 }
 777
 778 FILE *get_preset_file(char *filename, size_t filename_size,
 779                       const char *preset_name, int is_path, const char *codec_name)
 780 {
 781     FILE *f = NULL;
 782     int i;
 783     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 784                            getenv("HOME"),
 785                            FFMPEG_DATADIR,
 786                          };
 787
 788     if (is_path) {
 789         av_strlcpy(filename, preset_name, filename_size);
 790         f = fopen(filename, "r");
 791     } else {
 792         for (i = 0; i < 3 && !f; i++) {
 793             if (!base[i])
 794                 continue;
 795             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 796             f = fopen(filename, "r");
 797             if (!f && codec_name) {
 798                 snprintf(filename, filename_size,
 799                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 800                 f = fopen(filename, "r");
 801             }
 802         }
 803     }
 804
 805     return f;
 806 }
 807
 808 #if CONFIG_AVFILTER
 809
 810 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
 811 {
 812     FFSinkContext *priv = ctx->priv;
 813
 814     if (!opaque)
 815         return AVERROR(EINVAL);
 816     *priv = *(FFSinkContext *)opaque;
 817
 818     return 0;
 819 }
 820
 821 static void null_end_frame(AVFilterLink *inlink) { }
 822
 823 static int ffsink_query_formats(AVFilterContext *ctx)
 824 {
 825     FFSinkContext *priv = ctx->priv;
 826     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
 827
 828     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
 829     return 0;
 830 }
 831
 832 AVFilter ffsink = {
 833     .name      = "ffsink",
 834     .priv_size = sizeof(FFSinkContext),
 835     .init      = ffsink_init,
 836
 837     .query_formats = ffsink_query_formats,
 838
 839     .inputs    = (AVFilterPad[]) {{ .name          = "default",
 840                                     .type          = AVMEDIA_TYPE_VIDEO,
 841                                     .end_frame     = null_end_frame,
 842                                     .min_perms     = AV_PERM_READ, },
 843                                   { .name = NULL }},
 844     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
 845 };
 846
 847 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
 848                              AVFilterBufferRef **picref_ptr, AVRational *tb)
 849 {
 850     int ret;
 851     AVFilterBufferRef *picref;
 852
 853     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
 854         return ret;
 855     if (!(picref = ctx->inputs[0]->cur_buf))
 856         return AVERROR(ENOENT);
 857     *picref_ptr = picref;
 858     ctx->inputs[0]->cur_buf = NULL;
 859     *tb = ctx->inputs[0]->time_base;
 860
 861     memcpy(frame->data,     picref->data,     sizeof(frame->data));
 862     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
 863     frame->interlaced_frame = picref->video->interlaced;
 864     frame->top_field_first  = picref->video->top_field_first;
 865
 866     return 1;
 867 }
 868
 869 #endif /* CONFIG_AVFILTER */