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