ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/cmdutils.c

 /*
  * Various utilities for command line tools
  * Copyright (c) 2000-2003 Fabrice Bellard
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
@@ skipping 17 matching lines @@
    Studio) will not omit unused inline functions and create undefined
    references to libraries that are not being built. */
 
 #include "config.h"
 #include "libavformat/avformat.h"
 #include "libavfilter/avfilter.h"
 #include "libavdevice/avdevice.h"
 #include "libswscale/swscale.h"
 #include "libpostproc/postprocess.h"
 #include "libavutil/avstring.h"
+#include "libavutil/pixdesc.h"
 #include "libavcodec/opt.h"
 #include "cmdutils.h"
 #include "version.h"
 #if CONFIG_NETWORK
 #include "libavformat/network.h"
 #endif
 #if HAVE_SYS_RESOURCE_H
 #include <sys/resource.h>
 #endif
 
-#undef exit
-
 const char **opt_names;
 static int opt_name_count;
 AVCodecContext *avcodec_opts[CODEC_TYPE_NB];
 AVFormatContext *avformat_opts;
 struct SwsContext *sws_opts;
 
 const int this_year = 2010;
 
 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
 {
@@ skipping 103 matching lines @@
                 *po->u.str_arg = str;
             } else if (po->flags & OPT_BOOL) {
                 *po->u.int_arg = bool_val;
             } else if (po->flags & OPT_INT) {
                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
             } else if (po->flags & OPT_INT64) {
                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
             } else if (po->flags & OPT_FLOAT) {
                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
             } else if (po->flags & OPT_FUNC2) {
-                if(po->u.func2_arg(opt, arg)<0)
-                    goto unknown_opt;
+                if (po->u.func2_arg(opt, arg) < 0) {
+                    fprintf(stderr, "%s: invalid value '%s' for option '%s'\n", argv[0], arg, opt);
+                    exit(1);
+                }
             } else {
                 po->u.func_arg(arg);
             }
             if(po->flags & OPT_EXIT)
                 exit(0);
         } else {
             if (parse_arg_function)
                 parse_arg_function(opt);
         }
     }
 }
 
 int opt_default(const char *opt, const char *arg){
     int type;
     int ret= 0;
     const AVOption *o= NULL;
     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 
     for(type=0; type<CODEC_TYPE_NB && ret>= 0; type++){
         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
         if(o2)
             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
     }
     if(!o)
         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
-    if(!o)
+    if(!o && sws_opts)
         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
     if(!o){
         if(opt[0] == 'a')
             ret = av_set_string3(avcodec_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1, &o);
         else if(opt[0] == 'v')
             ret = av_set_string3(avcodec_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1, &o);
         else if(opt[0] == 's')
             ret = av_set_string3(avcodec_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1, &o);
     }
     if (o && ret < 0) {
         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
         exit(1);
     }
-    if(!o)
-        return -1;
+    if (!o) {
+        fprintf(stderr, "Unrecognized option '%s'\n", opt);
+        exit(1);
+    }
 
 //    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));
 
     //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
     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
     opt_names[opt_name_count++]= o->name;
 
     if(avcodec_opts[0]->debug || avformat_opts->debug)
         av_log_set_level(AV_LOG_DEBUG);
     return 0;
@@ skipping 29 matching lines @@
         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
         exit(1);
     }
     av_log_set_level(level);
     return 0;
 }
 
 int opt_timelimit(const char *opt, const char *arg)
 {
-#if HAVE_SYS_RESOURCE_H
+#if HAVE_SETRLIMIT
     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
     struct rlimit rl = { lim, lim + 1 };
     if (setrlimit(RLIMIT_CPU, &rl))
         perror("setrlimit");
 #else
     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 #endif
     return 0;
 }
 
@@ skipping 83 matching lines @@
     }
 }
 
 #define PRINT_LIB_CONFIG(lib, tag, cfg) do {    \
         if (CONFIG_##lib)                       \
             maybe_print_config(tag, cfg);       \
     } while (0)
 
 void show_banner(void)
 {
-    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d Fabrice Bellard, et al.\n",
+    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
             program_name, program_birth_year, this_year);
     fprintf(stderr, "  built on %s %s with %s %s\n",
             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
     PRINT_LIB_CONFIG(AVUTIL,   "libavutil",   avutil_configuration());
     PRINT_LIB_CONFIG(AVCODEC,  "libavcodec",  avcodec_configuration());
     PRINT_LIB_CONFIG(AVFORMAT, "libavformat", avformat_configuration());
     PRINT_LIB_CONFIG(AVDEVICE, "libavdevice", avdevice_configuration());
     PRINT_LIB_CONFIG(AVFILTER, "libavfilter", avfilter_configuration());
     PRINT_LIB_CONFIG(SWSCALE,  "libswscale",  swscale_configuration());
@@ skipping 238 matching lines @@
 
     printf("Filters:\n");
 #if CONFIG_AVFILTER
     while ((filter = av_filter_next(filter)) && *filter)
         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 #endif
 }
 
 void show_pix_fmts(void)
 {
-    list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
+    enum PixelFormat pix_fmt;
+
+    printf(
+        "Pixel formats:\n"
+        "I.... = Supported Input  format for conversion\n"
+        ".O... = Supported Output format for conversion\n"
+        "..H.. = Hardware accelerated format\n"
+        "...P. = Paletted format\n"
+        "....B = Bitstream format\n"
+        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
+        "-----\n");
+
+    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
+        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
+        printf("%c%c%c%c%c %-16s       %d            %2d\n",
+               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
+               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
+               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
+               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
+               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
+               pix_desc->name,
+               pix_desc->nb_components,
+               av_get_bits_per_pixel(pix_desc));
+    }
 }
 
 int read_yesno(void)
 {
     int c = getchar();
     int yesno = (toupper(c) == 'Y');
 
     while (c != '\n' && c != EOF)
         c = getchar();
 
     return yesno;
 }