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 "libavutil/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         av_freep(&opt_names[i]);
  83         av_freep(&opt_values[i]);
  84     }
  85     av_freep(&opt_names);
  86     av_freep(&opt_values);
  87 }
  88
  89 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
  90 {
  91     vfprintf(stdout, fmt, vl);
  92 }
  93
  94 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
  95 {
  96     char *tail;
  97     const char *error;
  98     double d = av_strtod(numstr, &tail);
  99     if (*tail)
 100         error= "Expected number for %s but found: %s\n";
 101     else if (d < min || d > max)
 102         error= "The value for %s was %s which is not within %f - %f\n";
 103     else if(type == OPT_INT64 && (int64_t)d != d)
 104         error= "Expected int64 for %s but found %s\n";
 105     else if (type == OPT_INT && (int)d != d)
 106         error= "Expected int for %s but found %s\n";
 107     else
 108         return d;
 109     fprintf(stderr, error, context, numstr, min, max);
 110     exit(1);
 111 }
 112
 113 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
 114 {
 115     int64_t us;
 116     if (av_parse_time(&us, timestr, is_duration) < 0) {
 117         fprintf(stderr, "Invalid %s specification for %s: %s\n",
 118                 is_duration ? "duration" : "date", context, timestr);
 119         exit(1);
 120     }
 121     return us;
 122 }
 123
 124 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
 125 {
 126     const OptionDef *po;
 127     int first;
 128
 129     first = 1;
 130     for(po = options; po->name != NULL; po++) {
 131         char buf[64];
 132         if ((po->flags & mask) == value) {
 133             if (first) {
 134                 printf("%s", msg);
 135                 first = 0;
 136             }
 137             av_strlcpy(buf, po->name, sizeof(buf));
 138             if (po->flags & HAS_ARG) {
 139                 av_strlcat(buf, " ", sizeof(buf));
 140                 av_strlcat(buf, po->argname, sizeof(buf));
 141             }
 142             printf("-%-17s  %s\n", buf, po->help);
 143         }
 144     }
 145 }
 146
 147 static const OptionDef* find_option(const OptionDef *po, const char *name){
 148     while (po->name != NULL) {
 149         if (!strcmp(name, po->name))
 150             break;
 151         po++;
 152     }
 153     return po;
 154 }
 155
 156 void parse_options(int argc, char **argv, const OptionDef *options,
 157                    void (* parse_arg_function)(const char*))
 158 {
 159     const char *opt, *arg;
 160     int optindex, handleoptions=1;
 161     const OptionDef *po;
 162
 163     /* parse options */
 164     optindex = 1;
 165     while (optindex < argc) {
 166         opt = argv[optindex++];
 167
 168         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 169             int bool_val = 1;
 170             if (opt[1] == '-' && opt[2] == '\0') {
 171                 handleoptions = 0;
 172                 continue;
 173             }
 174             opt++;
 175             po= find_option(options, opt);
 176             if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
 177                 /* handle 'no' bool option */
 178                 po = find_option(options, opt + 2);
 179                 if (!(po->name && (po->flags & OPT_BOOL)))
 180                     goto unknown_opt;
 181                 bool_val = 0;
 182             }
 183             if (!po->name)
 184                 po= find_option(options, "default");
 185             if (!po->name) {
 186 unknown_opt:
 187                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 188                 exit(1);
 189             }
 190             arg = NULL;
 191             if (po->flags & HAS_ARG) {
 192                 arg = argv[optindex++];
 193                 if (!arg) {
 194                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 195                     exit(1);
 196                 }
 197             }
 198             if (po->flags & OPT_STRING) {
 199                 char *str;
 200                 str = av_strdup(arg);
 201                 *po->u.str_arg = str;
 202             } else if (po->flags & OPT_BOOL) {
 203                 *po->u.int_arg = bool_val;
 204             } else if (po->flags & OPT_INT) {
 205                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 206             } else if (po->flags & OPT_INT64) {
 207                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 208             } else if (po->flags & OPT_FLOAT) {
 209                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
 210             } else if (po->flags & OPT_FUNC2) {
 211                 if (po->u.func2_arg(opt, arg) < 0) {
 212                     fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
 213                     exit(1);
 214                 }
 215             } else if (po->flags & OPT_DUMMY) {
 216                 /* Do nothing for this option */
 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     AVCodec *p = NULL;
 235     AVOutputFormat *oformat = NULL;
 236
 237     while ((p = av_codec_next(p))) {
 238         AVClass *c = p->priv_class;
 239         if (c && av_find_opt(&c, opt, NULL, 0, 0))
 240             break;
 241     }
 242     if (p)
 243         goto out;
 244     while ((oformat = av_oformat_next(oformat))) {
 245         const AVClass *c = oformat->priv_class;
 246         if (c && av_find_opt(&c, opt, NULL, 0, 0))
 247             break;
 248     }
 249     if (oformat)
 250         goto out;
 251
 252     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
 253         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 254         if(o2)
 255             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 256     }
 257     if(!o && avformat_opts)
 258         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 259     if(!o && sws_opts)
 260         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 261     if(!o){
 262         if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
 263             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
 264         else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
 265             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
 266         else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
 267             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 268         if (ret >= 0)
 269             opt += 1;
 270     }
 271     if (o && ret < 0) {
 272         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 273         exit(1);
 274     }
 275     if (!o) {
 276         fprintf(stderr, "Unrecognized option '%s'\n", opt);
 277         exit(1);
 278     }
 279
 280  out:
 281 //    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));
 282
 283     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
 284     opt_values[opt_name_count] = av_strdup(arg);
 285     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 286     opt_names[opt_name_count++] = av_strdup(opt);
 287
 288     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
 289         av_log_set_level(AV_LOG_DEBUG);
 290     return 0;
 291 }
 292
 293 int opt_loglevel(const char *opt, const char *arg)
 294 {
 295     const struct { const char *name; int level; } log_levels[] = {
 296         { "quiet"  , AV_LOG_QUIET   },
 297         { "panic"  , AV_LOG_PANIC   },
 298         { "fatal"  , AV_LOG_FATAL   },
 299         { "error"  , AV_LOG_ERROR   },
 300         { "warning", AV_LOG_WARNING },
 301         { "info"   , AV_LOG_INFO    },
 302         { "verbose", AV_LOG_VERBOSE },
 303         { "debug"  , AV_LOG_DEBUG   },
 304     };
 305     char *tail;
 306     int level;
 307     int i;
 308
 309     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 310         if (!strcmp(log_levels[i].name, arg)) {
 311             av_log_set_level(log_levels[i].level);
 312             return 0;
 313         }
 314     }
 315
 316     level = strtol(arg, &tail, 10);
 317     if (*tail) {
 318         fprintf(stderr, "Invalid loglevel \"%s\". "
 319                         "Possible levels are numbers or:\n", arg);
 320         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 321             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 322         exit(1);
 323     }
 324     av_log_set_level(level);
 325     return 0;
 326 }
 327
 328 int opt_timelimit(const char *opt, const char *arg)
 329 {
 330 #if HAVE_SETRLIMIT
 331     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 332     struct rlimit rl = { lim, lim + 1 };
 333     if (setrlimit(RLIMIT_CPU, &rl))
 334         perror("setrlimit");
 335 #else
 336     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 337 #endif
 338     return 0;
 339 }
 340
 341 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
 342 {
 343     int i;
 344     void *priv_ctx=NULL;
 345     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
 346         AVCodecContext *avctx= ctx;
 347         if(codec && codec->priv_class && avctx->priv_data){
 348             priv_ctx= avctx->priv_data;
 349         }
 350     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
 351         AVFormatContext *avctx = ctx;
 352         if (avctx->oformat && avctx->oformat->priv_class) {
 353             priv_ctx = avctx->priv_data;
 354         }
 355     }
 356
 357     for(i=0; i<opt_name_count; i++){
 358         char buf[256];
 359         const AVOption *opt;
 360         const char *str;
 361         if (priv_ctx) {
 362             if (av_find_opt(priv_ctx, opt_names[i], NULL, flags, flags)) {
 363                 if (av_set_string3(priv_ctx, opt_names[i], opt_values[i], 0, NULL) < 0) {
 364                     fprintf(stderr, "Invalid value '%s' for option '%s'\n",
 365                             opt_names[i], opt_values[i]);
 366                     exit(1);
 367                 }
 368             } else
 369                 goto global;
 370         } else {
 371         global:
 372             str = av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 373             /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 374             if (str && ((opt->flags & flags) == flags))
 375                 av_set_string3(ctx, opt_names[i], str, 1, NULL);
 376         }
 377     }
 378 }
 379
 380 void print_error(const char *filename, int err)
 381 {
 382     char errbuf[128];
 383     const char *errbuf_ptr = errbuf;
 384
 385     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 386         errbuf_ptr = strerror(AVUNERROR(err));
 387     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
 388 }
 389
 390 static int warned_cfg = 0;
 391
 392 #define INDENT        1
 393 #define SHOW_VERSION  2
 394 #define SHOW_CONFIG   4
 395
 396 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 397     if (CONFIG_##LIBNAME) {                                             \
 398         const char *indent = flags & INDENT? "  " : "";                 \
 399         if (flags & SHOW_VERSION) {                                     \
 400             unsigned int version = libname##_version();                 \
 401             fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
 402                     indent, #libname,                                   \
 403                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 404                     LIB##LIBNAME##_VERSION_MINOR,                       \
 405                     LIB##LIBNAME##_VERSION_MICRO,                       \
 406                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 407         }                                                               \
 408         if (flags & SHOW_CONFIG) {                                      \
 409             const char *cfg = libname##_configuration();                \
 410             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 411                 if (!warned_cfg) {                                      \
 412                     fprintf(outstream,                                  \
 413                             "%sWARNING: library configuration mismatch\n", \
 414                             indent);                                    \
 415                     warned_cfg = 1;                                     \
 416                 }                                                       \
 417                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 418                         indent, #libname, cfg);                         \
 419             }                                                           \
 420         }                                                               \
 421     }                                                                   \
 422
 423 static void print_all_libs_info(FILE* outstream, int flags)
 424 {
 425     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 426     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 427     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 428     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 429     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 430     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 431     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 432 }
 433
 434 void show_banner(void)
 435 {
 436     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
 437             program_name, program_birth_year, this_year);
 438     fprintf(stderr, "  built on %s %s with %s %s\n",
 439             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 440     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 441     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 442     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 443 }
 444
 445 void show_version(void) {
 446     printf("%s " FFMPEG_VERSION "\n", program_name);
 447     print_all_libs_info(stdout, SHOW_VERSION);
 448 }
 449
 450 void show_license(void)
 451 {
 452     printf(
 453 #if CONFIG_NONFREE
 454     "This version of %s has nonfree parts compiled in.\n"
 455     "Therefore it is not legally redistributable.\n",
 456     program_name
 457 #elif CONFIG_GPLV3
 458     "%s is free software; you can redistribute it and/or modify\n"
 459     "it under the terms of the GNU General Public License as published by\n"
 460     "the Free Software Foundation; either version 3 of the License, or\n"
 461     "(at your option) any later version.\n"
 462     "\n"
 463     "%s is distributed in the hope that it will be useful,\n"
 464     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 465     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 466     "GNU General Public License for more details.\n"
 467     "\n"
 468     "You should have received a copy of the GNU General Public License\n"
 469     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 470     program_name, program_name, program_name
 471 #elif CONFIG_GPL
 472     "%s is free software; you can redistribute it and/or modify\n"
 473     "it under the terms of the GNU General Public License as published by\n"
 474     "the Free Software Foundation; either version 2 of the License, or\n"
 475     "(at your option) any later version.\n"
 476     "\n"
 477     "%s is distributed in the hope that it will be useful,\n"
 478     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 479     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 480     "GNU General Public License for more details.\n"
 481     "\n"
 482     "You should have received a copy of the GNU General Public License\n"
 483     "along with %s; if not, write to the Free Software\n"
 484     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 485     program_name, program_name, program_name
 486 #elif CONFIG_LGPLV3
 487     "%s is free software; you can redistribute it and/or modify\n"
 488     "it under the terms of the GNU Lesser General Public License as published by\n"
 489     "the Free Software Foundation; either version 3 of the License, or\n"
 490     "(at your option) any later version.\n"
 491     "\n"
 492     "%s is distributed in the hope that it will be useful,\n"
 493     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 494     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 495     "GNU Lesser General Public License for more details.\n"
 496     "\n"
 497     "You should have received a copy of the GNU Lesser General Public License\n"
 498     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 499     program_name, program_name, program_name
 500 #else
 501     "%s is free software; you can redistribute it and/or\n"
 502     "modify it under the terms of the GNU Lesser General Public\n"
 503     "License as published by the Free Software Foundation; either\n"
 504     "version 2.1 of the License, or (at your option) any later version.\n"
 505     "\n"
 506     "%s is distributed in the hope that it will be useful,\n"
 507     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 508     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 509     "Lesser General Public License for more details.\n"
 510     "\n"
 511     "You should have received a copy of the GNU Lesser General Public\n"
 512     "License along with %s; if not, write to the Free Software\n"
 513     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 514     program_name, program_name, program_name
 515 #endif
 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 FILE *get_preset_file(char *filename, size_t filename_size,
 752                       const char *preset_name, int is_path, const char *codec_name)
 753 {
 754     FILE *f = NULL;
 755     int i;
 756     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 757                            getenv("HOME"),
 758                            FFMPEG_DATADIR,
 759                          };
 760
 761     if (is_path) {
 762         av_strlcpy(filename, preset_name, filename_size);
 763         f = fopen(filename, "r");
 764     } else {
 765         for (i = 0; i < 3 && !f; i++) {
 766             if (!base[i])
 767                 continue;
 768             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 769             f = fopen(filename, "r");
 770             if (!f && codec_name) {
 771                 snprintf(filename, filename_size,
 772                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 773                 f = fopen(filename, "r");
 774             }
 775         }
 776     }
 777
 778     return f;
 779 }
 780
 781 #if CONFIG_AVFILTER
 782
 783 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
 784 {
 785     FFSinkContext *priv = ctx->priv;
 786
 787     if (!opaque)
 788         return AVERROR(EINVAL);
 789     *priv = *(FFSinkContext *)opaque;
 790
 791     return 0;
 792 }
 793
 794 static void null_end_frame(AVFilterLink *inlink) { }
 795
 796 static int ffsink_query_formats(AVFilterContext *ctx)
 797 {
 798     FFSinkContext *priv = ctx->priv;
 799     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
 800
 801     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
 802     return 0;
 803 }
 804
 805 AVFilter ffsink = {
 806     .name      = "ffsink",
 807     .priv_size = sizeof(FFSinkContext),
 808     .init      = ffsink_init,
 809
 810     .query_formats = ffsink_query_formats,
 811
 812     .inputs    = (AVFilterPad[]) {{ .name          = "default",
 813                                     .type          = AVMEDIA_TYPE_VIDEO,
 814                                     .end_frame     = null_end_frame,
 815                                     .min_perms     = AV_PERM_READ, },
 816                                   { .name = NULL }},
 817     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
 818 };
 819
 820 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
 821                              AVFilterBufferRef **picref_ptr, AVRational *tb)
 822 {
 823     int ret;
 824     AVFilterBufferRef *picref;
 825
 826     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
 827         return ret;
 828     if (!(picref = ctx->inputs[0]->cur_buf))
 829         return AVERROR(ENOENT);
 830     *picref_ptr = picref;
 831     ctx->inputs[0]->cur_buf = NULL;
 832     *tb = ctx->inputs[0]->time_base;
 833
 834     memcpy(frame->data,     picref->data,     sizeof(frame->data));
 835     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
 836     frame->interlaced_frame = picref->video->interlaced;
 837     frame->top_field_first  = picref->video->top_field_first;
 838     frame->key_frame        = picref->video->key_frame;
 839     frame->pict_type        = picref->video->pict_type;
 840
 841     return 1;
 842 }
 843
 844 #endif /* CONFIG_AVFILTER */