diff了一下,我的svn的ffmpeg和在网站上下载的最新的ffmpeg 0.6.1

diff了一下,我的svn的ffmpeg和在网站上下载的最新的ffmpeg 0.6.1

发现还是有很多很多的不同。- -!

root@ubuntu:/home/zhangbin/Documents# diff ffmpeg ffmpeg-0.6.1 > diff-result.txt 

据说只是比较目录下的文件,不比较子目录中的。

diff ffmpeg/Changelog ffmpeg-0.6.1/Changelog

3a4

> version 0.6.1:

5,73c6,12

< version <next>:

< - WebM support in Matroska de/muxer

< - low overhead Ogg muxing

< - MMS-TCP support

< - VP8 de/encoding via libvpx

< - Demuxer for On2's IVF format

< - Pictor/PC Paint decoder

< - HE-AAC v2 decoder

< - libfaad2 wrapper removed

< - DTS-ES extension (XCh) decoding support

< - native VP8 decoder

< - RTSP tunneling over HTTP

< - RTP depacketization of SVQ3

< - -strict inofficial replaced by -strict unofficial

< - ffplay -exitonkeydown and -exitonmousedown options added

< - native GSM / GSM MS decoder

< - RTP depacketization of QDM2

< - ANSI/ASCII art playback system

< - Lego Mindstorms RSO de/muxer

< - libavcore added

< - SubRip subtitle file muxer and demuxer

< - Chinese AVS encoding via libxavs

< - ffprobe -show_packets option added

< - RTP packetization of Theora and Vorbis

< - RTP depacketization of MP4A-LATM

< - RTP packetization and depacketization of VP8

< - hflip filter

< - Apple HTTP Live Streaming demuxer

< - a64 codec

< - MMS-HTTP support

< - G.722 ADPCM audio encoder/decoder

< - R10k video decoder

< - ocv_smooth filter

< - frei0r wrapper filter

< - change crop filter syntax to width:height:x:y

< - make the crop filter accept parametric expressions

< - make ffprobe accept AVFormatContext options

< - yadif filter

< - blackframe filter

< - Demuxer for Leitch/Harris' VR native stream format (LXF)

< - RTP depacketization of the X-QT QuickTime format

< - SAP (Session Announcement Protocol, RFC 2974) muxer and demuxer

< - cropdetect filter

< - ffmpeg -crop* options removed

< - transpose filter added

< - ffmpeg -force_key_frames option added

< - demuxer for receiving raw rtp:// URLs without an SDP description

< - single stream LATM/LOAS decoder

< - setpts filter added

< - Win64 support for optimized asm functions

< - MJPEG/AVI1 to JPEG/JFIF bitstream filter

< - ASS subtitle encoder and decoder

< - IEC 61937 encapsulation for E-AC3 and TrueHD (for HDMI passthrough)

< - overlay filter added

< - rename aspect filter to setdar, and pixelaspect to setsar

< - IEC 61937 demuxer

< - Mobotix .mxg demuxer

< - frei0r source added

< - hqdn3d filter added

< - RTP depacketization of QCELP

< - FLAC parser added

< - gradfun filter added

< - AMR-WB decoder

< - replace the ocv_smooth filter with a more generic ocv filter

< - Windows Televison (WTV) demuxer

< - FFmpeg metadata format muxer and demuxer

< - SubRip (srt) subtitle decoder

< - floating-point AC-3 encoder added

---

> - fix autodetection of E-AC-3 substream samples

> - performance fix for seekable HTTP

> - backport AAC-HE v2 from trunk

> - add missing VP80 fourcc code for the VP8 codec

> - small documentation fixes

> - fix several potentially exploitable issues in the FLIC decoder

>   (addresses CVE-2010-3429)

82c21

< - Alpha channel scaler

---

> - alpha channel scaler

151c90,94

< - RealAudio 1.0 (14.4K) encoder

---

> - WebM support in Matroska de/muxer

> - low overhead Ogg muxing

> - VP8 de/encoding via libvpx

> - CODEC_CAP_EXPERIMENTAL added

315a259

399a344

410a356

451a398

488a436

519a468

544a494

565a516

595a547

623a576

628a582

636a591

642a598

649a606

diff ffmpeg/cmdutils.c ffmpeg-0.6.1/cmdutils.c

39d38

< #include "libavutil/eval.h"

41d39

< #include "libavcore/avcore.h"

52d49

< const char **opt_values;

58,86c55

< const int this_year = 2011;

< void init_opts(void)

< {

<     int i;

<     for (i = 0; i < AVMEDIA_TYPE_NB; i++)

<         avcodec_opts[i] = avcodec_alloc_context2(i);

<     avformat_opts = avformat_alloc_context();

< #if CONFIG_SWSCALE

<     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);

< #endif

< }

< void uninit_opts(void)

< {

<     int i;

<     for (i = 0; i < AVMEDIA_TYPE_NB; i++)

<         av_freep(&avcodec_opts[i]);

<     av_freep(&avformat_opts->key);

<     av_freep(&avformat_opts);

< #if CONFIG_SWSCALE

<     av_freep(&sws_opts);

< #endif

< }

< void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)

< {

<     vfprintf(stdout, fmt, vl);

< }

---

> const int this_year = 2010;

92c61

<     double d = av_strtod(numstr, &tail);

---

>     double d = strtod(numstr, &tail);

225c194

<     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){

---

>     for(type=0; type<AVMEDIA_TYPE_NB && ret>= 0; type++){

230c199

<     if(!o && avformat_opts)

---

>     if(!o)

235c204

<         if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])

---

>         if(opt[0] == 'a')

237c206

<         else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])

---

>         else if(opt[0] == 'v')

239c208

<         else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])

---

>         else if(opt[0] == 's')

247,264c216,217

<         AVCodec *p = NULL;

<         AVOutputFormat *oformat = NULL;

<         while ((p=av_codec_next(p))){

<             AVClass *c= p->priv_class;

<             if(c && av_find_opt(&c, opt, NULL, 0, 0))

<                 break;

<         }

<         if (!p) {

<             while ((oformat = av_oformat_next(oformat))) {

<                 const AVClass *c = oformat->priv_class;

<                 if (c && av_find_opt(&c, opt, NULL, 0, 0))

<                     break;

<             }

<         }

<         if(!p && !oformat){

<             fprintf(stderr, "Unrecognized option '%s'/n", opt);

<             exit(1);

<         }

---

>         fprintf(stderr, "Unrecognized option '%s'/n", opt);

>         exit(1);

270,271d222

<     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));

<     opt_values[opt_name_count]= o ? NULL : arg;

273c224

<     opt_names[opt_name_count++]= o ? o->name : opt;

---

>     opt_names[opt_name_count++]= o->name;

275c226

<     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))

---

>     if(avcodec_opts[0]->debug || avformat_opts->debug)

328c279

< void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)

---

> void set_context_opts(void *ctx, void *opts_ctx, int flags)

331,343d281

<     void *priv_ctx=NULL;

<     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){

<         AVCodecContext *avctx= ctx;

<         if(codec && codec->priv_class && avctx->priv_data){

<             priv_ctx= avctx->priv_data;

<         }

<     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {

<         AVFormatContext *avctx = ctx;

<         if (avctx->oformat && avctx->oformat->priv_class) {

<             priv_ctx = avctx->priv_data;

<         }

<     }

351,356d288

<         /* We need to use a differnt system to pass options to the private context because

<            it is not known which codec and thus context kind that will be when parsing options

<            we thus use opt_values directly instead of opts_ctx */

<         if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){

<             av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);

<         }

370c302,322

< static int warned_cfg = 0;

---

> #define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent)             /

>     if (CONFIG_##LIBNAME) {                                             /

>         unsigned int version = libname##_version();                     /

>         fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d/n",    /

>                 indent? "  " : "", #libname,                            /

>                 LIB##LIBNAME##_VERSION_MAJOR,                           /

>                 LIB##LIBNAME##_VERSION_MINOR,                           /

>                 LIB##LIBNAME##_VERSION_MICRO,                           /

>                 version >> 16, version >> 8 & 0xff, version & 0xff);    /

>     }

> static void print_all_lib_versions(FILE* outstream, int indent)

> {

>     PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);

>     PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);

>     PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);

>     PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);

>     PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);

>     PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);

>     PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);

> }

372,374c324,326

< #define INDENT        1

< #define SHOW_VERSION  2

< #define SHOW_CONFIG   4

---

> static void maybe_print_config(const char *lib, const char *cfg)

> {

>     static int warned_cfg;

376,412c328,334

< #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 /

<     if (CONFIG_##LIBNAME) {                                             /

<         const char *indent = flags & INDENT? "  " : "";                 /

<         if (flags & SHOW_VERSION) {                                     /

<             unsigned int version = libname##_version();                 /

<             fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d/n", /

<                     indent, #libname,                                   /

<                     LIB##LIBNAME##_VERSION_MAJOR,                       /

<                     LIB##LIBNAME##_VERSION_MINOR,                       /

<                     LIB##LIBNAME##_VERSION_MICRO,                       /

<                     version >> 16, version >> 8 & 0xff, version & 0xff); /

<         }                                                               /

<         if (flags & SHOW_CONFIG) {                                      /

<             const char *cfg = libname##_configuration();                /

<             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    /

<                 if (!warned_cfg) {                                      /

<                     fprintf(outstream,                                  /

<                             "%sWARNING: library configuration mismatch/n", /

<                             indent);                                    /

<                     warned_cfg = 1;                                     /

<                 }                                                       /

<                 fprintf(stderr, "%s%-11s configuration: %s/n",          /

<                         indent, #libname, cfg);                         /

<             }                                                           /

<         }                                                               /

<     }                                                                   /

< static void print_all_libs_info(FILE* outstream, int flags)

< {

<     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);

<     PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);

<     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);

<     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);

<     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);

<     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);

<     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);

<     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);

---

>     if (strcmp(FFMPEG_CONFIGURATION, cfg)) {

>         if (!warned_cfg) {

>             fprintf(stderr, "  WARNING: library configuration mismatch/n");

>             warned_cfg = 1;

>         }

>         fprintf(stderr, "  %-11s configuration: %s/n", lib, cfg);

>     }

414a337,341

> #define PRINT_LIB_CONFIG(lib, tag, cfg) do {    /

>         if (CONFIG_##lib)                       /

>             maybe_print_config(tag, cfg);       /

>     } while (0)

422,423c349,356

<     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);

<     print_all_libs_info(stderr, INDENT|SHOW_VERSION);

---

>     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());

>     PRINT_LIB_CONFIG(POSTPROC, "libpostproc", postproc_configuration());

>     print_all_lib_versions(stderr, 1);

428c361

<     print_all_libs_info(stdout, SHOW_VERSION);

---

>     print_all_lib_versions(stdout, 0);

649,654c582

<     printf("Supported file protocols:/n"

<            "I.. = Input  supported/n"

<            ".O. = Output supported/n"

<            "..S = Seek   supported/n"

<            "FLAGS NAME/n"

<            "----- /n");

---

>     printf("Supported file protocols:/n");

656,660c584

<         printf("%c%c%c   %s/n",

<                up->url_read  ? 'I' : '.',

<                up->url_write ? 'O' : '.',

<                up->url_seek  ? 'S' : '.',

<                up->name);

---

>         printf("%s/n", up->name);

741,860d664

< void init_pts_correction(PtsCorrectionContext *ctx)

< {

<     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;

<     ctx->last_pts = ctx->last_dts = INT64_MIN;

< }

< int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)

< {

<     int64_t pts = AV_NOPTS_VALUE;

<     if (dts != AV_NOPTS_VALUE) {

<         ctx->num_faulty_dts += dts <= ctx->last_dts;

<         ctx->last_dts = dts;

<     }

<     if (reordered_pts != AV_NOPTS_VALUE) {

<         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;

<         ctx->last_pts = reordered_pts;

<     }

<     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)

<        && reordered_pts != AV_NOPTS_VALUE)

<         pts = reordered_pts;

<     else

<         pts = dts;

<     return pts;

< }

< FILE *get_preset_file(char *filename, size_t filename_size,

<                       const char *preset_name, int is_path, const char *codec_name)

< {

<     FILE *f = NULL;

<     int i;

<     const char *base[3]= { getenv("FFMPEG_DATADIR"),

<                            getenv("HOME"),

<                            FFMPEG_DATADIR,

<                          };

<     if (is_path) {

<         av_strlcpy(filename, preset_name, filename_size);

<         f = fopen(filename, "r");

<     } else {

<         for (i = 0; i < 3 && !f; i++) {

<             if (!base[i])

<                 continue;

<             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);

<             f = fopen(filename, "r");

<             if (!f && codec_name) {

<                 snprintf(filename, filename_size,

<                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);

<                 f = fopen(filename, "r");

<             }

<         }

<     }

<     return f;

< }

< #if CONFIG_AVFILTER

< static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)

< {

<     FFSinkContext *priv = ctx->priv;

<     if (!opaque)

<         return AVERROR(EINVAL);

<     *priv = *(FFSinkContext *)opaque;

<     return 0;

< }

< static void null_end_frame(AVFilterLink *inlink) { }

< static int ffsink_query_formats(AVFilterContext *ctx)

< {

<     FFSinkContext *priv = ctx->priv;

<     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };

<     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));

<     return 0;

< }

< AVFilter ffsink = {

<     .name      = "ffsink",

<     .priv_size = sizeof(FFSinkContext),

<     .init      = ffsink_init,

<     .query_formats = ffsink_query_formats,

<     .inputs    = (AVFilterPad[]) {{ .name          = "default",

<                                     .type          = AVMEDIA_TYPE_VIDEO,

<                                     .end_frame     = null_end_frame,

<                                     .min_perms     = AV_PERM_READ, },

<                                   { .name = NULL }},

<     .outputs   = (AVFilterPad[]) {{ .name = NULL }},

< };

< int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,

<                              AVFilterBufferRef **picref_ptr, AVRational *tb)

< {

<     int ret;

<     AVFilterBufferRef *picref;

<     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)

<         return ret;

<     if (!(picref = ctx->inputs[0]->cur_buf))

<         return AVERROR(ENOENT);

<     *picref_ptr = picref;

<     ctx->inputs[0]->cur_buf = NULL;

<     *tb = ctx->inputs[0]->time_base;

<     memcpy(frame->data,     picref->data,     sizeof(frame->data));

<     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));

<     frame->interlaced_frame = picref->video->interlaced;

<     frame->top_field_first  = picref->video->top_field_first;

<     return 1;

< }

< #endif /* CONFIG_AVFILTER */

diff ffmpeg/cmdutils.d ffmpeg-0.6.1/cmdutils.d

2,5c2,4

<  libavcodec/avcodec.h libavcore/samplefmt.h libavutil/avutil.h /

<  libavutil/common.h libavutil/attributes.h libavutil/avconfig.h /

<  libavutil/mem.h libavutil/avutil.h libavutil/error.h /

<  libavutil/mathematics.h libavutil/rational.h /

---

>  libavcodec/avcodec.h libavutil/avutil.h libavutil/common.h /

>  libavutil/attributes.h libavutil/mem.h libavutil/error.h /

>  libavutil/avutil.h libavutil/mathematics.h libavutil/rational.h /

7,14c6,10

<  libavutil/cpu.h libavcore/audioconvert.h libavcore/avcore.h /

<  libavformat/avio.h libavutil/common.h libavutil/log.h /

<  libavfilter/avfilter.h libavcore/avcore.h libavdevice/avdevice.h /

<  libswscale/swscale.h libpostproc/postprocess.h libavutil/avstring.h /

<  libavutil/pixdesc.h libavutil/eval.h libavutil/avutil.h libavcodec/opt.h /

<  libavutil/rational.h libavcodec/avcodec.h libavutil/opt.h /

<  libavcore/avcore.h cmdutils.h libavcodec/avcodec.h version.h /

<  libavformat/network.h config.h

---

>  libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

>  libavfilter/avfilter.h libavdevice/avdevice.h libswscale/swscale.h /

>  libpostproc/postprocess.h libavutil/avstring.h libavutil/pixdesc.h /

>  libavcodec/opt.h libavutil/rational.h libavcodec/avcodec.h cmdutils.h /

>  libavcodec/avcodec.h version.h libavformat/network.h config.h

diff ffmpeg/cmdutils.h ffmpeg-0.6.1/cmdutils.h

48,64d47

<  * Initialize the cmdutils option system, in particular

<  * allocate the *_opts contexts.

<  */

< void init_opts(void);

< /**

<  * Uninitialize the cmdutils option system, in particular

<  * free the *_opts contexts and their contents.

<  */

< void uninit_opts(void);

< /**

<  * Trivial log callback.

<  * Only suitable for show_help and similar since it lacks prefix handling.

<  */

< void log_callback_help(void* ptr, int level, const char* fmt, va_list vl);

< /**

71c54

<  * Set the libav* libraries log level.

---

>  * Sets the libav* libraries log level.

81,82c64,65

<  * Parse a string and return its corresponding value as a double.

<  * Exit from the application if the string cannot be correctly

---

>  * Parses a string and returns its corresponding value as a double.

>  * Exits from the application if the string cannot be correctly

96,97c79,80

<  * Parse a string specifying a time and return its corresponding

<  * value as a number of microseconds. Exit from the application if

---

>  * Parses a string specifying a time and returns its corresponding

>  * value as a number of microseconds. Exits from the application if

142c125

<  * Parse the command line arguments.

---

>  * Parses the command line arguments.

144c127

<  * option of the form: -option_name [argument]

---

>  * option of the form: -<option_name> [<argument>]

152c135

< void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec);

---

> void set_context_opts(void *ctx, void *opts_ctx, int flags);

155c138

<  * Print an error message to stderr, indicating filename and a human

---

>  * Prints an error message to stderr, indicating filename and a human

168c151

<  * Print the program banner to stderr. The banner contents depend on the

---

>  * Prints the program banner to stderr. The banner contents depend on the

175c158

<  * Print the version of the program to stdout. The version message

---

>  * Prints the version of the program to stdout. The version message

182c165

<  * Print the license of the program to stdout. The license depends on

---

>  * Prints the license of the program to stdout. The license depends on

188c171

<  * Print a listing containing all the formats supported by the

---

>  * Prints a listing containing all the formats supported by the

194c177

<  * Print a listing containing all the codecs supported by the

---

>  * Prints a listing containing all the codecs supported by the

200c183

<  * Print a listing containing all the filters supported by the

---

>  * Prints a listing containing all the filters supported by the

206c189

<  * Print a listing containing all the bit stream filters supported by the

---

>  * Prints a listing containing all the bit stream filters supported by the

212c195

<  * Print a listing containing all the protocols supported by the

---

>  * Prints a listing containing all the protocols supported by the

218c201

<  * Print a listing containing all the pixel formats supported by the

---

>  * Prints a listing containing all the pixel formats supported by the

224,225c207,208

<  * Return a positive value if a line read from standard input

<  * starts with [yY], otherwise return 0.

---

>  * Returns a positive value if reads from standard input a line

>  * starting with [yY], otherwise returns 0.

230c213

<  * Read the file with name filename, and put its content in a newly

---

>  * Reads the file with name filename, and puts its content in a newly

233,234c216,217

<  * @param bufptr location where pointer to buffer is returned

<  * @param size   location where size of buffer is returned

---

>  * @param bufptr puts here the pointer to the newly allocated buffer

>  * @param size puts here the size of the newly allocated buffer

240,303d222

< typedef struct {

<     int64_t num_faulty_pts; /// Number of incorrect PTS values so far

<     int64_t num_faulty_dts; /// Number of incorrect DTS values so far

<     int64_t last_pts;       /// PTS of the last frame

<     int64_t last_dts;       /// DTS of the last frame

< } PtsCorrectionContext;

< /**

<  * Reset the state of the PtsCorrectionContext.

<  */

< void init_pts_correction(PtsCorrectionContext *ctx);

< /**

<  * Attempt to guess proper monotonic timestamps for decoded video frames

<  * which might have incorrect times. Input timestamps may wrap around, in

<  * which case the output will as well.

<  *

<  * @param pts the pts field of the decoded AVPacket, as passed through

<  * AVCodecContext.reordered_opaque

<  * @param dts the dts field of the decoded AVPacket

<  * @return one of the input values, may be AV_NOPTS_VALUE

<  */

< int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t pts, int64_t dts);

< /**

<  * Get a file corresponding to a preset file.

<  *

<  * If is_path is non-zero, look for the file in the path preset_name.

<  * Otherwise search for a file named arg.ffpreset in the directories

<  * $FFMPEG_DATADIR (if set), $HOME/.ffmpeg, and in the datadir defined

<  * at configuration time, in that order. If no such file is found and

<  * codec_name is defined, then search for a file named

<  * codec_name-preset_name.ffpreset in the above-mentioned directories.

<  *

<  * @param filename buffer where the name of the found filename is written

<  * @param filename_size size in bytes of the filename buffer

<  * @param preset_name name of the preset to search

<  * @param is_path tell if preset_name is a filename path

<  * @param codec_name name of the codec for which to look for the

<  * preset, may be NULL

<  */

< FILE *get_preset_file(char *filename, size_t filename_size,

<                       const char *preset_name, int is_path, const char *codec_name);

< #if CONFIG_AVFILTER

< #include "libavfilter/avfilter.h"

< typedef struct {

<     enum PixelFormat pix_fmt;

< } FFSinkContext;

< extern AVFilter ffsink;

< /**

<  * Extract a frame from sink.

<  *

<  * @return a negative error in case of failure, 1 if one frame has

<  * been extracted successfully.

<  */

< int get_filtered_video_frame(AVFilterContext *sink, AVFrame *frame,

<                              AVFilterBufferRef **picref, AVRational *pts_tb);

< #endif /* CONFIG_AVFILTER */

Binary files ffmpeg/cmdutils.o and ffmpeg-0.6.1/cmdutils.o differ

diff ffmpeg/common.mak ffmpeg-0.6.1/common.mak

29,30c29,30

<     $(eval override $(VAR) = @$$(call ECHO,$(VAR),$$(MSG)); $($(VAR))))

< $(foreach VAR,$(SILENT),$(eval override $(VAR) = @$($(VAR))))

---

>     $(eval $(VAR) = @$$(call ECHO,$(VAR),$$(MSG)); $($(VAR))))

> $(foreach VAR,$(SILENT),$(eval $(VAR) = @$($(VAR))))

34c34

< ALLFFLIBS = avcodec avcore avdevice avfilter avformat avutil postproc swscale

---

> ALLFFLIBS = avcodec avdevice avfilter avformat avutil postproc swscale

36,37c36

< IFLAGS   := -I$(BUILD_ROOT_REL) -I$(SRC_PATH)

< CPPFLAGS := $(IFLAGS) $(CPPFLAGS)

---

> CPPFLAGS := -I$(BUILD_ROOT_REL) -I$(SRC_PATH) $(CPPFLAGS)

39,41d37

< YASMFLAGS += $(IFLAGS) -Pconfig.asm

< HOSTCFLAGS += $(IFLAGS)

61,64d56

< # Dummy rule to stop make trying to rebuild removed or renamed headers

< %.h:

< @:

109a102,104

> DEPS := $(OBJS:.o=.d)

> depend dep: $(DEPS)

114c109

< -include $(wildcard $(OBJS:.o=.d))

---

> -include $(wildcard $(DEPS))

Only in ffmpeg: .config

Only in ffmpeg: config.asm

Only in ffmpeg-0.6.1: config.err

Only in ffmpeg: config.fate

diff ffmpeg/config.h ffmpeg-0.6.1/config.h

4,5c4,5

< #define FFMPEG_CONFIGURATION "--enable-shared --enable-gpl --enable-nonfree --enable-pthreads --enable-libfaac --enable-libmp3lame --enable-libtheora --enable-libxvid --enable-x11grab --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopencore-amrnb --enable-version3"

< #define FFMPEG_LICENSE "nonfree and unredistributable"

---

> #define FFMPEG_CONFIGURATION ""

> #define FFMPEG_LICENSE "LGPL version 2.1 or later"

10c10

< #define ASMALIGN(ZEROBITS) ".p2align " #ZEROBITS "/n/t"

---

> #define ASMALIGN(ZEROBITS) ".align 1 << " #ZEROBITS "/n/t"

13d12

< #define SLIBSUF ".so"

52,53c51,53

< #define HAVE_FAST_UNALIGNED 1

< #define HAVE_PTHREADS 1

---

> #define HAVE_BEOSTHREADS 0

> #define HAVE_OS2THREADS 0

> #define HAVE_PTHREADS 0

55,56c55

< #define HAVE_ALIGNED_STACK 1

< #define HAVE_ALSA_ASOUNDLIB_H 1

---

> #define HAVE_ALSA_ASOUNDLIB_H 0

81c80

< #define HAVE_FCNTL 1

---

> #define HAVE_FAST_UNALIGNED 1

88d86

< #define HAVE_GNU_AS 1

90d87

< #define HAVE_IBM_ASM 0

110d106

< #define HAVE_MAPVIEWOFFILE 0

113d108

< #define HAVE_MMAP 1

118,119c113,114

< #define HAVE_SDL 1

< #define HAVE_SDL_VIDEO_SIZE 1

---

> #define HAVE_SDL 0

> #define HAVE_SDL_VIDEO_SIZE 0

126d120

< #define HAVE_STRTOK_R 1

142c136

< #define HAVE_THREADS 1

---

> #define HAVE_THREADS 0

148,149c142

< #define HAVE_XMM_CLOBBERS 0

< #define HAVE_YASM 1

---

> #define HAVE_YASM 0

163d155

< #define CONFIG_AVCORE 1

165c157,158

< #define CONFIG_AVFILTER 1

---

> #define CONFIG_AVFILTER 0

> #define CONFIG_AVFILTER_LAVF 0

167a161

> #define CONFIG_BEOS_NETSERVER 0

170c164

< #define CONFIG_DOC 1

---

> #define CONFIG_DOC 0

175c169

< #define CONFIG_FFPLAY 1

---

> #define CONFIG_FFPLAY 0

179d172

< #define CONFIG_FREI0R 0

181c174,175

< #define CONFIG_GPL 1

---

> #define CONFIG_GPL 0

> #define CONFIG_GPROF 0

184d177

< #define CONFIG_H264PRED 1

186d178

< #define CONFIG_HUFFMAN 1

189c181,183

< #define CONFIG_LIBFAAC 1

---

> #define CONFIG_LIBFAAC 0

> #define CONFIG_LIBFAAD 0

> #define CONFIG_LIBFAADBIN 0

191c185

< #define CONFIG_LIBMP3LAME 1

---

> #define CONFIG_LIBMP3LAME 0

193,195c187,188

< #define CONFIG_LIBOPENCORE_AMRNB 1

< #define CONFIG_LIBOPENCORE_AMRWB 1

< #define CONFIG_LIBOPENCV 0

---

> #define CONFIG_LIBOPENCORE_AMRNB 0

> #define CONFIG_LIBOPENCORE_AMRWB 0

200c193

< #define CONFIG_LIBTHEORA 1

---

> #define CONFIG_LIBTHEORA 0

204,205c197

< #define CONFIG_LIBXAVS 0

< #define CONFIG_LIBXVID 1

---

> #define CONFIG_LIBXVID 0

213c205

< #define CONFIG_NONFREE 1

---

> #define CONFIG_NONFREE 0

215a208

> #define CONFIG_POWERPC_PERF 0

217d209

< #define CONFIG_RTPDEC 1

219c211

< #define CONFIG_SHARED 1

---

> #define CONFIG_SHARED 0

227,229c219,221

< #define CONFIG_VERSION3 1

< #define CONFIG_X11GRAB 1

< #define CONFIG_ZLIB 1

---

> #define CONFIG_VERSION3 0

> #define CONFIG_X11GRAB 0

> #define CONFIG_ZLIB 0

231c223

< #define CONFIG_GPLV3 1

---

> #define CONFIG_GPLV3 0

236d227

< #define CONFIG_ANSI_DECODER 1

257c248

< #define CONFIG_DXA_DECODER 1

---

> #define CONFIG_DXA_DECODER 0

269c260

< #define CONFIG_FLASHSV_DECODER 1

---

> #define CONFIG_FLASHSV_DECODER 0

319,320c310

< #define CONFIG_PICTOR_DECODER 1

< #define CONFIG_PNG_DECODER 1

---

> #define CONFIG_PNG_DECODER 0

326d315

< #define CONFIG_R10K_DECODER 1

352c341

< #define CONFIG_TSCC_DECODER 1

---

> #define CONFIG_TSCC_DECODER 0

368d356

< #define CONFIG_VP8_DECODER 1

378,379c366,367

< #define CONFIG_ZLIB_DECODER 1

< #define CONFIG_ZMBV_DECODER 1

---

> #define CONFIG_ZLIB_DECODER 0

> #define CONFIG_ZMBV_DECODER 0

381d368

< #define CONFIG_AAC_LATM_DECODER 1

386d372

< #define CONFIG_AMRWB_DECODER 1

397,398d382

< #define CONFIG_GSM_DECODER 1

< #define CONFIG_GSM_MS_DECODER 1

404d387

< #define CONFIG_MP1FLOAT_DECODER 1

406d388

< #define CONFIG_MP2FLOAT_DECODER 1

408d389

< #define CONFIG_MP3FLOAT_DECODER 1

410d390

< #define CONFIG_MP3ADUFLOAT_DECODER 1

412d391

< #define CONFIG_MP3ON4FLOAT_DECODER 1

443d421

< #define CONFIG_PCM_LXF_DECODER 1

475d452

< #define CONFIG_ADPCM_G722_DECODER 1

495d471

< #define CONFIG_ASS_DECODER 1

499d474

< #define CONFIG_SRT_DECODER 1

501a477

> #define CONFIG_LIBFAAD_DECODER 0

504,505c480,481

< #define CONFIG_LIBOPENCORE_AMRNB_DECODER 1

< #define CONFIG_LIBOPENCORE_AMRWB_DECODER 1

---

> #define CONFIG_LIBOPENCORE_AMRNB_DECODER 0

> #define CONFIG_LIBOPENCORE_AMRWB_DECODER 0

510,511d485

< #define CONFIG_A64MULTI_ENCODER 1

< #define CONFIG_A64MULTI5_ENCODER 1

519c493

< #define CONFIG_FLASHSV_ENCODER 1

---

> #define CONFIG_FLASHSV_ENCODER 0

540c514

< #define CONFIG_PNG_ENCODER 1

---

> #define CONFIG_PNG_ENCODER 0

555,556c529,530

< #define CONFIG_ZLIB_ENCODER 1

< #define CONFIG_ZMBV_ENCODER 1

---

> #define CONFIG_ZLIB_ENCODER 0

> #define CONFIG_ZMBV_ENCODER 0

559d532

< #define CONFIG_AC3_FIXED_ENCODER 1

564d536

< #define CONFIG_RA_144_ENCODER 1

567d538

< #define CONFIG_VORBIS_ENCODER 1

594d564

< #define CONFIG_ADPCM_G722_ENCODER 1

601d570

< #define CONFIG_ASS_ENCODER 1

606c575

< #define CONFIG_LIBFAAC_ENCODER 1

---

> #define CONFIG_LIBFAAC_ENCODER 0

609,610c578,579

< #define CONFIG_LIBMP3LAME_ENCODER 1

< #define CONFIG_LIBOPENCORE_AMRNB_ENCODER 1

---

> #define CONFIG_LIBMP3LAME_ENCODER 0

> #define CONFIG_LIBOPENCORE_AMRNB_ENCODER 0

612c581

< #define CONFIG_LIBTHEORA_ENCODER 1

---

> #define CONFIG_LIBTHEORA_ENCODER 0

616,617c585

< #define CONFIG_LIBXAVS_ENCODER 0

< #define CONFIG_LIBXVID_ENCODER 1

---

> #define CONFIG_LIBXVID_ENCODER 0

621d588

< #define CONFIG_MPEG2_DXVA2_HWACCEL 0

629d595

< #define CONFIG_AAC_LATM_PARSER 1

637d602

< #define CONFIG_FLAC_PARSER 1

649d613

< #define CONFIG_VP8_PARSER 1

651d614

< #define CONFIG_CHOMP_BSF 1

655d617

< #define CONFIG_MJPEG2JPEG_BSF 1

671d632

< #define CONFIG_APPLEHTTP_DEMUXER 1

696d656

< #define CONFIG_FFMETADATA_DEMUXER 1

702d661

< #define CONFIG_G722_DEMUXER 1

716d674

< #define CONFIG_IVF_DEMUXER 1

718d675

< #define CONFIG_LXF_DEMUXER 1

737d693

< #define CONFIG_MXG_DEMUXER 1

772,773d727

< #define CONFIG_RSO_DEMUXER 1

< #define CONFIG_RTP_DEMUXER 1

775d728

< #define CONFIG_SAP_DEMUXER 1

783,784d735

< #define CONFIG_SPDIF_DEMUXER 1

< #define CONFIG_SRT_DEMUXER 1

793d743

< #define CONFIG_TTY_DEMUXER 1

804d753

< #define CONFIG_WTV_DEMUXER 1

810d758

< #define CONFIG_A64_MUXER 1

821d768

< #define CONFIG_CAVSVIDEO_MUXER 1

830d776

< #define CONFIG_FFMETADATA_MUXER 1

835,836d780

< #define CONFIG_FRAMEMD5_MUXER 1

< #define CONFIG_G722_MUXER 1

846d789

< #define CONFIG_MD5_MUXER 1

894d836

< #define CONFIG_RSO_MUXER 1

897d838

< #define CONFIG_SAP_MUXER 1

900d840

< #define CONFIG_SRT_MUXER 1

911,915c851

< #define CONFIG_ANULL_FILTER 1

< #define CONFIG_ANULLSRC_FILTER 1

< #define CONFIG_ANULLSINK_FILTER 1

< #define CONFIG_BLACKFRAME_FILTER 1

< #define CONFIG_COPY_FILTER 1

---

> #define CONFIG_ASPECT_FILTER 1

917,919d852

< #define CONFIG_CROPDETECT_FILTER 1

< #define CONFIG_DRAWBOX_FILTER 1

< #define CONFIG_FIFO_FILTER 1

921,924d853

< #define CONFIG_FREI0R_FILTER 0

< #define CONFIG_GRADFUN_FILTER 1

< #define CONFIG_HFLIP_FILTER 1

< #define CONFIG_HQDN3D_FILTER 1

927,930c856

< #define CONFIG_OCV_FILTER 0

< #define CONFIG_OVERLAY_FILTER 1

< #define CONFIG_PAD_FILTER 1

< #define CONFIG_PIXDESCTEST_FILTER 1

---

> #define CONFIG_PIXELASPECT_FILTER 1

932,935d857

< #define CONFIG_SETDAR_FILTER 1

< #define CONFIG_SETPTS_FILTER 1

< #define CONFIG_SETSAR_FILTER 1

< #define CONFIG_SETTB_FILTER 1

937d858

< #define CONFIG_TRANSPOSE_FILTER 1

940,943d860

< #define CONFIG_YADIF_FILTER 1

< #define CONFIG_BUFFER_FILTER 1

< #define CONFIG_COLOR_FILTER 1

< #define CONFIG_FREI0R_SRC_FILTER 0

946d862

< #define CONFIG_CONCAT_PROTOCOL 1

950,952d865

< #define CONFIG_MMSH_PROTOCOL 1

< #define CONFIG_MMST_PROTOCOL 1

< #define CONFIG_MD5_PROTOCOL 1

962c875,877

< #define CONFIG_ALSA_INDEV 1

---

> #define CONFIG_CONCAT_PROTOCOL 1

> #define CONFIG_ALSA_INDEV 0

> #define CONFIG_AUDIO_BEOS_INDEV 0

972c887,888

< #define CONFIG_ALSA_OUTDEV 1

---

> #define CONFIG_ALSA_OUTDEV 0

> #define CONFIG_AUDIO_BEOS_OUTDEV 0

Only in ffmpeg: config.log

diff ffmpeg/config.mak ffmpeg-0.6.1/config.mak

4c4

< FFMPEG_CONFIGURATION=--enable-shared --enable-gpl --enable-nonfree --enable-pthreads --enable-libfaac --enable-libmp3lame --enable-libtheora --enable-libxvid --enable-x11grab --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopencore-amrnb --enable-version3

---

> FFMPEG_CONFIGURATION=

12,15c12,14

< SRC_PATH="/home/zhangbin/Documents/ffmpeg"

< SRC_PATH_BARE=/home/zhangbin/Documents/ffmpeg

< BUILD_ROOT="/home/zhangbin/Documents/ffmpeg"

< CC_IDENT=gcc 4.4.3 (Ubuntu 4.4.3-4ubuntu5)

---

> SRC_PATH="/home/zhangbin/Documents/ffmpeg-0.6.1"

> SRC_PATH_BARE=/home/zhangbin/Documents/ffmpeg-0.6.1

> BUILD_ROOT="/home/zhangbin/Documents/ffmpeg-0.6.1"

29c28

< CFLAGS=   -std=c99 -fomit-frame-pointer -pthread -g -Wdeclaration-after-statement -Wall -Wno-parentheses -Wno-switch -Wdisabled-optimization -Wpointer-arith -Wredundant-decls -Wno-pointer-sign -Wcast-qual -Wwrite-strings -Wtype-limits -Wundef -Wmissing-prototypes -O3 -fno-math-errno -fno-signed-zeros -fno-tree-vectorize -Werror=implicit-function-declaration -Werror=missing-prototypes

---

> CFLAGS=   -std=c99 -fomit-frame-pointer -g -Wdeclaration-after-statement -Wall -Wno-switch -Wdisabled-optimization -Wpointer-arith -Wredundant-decls -Wno-pointer-sign -Wcast-qual -Wwrite-strings -Wtype-limits -Wundef -Wmissing-prototypes -O3 -fno-math-errno -fno-signed-zeros -fno-tree-vectorize -Werror=implicit -Werror=missing-prototypes

32c31

< LDFLAGS= -Wl,--warn-common -Wl,--as-needed -Wl,-rpath-link,$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,$(BUILD_ROOT)/libswscale -Wl,-rpath-link,$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,$(BUILD_ROOT)/libavformat -Wl,-rpath-link,$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,$(BUILD_ROOT)/libavcore -Wl,-rpath-link,$(BUILD_ROOT)/libavutil -Wl,-Bsymbolic

---

> LDFLAGS=  -Wl,--warn-common -Wl,--as-needed -Wl,-rpath-link,$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,$(BUILD_ROOT)/libswscale -Wl,-rpath-link,$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,$(BUILD_ROOT)/libavformat -Wl,-rpath-link,$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,$(BUILD_ROOT)/libavutil -Wl,-Bsymbolic

35c34

< YASMFLAGS=-f elf  -g dwarf2

---

> YASMFLAGS=-f elf -DARCH_X86_32 -g dwarf2

57,58c56,57

< SDL_LIBS=-L/usr/lib -lSDL

< SDL_CFLAGS=-I/usr/include/SDL -D_GNU_SOURCE=1 -D_REENTRANT

---

> SDL_LIBS=

> SDL_CFLAGS=

60c59

< EXTRALIBS=-ldl -lasound -lxvidcore -ltheoraenc -ltheoradec -logg -lopencore-amrwb -lopencore-amrnb -lmp3lame -lfaac -lm -pthread -lz 

---

> EXTRALIBS=  -lm -ldl

71c70

< libswscale_VERSION=0.12.0

---

> libswscale_VERSION=0.11.0

75c74

< libavcodec_VERSION=52.107.0

---

> libavcodec_VERSION=52.72.2

77,79c76

< libavcore_VERSION=0.16.0

< libavcore_VERSION_MAJOR=0

< libavdevice_VERSION=52.2.3

---

> libavdevice_VERSION=52.2.0

81c78

< libavformat_VERSION=52.92.0

---

> libavformat_VERSION=52.64.2

83c80

< libavutil_VERSION=50.36.0

---

> libavutil_VERSION=50.15.1

85c82

< libavfilter_VERSION=1.72.0

---

> libavfilter_VERSION=1.19.0

125,126c122,124

< HAVE_FAST_UNALIGNED=yes

< HAVE_PTHREADS=yes

---

> !HAVE_BEOSTHREADS=yes

> !HAVE_OS2THREADS=yes

> !HAVE_PTHREADS=yes

128,129c126

< HAVE_ALIGNED_STACK=yes

< HAVE_ALSA_ASOUNDLIB_H=yes

---

> !HAVE_ALSA_ASOUNDLIB_H=yes

154c151

< HAVE_FCNTL=yes

---

> HAVE_FAST_UNALIGNED=yes

161d157

< HAVE_GNU_AS=yes

163d158

< !HAVE_IBM_ASM=yes

183d177

< !HAVE_MAPVIEWOFFILE=yes

186d179

< HAVE_MMAP=yes

191,192c184,185

< HAVE_SDL=yes

< HAVE_SDL_VIDEO_SIZE=yes

---

> !HAVE_SDL=yes

> !HAVE_SDL_VIDEO_SIZE=yes

199d191

< HAVE_STRTOK_R=yes

215c207

< HAVE_THREADS=yes

---

> !HAVE_THREADS=yes

221,222c213

< !HAVE_XMM_CLOBBERS=yes

< HAVE_YASM=yes

---

> !HAVE_YASM=yes

236d226

< CONFIG_AVCORE=yes

238c228,229

< CONFIG_AVFILTER=yes

---

> !CONFIG_AVFILTER=yes

> !CONFIG_AVFILTER_LAVF=yes

240a232

> !CONFIG_BEOS_NETSERVER=yes

243c235

< CONFIG_DOC=yes

---

> !CONFIG_DOC=yes

248c240

< CONFIG_FFPLAY=yes

---

> !CONFIG_FFPLAY=yes

252d243

< !CONFIG_FREI0R=yes

254c245,246

< CONFIG_GPL=yes

---

> !CONFIG_GPL=yes

> !CONFIG_GPROF=yes

257d248

< CONFIG_H264PRED=yes

259d249

< CONFIG_HUFFMAN=yes

262c252,254

< CONFIG_LIBFAAC=yes

---

> !CONFIG_LIBFAAC=yes

> !CONFIG_LIBFAAD=yes

> !CONFIG_LIBFAADBIN=yes

264c256

< CONFIG_LIBMP3LAME=yes

---

> !CONFIG_LIBMP3LAME=yes

266,268c258,259

< CONFIG_LIBOPENCORE_AMRNB=yes

< CONFIG_LIBOPENCORE_AMRWB=yes

< !CONFIG_LIBOPENCV=yes

---

> !CONFIG_LIBOPENCORE_AMRNB=yes

> !CONFIG_LIBOPENCORE_AMRWB=yes

273c264

< CONFIG_LIBTHEORA=yes

---

> !CONFIG_LIBTHEORA=yes

277,278c268

< !CONFIG_LIBXAVS=yes

< CONFIG_LIBXVID=yes

---

> !CONFIG_LIBXVID=yes

286c276

< CONFIG_NONFREE=yes

---

> !CONFIG_NONFREE=yes

288a279

> !CONFIG_POWERPC_PERF=yes

290d280

< CONFIG_RTPDEC=yes

292c282

< CONFIG_SHARED=yes

---

> !CONFIG_SHARED=yes

300,302c290,292

< CONFIG_VERSION3=yes

< CONFIG_X11GRAB=yes

< CONFIG_ZLIB=yes

---

> !CONFIG_VERSION3=yes

> !CONFIG_X11GRAB=yes

> !CONFIG_ZLIB=yes

304c294

< CONFIG_GPLV3=yes

---

> !CONFIG_GPLV3=yes

309d298

< CONFIG_ANSI_DECODER=yes

330c319

< CONFIG_DXA_DECODER=yes

---

> !CONFIG_DXA_DECODER=yes

342c331

< CONFIG_FLASHSV_DECODER=yes

---

> !CONFIG_FLASHSV_DECODER=yes

392,393c381

< CONFIG_PICTOR_DECODER=yes

< CONFIG_PNG_DECODER=yes

---

> !CONFIG_PNG_DECODER=yes

399d386

< CONFIG_R10K_DECODER=yes

425c412

< CONFIG_TSCC_DECODER=yes

---

> !CONFIG_TSCC_DECODER=yes

441d427

< CONFIG_VP8_DECODER=yes

451,452c437,438

< CONFIG_ZLIB_DECODER=yes

< CONFIG_ZMBV_DECODER=yes

---

> !CONFIG_ZLIB_DECODER=yes

> !CONFIG_ZMBV_DECODER=yes

454d439

< CONFIG_AAC_LATM_DECODER=yes

459d443

< CONFIG_AMRWB_DECODER=yes

470,471d453

< CONFIG_GSM_DECODER=yes

< CONFIG_GSM_MS_DECODER=yes

477d458

< CONFIG_MP1FLOAT_DECODER=yes

479d459

< CONFIG_MP2FLOAT_DECODER=yes

481d460

< CONFIG_MP3FLOAT_DECODER=yes

483d461

< CONFIG_MP3ADUFLOAT_DECODER=yes

485d462

< CONFIG_MP3ON4FLOAT_DECODER=yes

516d492

< CONFIG_PCM_LXF_DECODER=yes

548d523

< CONFIG_ADPCM_G722_DECODER=yes

568d542

< CONFIG_ASS_DECODER=yes

572d545

< CONFIG_SRT_DECODER=yes

574a548

> !CONFIG_LIBFAAD_DECODER=yes

577,578c551,552

< CONFIG_LIBOPENCORE_AMRNB_DECODER=yes

< CONFIG_LIBOPENCORE_AMRWB_DECODER=yes

---

> !CONFIG_LIBOPENCORE_AMRNB_DECODER=yes

> !CONFIG_LIBOPENCORE_AMRWB_DECODER=yes

583,584d556

< CONFIG_A64MULTI_ENCODER=yes

< CONFIG_A64MULTI5_ENCODER=yes

592c564

< CONFIG_FLASHSV_ENCODER=yes

---

> !CONFIG_FLASHSV_ENCODER=yes

613c585

< CONFIG_PNG_ENCODER=yes

---

> !CONFIG_PNG_ENCODER=yes

628,629c600,601

< CONFIG_ZLIB_ENCODER=yes

< CONFIG_ZMBV_ENCODER=yes

---

> !CONFIG_ZLIB_ENCODER=yes

> !CONFIG_ZMBV_ENCODER=yes

632d603

< CONFIG_AC3_FIXED_ENCODER=yes

637d607

< CONFIG_RA_144_ENCODER=yes

640d609

< CONFIG_VORBIS_ENCODER=yes

667d635

< CONFIG_ADPCM_G722_ENCODER=yes

674d641

< CONFIG_ASS_ENCODER=yes

679c646

< CONFIG_LIBFAAC_ENCODER=yes

---

> !CONFIG_LIBFAAC_ENCODER=yes

682,683c649,650

< CONFIG_LIBMP3LAME_ENCODER=yes

< CONFIG_LIBOPENCORE_AMRNB_ENCODER=yes

---

> !CONFIG_LIBMP3LAME_ENCODER=yes

> !CONFIG_LIBOPENCORE_AMRNB_ENCODER=yes

685c652

< CONFIG_LIBTHEORA_ENCODER=yes

---

> !CONFIG_LIBTHEORA_ENCODER=yes

689,690c656

< !CONFIG_LIBXAVS_ENCODER=yes

< CONFIG_LIBXVID_ENCODER=yes

---

> !CONFIG_LIBXVID_ENCODER=yes

694d659

< !CONFIG_MPEG2_DXVA2_HWACCEL=yes

702d666

< CONFIG_AAC_LATM_PARSER=yes

710d673

< CONFIG_FLAC_PARSER=yes

722d684

< CONFIG_VP8_PARSER=yes

724d685

< CONFIG_CHOMP_BSF=yes

728d688

< CONFIG_MJPEG2JPEG_BSF=yes

744d703

< CONFIG_APPLEHTTP_DEMUXER=yes

769d727

< CONFIG_FFMETADATA_DEMUXER=yes

775d732

< CONFIG_G722_DEMUXER=yes

789d745

< CONFIG_IVF_DEMUXER=yes

791d746

< CONFIG_LXF_DEMUXER=yes

810d764

< CONFIG_MXG_DEMUXER=yes

845,846d798

< CONFIG_RSO_DEMUXER=yes

< CONFIG_RTP_DEMUXER=yes

848d799

< CONFIG_SAP_DEMUXER=yes

856,857d806

< CONFIG_SPDIF_DEMUXER=yes

< CONFIG_SRT_DEMUXER=yes

866d814

< CONFIG_TTY_DEMUXER=yes

877d824

< CONFIG_WTV_DEMUXER=yes

883d829

< CONFIG_A64_MUXER=yes

894d839

< CONFIG_CAVSVIDEO_MUXER=yes

903d847

< CONFIG_FFMETADATA_MUXER=yes

908,909d851

< CONFIG_FRAMEMD5_MUXER=yes

< CONFIG_G722_MUXER=yes

919d860

< CONFIG_MD5_MUXER=yes

967d907

< CONFIG_RSO_MUXER=yes

970d909

< CONFIG_SAP_MUXER=yes

973d911

< CONFIG_SRT_MUXER=yes

984,988c922

< CONFIG_ANULL_FILTER=yes

< CONFIG_ANULLSRC_FILTER=yes

< CONFIG_ANULLSINK_FILTER=yes

< CONFIG_BLACKFRAME_FILTER=yes

< CONFIG_COPY_FILTER=yes

---

> CONFIG_ASPECT_FILTER=yes

990,992d923

< CONFIG_CROPDETECT_FILTER=yes

< CONFIG_DRAWBOX_FILTER=yes

< CONFIG_FIFO_FILTER=yes

994,997d924

< !CONFIG_FREI0R_FILTER=yes

< CONFIG_GRADFUN_FILTER=yes

< CONFIG_HFLIP_FILTER=yes

< CONFIG_HQDN3D_FILTER=yes

1000,1003c927

< !CONFIG_OCV_FILTER=yes

< CONFIG_OVERLAY_FILTER=yes

< CONFIG_PAD_FILTER=yes

< CONFIG_PIXDESCTEST_FILTER=yes

---

> CONFIG_PIXELASPECT_FILTER=yes

1005,1008d928

< CONFIG_SETDAR_FILTER=yes

< CONFIG_SETPTS_FILTER=yes

< CONFIG_SETSAR_FILTER=yes

< CONFIG_SETTB_FILTER=yes

1010d929

< CONFIG_TRANSPOSE_FILTER=yes

1013,1016d931

< CONFIG_YADIF_FILTER=yes

< CONFIG_BUFFER_FILTER=yes

< CONFIG_COLOR_FILTER=yes

< !CONFIG_FREI0R_SRC_FILTER=yes

1019d933

< CONFIG_CONCAT_PROTOCOL=yes

1023,1025d936

< CONFIG_MMSH_PROTOCOL=yes

< CONFIG_MMST_PROTOCOL=yes

< CONFIG_MD5_PROTOCOL=yes

1035c946,948

< CONFIG_ALSA_INDEV=yes

---

> CONFIG_CONCAT_PROTOCOL=yes

> !CONFIG_ALSA_INDEV=yes

> !CONFIG_AUDIO_BEOS_INDEV=yes

1045c958,959

< CONFIG_ALSA_OUTDEV=yes

---

> !CONFIG_ALSA_OUTDEV=yes

> !CONFIG_AUDIO_BEOS_OUTDEV=yes

1047,1051d960

< ACODEC_TESTS=ac3_fixed adpcm_ima_qt adpcm_ima_wav adpcm_ms adpcm_swf adpcm_yam alac flac g726 mp2 pcm wmav1 wmav2 

< VCODEC_TESTS=asv1 asv2 dnxhd_1080i dnxhd_720p dnxhd_720p_rd dv dv50 error ffv1 flashsv flv h261 h263 h263p huffyuv jpegls ljpeg mjpeg mpeg mpeg1b mpeg2 mpeg2thread mpeg4 mpeg4adv mpeg4nr mpeg4thread msmpeg4 msmpeg4v2 qtrle rc rgb roq rv10 rv20 snow snowll svq1 wmv1 wmv2 yuv 

< LAVF_TESTS=aiff alaw asf au avi bmp dv_fmt ffm flv_fmt gif gxf jpg mkv mmf mov mpg mulaw mxf nut ogg pbmpipe pcx pgm pgmpipe pixfmt png ppm ppmpipe rm sgi swf tga tiff ts voc wav yuv4mpeg 

< LAVFI_TESTS=crop crop_scale crop_scale_vflip crop_vflip null pixdesc_le pixfmts_copy_le pixfmts_crop_le pixfmts_hflip_le pixfmts_null_le pixfmts_pad_le pixfmts_scale_le pixfmts_vflip_le scale200 scale500 vflip vflip_crop vflip_vflip 

< SEEK_TESTS=seek_ac3_rm seek_adpcm_ima_wav seek_adpcm_ms_wav seek_adpcm_qt_aiff seek_adpcm_swf_flv seek_adpcm_yam_wav seek_alac_m4a seek_asv1_avi seek_asv2_avi seek_dnxhd_1080i_mov seek_dnxhd_720p_dnxhd seek_dnxhd_720p_rd_dnxhd seek_dv411_dv seek_dv50_dv seek_dv_dv seek_error_mpeg4_adv_avi seek_ffv1_avi seek_flac_flac seek_flashsv_flv seek_flv_flv seek_g726_wav seek_h261_avi seek_h263_avi seek_h263p_avi seek_huffyuv_avi seek_image_bmp seek_image_jpg seek_image_pcx seek_image_pgm seek_image_ppm seek_image_sgi seek_image_tga seek_image_tiff seek_jpegls_avi seek_lavf_aif seek_lavf_al seek_lavf_asf seek_lavf_au seek_lavf_avi seek_lavf_dv seek_lavf_ffm seek_lavf_flv seek_lavf_gif seek_lavf_gxf seek_lavf_mkv seek_lavf_mmf seek_lavf_mov seek_lavf_mpg seek_lavf_mxf seek_lavf_mxf_d10 seek_lavf_nut seek_lavf_ogg seek_lavf_rm seek_lavf_swf seek_lavf_ts seek_lavf_ul seek_lavf_voc seek_lavf_wav seek_lavf_y4m seek_ljpeg_avi seek_mjpeg_avi seek_mp2_mp2 seek_mpeg1_mpg seek_mpeg1b_mpg seek_mpeg2_422_mpg seek_mpeg2_mpg seek_mpeg2i_mpg seek_mpeg2ivlc_qprd_mpg seek_mpeg2reuse_mpg seek_mpeg2thread_mpg seek_mpeg2threadivlc_mpg seek_mpeg4_adap_avi seek_mpeg4_adv_avi seek_mpeg4_nr_avi seek_mpeg4_qprd_avi seek_mpeg4_rc_avi seek_mpeg4_thread_avi seek_msmpeg4_avi seek_msmpeg4v2_avi seek_odivx_mp4 seek_pbmpipe_pbm seek_pcm_alaw_wav seek_pcm_f32be_au seek_pcm_f32le_wav seek_pcm_f64be_au seek_pcm_f64le_wav seek_pcm_mulaw_wav seek_pcm_s16be_mkv seek_pcm_s16be_mov seek_pcm_s16le_mkv seek_pcm_s16le_wav seek_pcm_s24be_mov seek_pcm_s24daud_302 seek_pcm_s24le_wav seek_pcm_s32be_mov seek_pcm_s32le_wav seek_pcm_s8_mov seek_pcm_u8_wav seek_pcm_zork_wav seek_pgmpipe_pgm seek_ppmpipe_ppm seek_rgb_avi seek_roqav_roq seek_rv10_rm seek_rv20_rm seek_snow53_avi seek_snow_avi seek_svq1_mov seek_wmav1_asf seek_wmav2_asf seek_wmv1_avi seek_wmv2_avi seek_yuv_avi 

diff ffmpeg/configure ffmpeg-0.6.1/configure

64c64

<   --logfile=FILE           log tests and output to FILE [config.log]

---

>   --logfile=FILE           log tests and output to FILE [config.err]

89d88

<   --disable-avcore         disable libavcore build

93,94c92,96

<   --disable-avfilter       disable video filter support [no]

<   --disable-pthreads       disable pthreads [auto]

---

>   --enable-avfilter        video filter support [no]

>   --enable-avfilter-lavf   video filters dependent on avformat [no]

>   --enable-beosthreads     use BeOS threads [no]

>   --enable-os2threads      use OS/2 threads [no]

>   --enable-pthreads        use pthreads [no]

107d108

<   --disable-huffman        disable Huffman code

116a118

>   --enable-beos-netserver  enable BeOS netserver

165d166

<   --enable-frei0r          enable frei0r video filtering

168d168

<   --enable-libopencv       enable video filtering via libopencv [no]

172a173,174

>   --enable-libfaad         enable FAAD support via libfaad [no]

>   --enable-libfaadbin      open libfaad.so.0 at runtime [no]

186d187

<   --enable-libxavs         enable AVS encoding via xavs [no]

217a219,220

>   --enable-powerpc-perf    enable performance report on PPC

>                            (requires enabling PMC)

238d240

<   --disable-symver         disable symbol versioning

242a245

>   --enable-gprof           enable profiling with gprof [$gprof]

270,274d272

< warn(){

<     log "WARNING: $*"

<     WARNINGS="${WARNINGS}WARNING: $*/n"

< }

312c310

<     test "x$v" = "x${v#*[!A-Za-z0-9_/.+-]}" || v="'$v'"

---

>     test "$v" = "${v#*[ |&;<>()$/`///"/'*?/[/]#~=%]}" || v="'$v'"

501,503c499,513

< print_config_h(){

<     enabled $1 && v=1 || v=0

<     echo "#define $2 $v"

---

> print_config(){

>     pfx=$1

>     header=$2

>     makefile=$3

>     shift 3

>     for cfg; do

>         ucname="$(toupper $cfg)"

>         if enabled $cfg; then

>             echo "#define ${pfx}${ucname} 1" >> $header

>             echo "${pfx}${ucname}=yes" >> $makefile

>         else

>             echo "#define ${pfx}${ucname} 0" >> $header

>             echo "!${pfx}${ucname}=yes" >> $makefile

>         fi

>     done

506,508c516,517

< print_config_mak(){

<     enabled $1 && v= || v=!

<     echo "$v$2=yes"

---

> flags_saved(){

>     (: ${SAVE_CFLAGS?}) 2> /dev/null

511,512c520,524

< print_config_asm(){

<     enabled $1 && echo "%define $2"

---

> save_flags(){

>     flags_saved && return

>     SAVE_CFLAGS="$CFLAGS"

>     SAVE_LDFLAGS="$LDFLAGS"

>     SAVE_extralibs="$extralibs"

515,524c527,534

< print_config(){

<     pfx=$1

<     files=$2

<     shift 2

<     for cfg; do

<         ucname="$(toupper $cfg)"

<         for f in $files; do

<             "print_config_${f##*.}" $cfg ${pfx}${ucname} >>$f

<         done

<     done

---

> restore_flags(){

>     flags_saved || return

>     CFLAGS="$SAVE_CFLAGS"

>     LDFLAGS="$SAVE_LDFLAGS"

>     extralibs="$SAVE_extralibs"

>     unset SAVE_CFLAGS

>     unset SAVE_LDFLAGS

>     unset SAVE_extralibs

527,533c537,539

< print_enabled(){

<     test "$1" = -n && end=" " && shift || end="/n"

<     suf=$1

<     shift

<     for v; do

<         enabled $v && printf "%s$end" ${v%$suf};

<     done

---

> temp_cflags(){

>     save_flags

>     CFLAGS="$CFLAGS $*"

536,539c542,549

< append(){

<     var=$1

<     shift

<     eval "$var=/"/$$var $*/""

---

> temp_ldflags(){

>     save_flags

>     LDFLAGS="$LDFLAGS $*"

> }

> temp_extralibs(){

>     save_flags

>     extralibs="$extralibs $*"

542c552

< prepend(){

---

> append(){

545c555,556

<     eval "$var=/"$* /$$var/""

---

>     flags_saved && eval "SAVE_$var=/"/$SAVE_$var $*/""

>     eval "$var=/"/$$var $*/""

565c576

<     prepend extralibs "$@"

---

>     append extralibs "$@"

723c734,738

<     check_header $header && check_func $func "$@" && add_extralibs "$@"

---

>     temp_extralibs "$@"

>     check_header $header && check_func $func && add_extralibs "$@"

>     err=$?

>     restore_flags

>     return $err

814a830,846

> check_foo_config(){

>     cfg=$1

>     pkg=$2

>     header=$3

>     func=$4

>     shift 4

>     disable $cfg

>     check_cmd ${pkg}-config --version

>     err=$?

>     if test "$err" = 0; then

>         temp_cflags $(${pkg}-config --cflags)

>         temp_extralibs $(${pkg}-config --libs)

>         check_lib "$@" $header $func && enable $cfg

>     fi

>     return $err

> }

862d893

<     avcore

864a896

>     avfilter_lavf

866a899

>     beos_netserver

878d910

<     frei0r

880a913

>     gprof

883d915

<     h264pred

885d916

<     huffman

888a920,921

>     libfaad

>     libfaadbin

894d926

<     libopencv

903d934

<     libxavs

914a946

>     powerpc_perf

916d947

<     rtpdec

931a963,964

>     beosthreads

>     os2threads

981d1013

<     fast_unaligned

988d1019

<     aligned_stack

1014c1045

<     fcntl

---

>     fast_unaligned

1021d1051

<     gnu_as

1023d1052

<     ibm_asm

1043d1071

<     MapViewOfFile

1046d1073

<     mmap

1059d1085

<     strtok_r

1081d1106

<     xmm_clobbers

1103d1127

<     symver

1177d1200

< aligned_stack_if_any="ppc x86"

1188d1210

< dct_select="rdft"

1193c1215

< aac_decoder_select="mdct rdft"

---

> aac_decoder_select="mdct rdft aac_parser"

1195d1216

< aac_latm_decoder_select="aac_decoder aac_latm_parser"

1197d1217

< ac3_encoder_select="mdct"

1200d1219

< amrwb_decoder_select="lsp"

1222d1240

< fraps_decoder_select="huffman"

1229c1247

< h264_decoder_select="golomb h264dsp h264pred"

---

> h264_decoder_select="golomb h264dsp"

1241,1245d1258

< mp1float_decoder_select="dct"

< mp2float_decoder_select="dct"

< mp3adufloat_decoder_select="dct"

< mp3float_decoder_select="dct"

< mp3on4float_decoder_select="dct"

1252,1253d1264

< mpeg2_dxva2_hwaccel_deps="dxva2api_h"

< mpeg2_dxva2_hwaccel_select="dxva2 mpeg2video_decoder"

1271d1281

< ra_144_encoder_select="lpc"

1276,1277c1286,1287

< rv30_decoder_select="golomb h264pred"

< rv40_decoder_select="golomb h264pred"

---

> rv30_decoder_select="golomb h264dsp"

> rv40_decoder_select="golomb h264dsp"

1286c1296

< svq3_decoder_select="golomb h264dsp h264pred"

---

> svq3_decoder_select="golomb h264dsp"

1301d1310

< vp6_decoder_select="huffman"

1304d1312

< vp8_decoder_select="h264pred"

1310c1318

< wmavoice_decoder_select="lsp rdft dct mdct"

---

> wmavoice_decoder_select="lsp rdft dct"

1328c1336,1339

< h264_parser_select="golomb h264dsp h264pred"

---

> h264_parser_select="golomb h264dsp"

> # bitstream_filters

> aac_adtstoasc_bsf_select="aac_parser"

1333a1345,1346

> libfaad_decoder_deps="libfaad"

> libfaadbin_extralibs='$ldl'

1351d1363

< libxavs_encoder_deps="libxavs"

1360d1371

< flac_demuxer_deps="flac_parser"

1373,1379c1384,1388

< rtp_demuxer_select="sdp_demuxer"

< rtpdec_select="asf_demuxer rm_demuxer rtp_protocol mpegts_demuxer mov_demuxer"

< rtsp_demuxer_select="http_protocol rtpdec"

< rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol"

< sap_demuxer_select="sdp_demuxer"

< sap_muxer_select="rtp_muxer rtp_protocol"

< sdp_demuxer_select="rtpdec"

---

> rtsp_demuxer_deps="sdp_demuxer"

> rtsp_muxer_deps="sdp_demuxer"

> rtsp_muxer_select="rtp_muxer"

> sdp_demuxer_deps="rtp_protocol mpegts_demuxer"

> sdp_demuxer_select="asf_demuxer rm_demuxer"

1386a1396

> alsa_indev_extralibs="-lasound"

1387a1398,1402

> alsa_outdev_extralibs="-lasound"

> audio_beos_indev_deps="audio_beos"

> audio_beos_indev_extralibs="-lmedia -lbe"

> audio_beos_outdev_deps="audio_beos"

> audio_beos_outdev_extralibs="-lmedia -lbe"

1390a1406

> jack_indev_extralibs="-ljack"

1396c1412

< vfwcap_indev_deps="capCreateCaptureWindow vfwcap_defines"

---

> vfwcap_indev_deps="capCreateCaptureWindow"

1405,1408c1421,1422

< mmsh_protocol_select="http_protocol"

< mmst_protocol_deps="network"

< rtmp_protocol_select="tcp_protocol"

< rtp_protocol_select="udp_protocol"

---

> rtmp_protocol_deps="tcp_protocol"

> rtp_protocol_deps="udp_protocol"

1413,1420c1427,1428

< blackframe_filter_deps="gpl"

< cropdetect_filter_deps="gpl"

< frei0r_filter_deps="frei0r dlopen strtok_r"

< frei0r_src_filter_deps="frei0r dlopen strtok_r"

< hqdn3d_filter_deps="gpl"

< scale_filter_deps="swscale"

< ocv_filter_deps="libopencv"

< yadif_filter_deps="gpl"

---

> movie_filter_deps="avfilter_lavf"

> avfilter_lavf_deps="avformat"

1428d1435

< ffmpeg_select="buffer_filter"

1437,1540d1443

< # tests

< test_deps(){

<     suf1=$1

<     suf2=$2

<     shift 2

<     for v; do

<         dep=${v%=*}

<         tests=${v#*=}

<         for name in ${tests}; do

<             eval ${name}_test_deps="'${dep}$suf1 ${dep}$suf2'"

<         done

<     done

< }

< set_ne_test_deps(){

<     eval ${1}_be_test_deps="bigendian"

<     eval ${1}_le_test_deps="!bigendian"

< }

< test_deps _encoder _decoder                                             /

<     adpcm_g726=g726                                                     /

<     adpcm_ima_qt                                                        /

<     adpcm_ima_wav                                                       /

<     adpcm_ms                                                            /

<     adpcm_swf                                                           /

<     adpcm_yamaha=adpcm_yam                                              /

<     alac                                                                /

<     asv1                                                                /

<     asv2                                                                /

<     bmp                                                                 /

<     dnxhd="dnxhd_1080i dnxhd_720p dnxhd_720p_rd"                        /

<     dvvideo="dv dv50"                                                   /

<     ffv1                                                                /

<     flac                                                                /

<     flashsv                                                             /

<     flv                                                                 /

<     gif                                                                 /

<     h261                                                                /

<     h263="h263 h263p"                                                   /

<     huffyuv                                                             /

<     jpegls                                                              /

<     mjpeg="jpg mjpeg ljpeg"                                             /

<     mp2                                                                 /

<     mpeg1video="mpeg mpeg1b"                                            /

<     mpeg2video="mpeg2 mpeg2thread"                                      /

<     mpeg4="mpeg4 mpeg4adv mpeg4nr mpeg4thread error rc"                 /

<     msmpeg4v3=msmpeg4                                                   /

<     msmpeg4v2                                                           /

<     pbm=pbmpipe                                                         /

<     pcx                                                                 /

<     pgm="pgm pgmpipe"                                                   /

<     ppm="ppm ppmpipe"                                                   /

<     rawvideo="rgb yuv"                                                  /

<     roq                                                                 /

<     rv10                                                                /

<     rv20                                                                /

<     sgi                                                                 /

<     snow="snow snowll"                                                  /

<     svq1                                                                /

<     targa=tga                                                           /

<     tiff                                                                /

<     wmav1                                                               /

<     wmav2                                                               /

<     wmv1                                                                /

<     wmv2                                                                /

< test_deps _muxer _demuxer                                               /

<     aiff                                                                /

<     pcm_alaw=alaw                                                       /

<     asf                                                                 /

<     au                                                                  /

<     avi                                                                 /

<     dv=dv_fmt                                                           /

<     ffm                                                                 /

<     flv=flv_fmt                                                         /

<     gxf                                                                 /

<     matroska=mkv                                                        /

<     mmf                                                                 /

<     mov                                                                 /

<     pcm_mulaw=mulaw                                                     /

<     mxf                                                                 /

<     nut                                                                 /

<     ogg                                                                 /

<     rawvideo=pixfmt                                                     /

<     rm                                                                  /

<     swf                                                                 /

<     mpegts=ts                                                           /

<     voc                                                                 /

<     wav                                                                 /

<     yuv4mpegpipe=yuv4mpeg                                               /

< ac3_fixed_test_deps="ac3_fixed_encoder ac3_decoder rm_muxer rm_demuxer"

< mpg_test_deps="mpeg1system_muxer mpegps_demuxer"

< set_ne_test_deps pixdesc

< set_ne_test_deps pixfmts_copy

< set_ne_test_deps pixfmts_crop

< set_ne_test_deps pixfmts_hflip

< set_ne_test_deps pixfmts_null

< set_ne_test_deps pixfmts_pad

< set_ne_test_deps pixfmts_scale

< set_ne_test_deps pixfmts_vflip

1543c1446

< logfile="config.log"

---

> logfile="config.err"

1565d1467

< nogas=":"

1579d1480

< enable avcore

1581d1481

< enable avfilter

1622,1623c1522,1523

< # since the object filename is not given with the -MM flag, the compiler

< # is only able to print the basename, and we must add the path ourselves

---

> # gcc stupidly only outputs the basename of targets with -MM, but we need the

> # full relative path for objects in subdirectories for non-recursive Make.

1667,1678d1566

< find_tests(){

<     map "echo ${2}/${v}_test" $(ls "$source_path"/tests/ref/$1 | grep -v '[^-a-z0-9_]')

< }

< ACODEC_TESTS=$(find_tests acodec)

< VCODEC_TESTS=$(find_tests vsynth1)

< LAVF_TESTS=$(find_tests lavf)

< LAVFI_TESTS=$(find_tests lavfi)

< SEEK_TESTS=$(find_tests seek seek_)

< pcm_test_deps=$(map 'echo ${v%_*}_decoder $v' $(filter pcm_* $ENCODER_LIST))

1685c1573

< enable $ARCH_EXT_LIST $ACODEC_TESTS $VCODEC_TESTS $LAVF_TESTS $LAVFI_TESTS $SEEK_TESTS

---

> enable $ARCH_EXT_LIST

1712c1600

<     map 'eval unset /${$(toupper ${v%s})_LIST}' $COMPONENT_LIST

---

>     map 'eval disable /${$(toupper ${v%s})_LIST}' $COMPONENT_LIST

1821d1708

< tmpfile TMPASM .asm

1842,1851c1729

< if   $cc -v 2>&1 | grep -q '^gcc.*LLVM'; then

<     cc_type=llvm_gcc

<     cc_version=__VERSION__

<     gcc_extra_ver=$(expr "$($cc --version | head -n1)" : '.*/((.*)/)')

<     cc_ident="llvm-gcc $($cc -dumpversion) $gcc_extra_ver"

<     CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

<     AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

<     speed_cflags='-O3'

<     size_cflags='-Os'

< elif $cc -v 2>&1 | grep -qi ^gcc; then

---

> if   $cc -v 2>&1 | grep -qi ^gcc; then

1854,1855d1731

<     gcc_extra_ver=$(expr "$($cc --version | head -n1)" : '.*/((.*)/)')

<     cc_ident="gcc $($cc -dumpversion) $gcc_extra_ver"

1865,1866d1740

<     cc_ident=$($cc --version | head -n1)

<     icc_version=$($cc -dumpversion)

1875d1748

<     cc_ident=$($cc -qversion 2>/dev/null | head -n1)

1881d1753

<     cc_ident=$($cc -V | head -n1 | cut -d' ' -f1-3)

1891d1762

<     cc_ident=$($cc --vsn | head -n1)

1898d1768

<     $cc --vsn | grep -q RVCT && armcc_opt=rvct || armcc_opt=armcc

1908d1777

<     cc_ident=$($cc -version | head -n1 | tr -s ' ')

1947,1949c1816

<     $cc -dM -E $TMPC | grep -q __clang_version__ &&

<         cc_version=__clang_version__ || cc_version=__VERSION__

<     cc_ident=$($cc --version | head -n1)

---

>     cc_version=__VERSION__

1957d1823

<     cc_ident=$($cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)

1969c1835

<                         v9|niagara)               echo -xarch=sparc          ;;

---

>                         v9)                       echo -xarch=sparc          ;;

1971c1837

<                         ultrasparc3|niagara2)     echo -xarch=sparcvis2      ;;

---

>                         ultrasparc3|niagara*)     echo -xarch=sparcvis2      ;;

1996,2011d1861

< elif $cc -v 2>&1 | grep -q 'PathScale/|Path64'; then

<     cc_type=pathscale

<     cc_version=__PATHSCALE__

<     cc_ident=$($cc -v 2>&1 | head -n1 | tr -d :)

<     CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

<     AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

<     speed_cflags='-O2'

<     size_cflags='-Os'

< elif $cc -v 2>&1 | grep -q Open64; then

<     cc_type=open64

<     cc_version=__OPEN64__

<     cc_ident=$($cc -v 2>&1 | head -n1 | tr -d :)

<     CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

<     AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

<     speed_cflags='-O2'

<     size_cflags='-Os'

2014,2015c1864

< test -n "$cc_type" && enable $cc_type ||

<     warn "Unknown C compiler $cc, unable to select optimal CFLAGS"

---

> test -n "$cc_type" && enable $cc_type || echolog "Unknown C compiler $cc"

2030c1879

<         gcc|llvm_gcc)

---

>         gcc)

2049c1898

<         gcc|llvm_gcc)

---

>         gcc)

2106c1955

< is_in $arch $ARCH_LIST || warn "unknown architecture $arch"

---

> is_in $arch $ARCH_LIST || echo "WARNING: unknown arch $arch"

2167c2016

<         i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64|k8|opteron|athlon-fx|core2|amdfam10|barcelona|atom)

---

>         i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64|k8|opteron|athlon-fx|core2|amdfam10)

2183,2186d2031

<         niagara)

<             cpuflags="-mcpu=$cpu"

<             disable vis

<         ;;

2197d2041

<             subarch=$(echo $cpu | sed 's/[^a-z0-9]//g')

2201,2208d2044

<             case $cpu in

<                 cortex-a*)                               subarch=armv7a  ;;

<                 cortex-r*)                               subarch=armv7r  ;;

<                 cortex-m*)                               subarch=armv7m  ;;

<                 arm11*)                                  subarch=armv6   ;;

<                 arm[79]*e*|arm9[24]6*|arm96*|arm102[26]) subarch=armv5te ;;

<                 armv4*|arm7*|arm9[24]*)                  subarch=armv4   ;;

<             esac

2294,2297c2130,2153

<     haiku)

<         prefix_default="/boot/common"

<         network_extralibs="-lnetwork"

<         ;;

---

>     beos|haiku|zeta)

>         prefix_default="$HOME/config"

>         # 3 gcc releases known for BeOS, each with ugly bugs

>         gcc_version="$($cc -v 2>&1 | grep version | cut -d ' ' -f3-)"

>         case "$gcc_version" in

>           2.9-beos-991026*|2.9-beos-000224*) echo "R5/GG gcc"

>             disable mmx

>             ;;

>           *20010315*) echo "BeBits gcc"

>             add_cflags -fno-expensive-optimizations

>             ;;

>         esac

>         SHFLAGS=-nostart

>         # enable BeOS things

>         enable audio_beos

>         # no need for libm, but the inet stuff

>         # Check for BONE

>         # XXX: actually should check for NOT net_server

>         if echo $BEINCLUDES | grep -q 'headers/be/bone'; then

>             network_extralibs="-lbind -lsocket"

>         else

>             enable beos_netserver

>             network_extralibs="-lnet"

>         fi ;;

2327c2183

<         add_extralibs -lpoll -lgnugetopt

---

>         osextralibs="-lpoll -lgnugetopt"

2332,2333d2187

<         gas="gas-preprocessor.pl $cc"

<         enabled ppc && add_asflags -force_cpusubtype_ALL

2335,2336c2189,2190

<         strip="${strip} -x"

<         add_ldflags -Wl,-dynamic,-search_paths_first

---

>         strip="strip -x"

>         FFLDFLAGS="-Wl,-dynamic,-search_paths_first"

2375,2376c2229,2230

<         check_cpp_condition _mingw.h "defined (__MINGW64_VERSION_MAJOR) || (__MINGW32_MAJOR_VERSION > 3) /

<                                       || (__MINGW32_MAJOR_VERSION == 3 && __MINGW32_MINOR_VERSION >= 15)" ||

---

>         if ! enabled x86_64; then

>             check_cpp_condition _mingw.h "(__MINGW32_MAJOR_VERSION > 3) || (__MINGW32_MAJOR_VERSION == 3 && __MINGW32_MINOR_VERSION >= 15)" ||

2377a2232,2235

>             enabled_any avisynth vfwcap_indev &&

>                 { check_cpp_condition w32api.h "(__W32API_MAJOR_VERSION > 3) || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION >= 13)" ||

>                   die "ERROR: avisynth and vfwcap_indev require w32api version 3.13 or later."; }

>         fi

2408c2266

<         add_ldflags -Zomf -Zbin-files -Zargs-wild -Zmap

---

>         FFLDFLAGS="-Zomf -Zbin-files -Zargs-wild -Zmap"

2439,2440d2296

< echo "config:$arch:$subarch:$cpu:$target_os:$cc_ident:$FFMPEG_CONFIGURATION" >config.fate

2444a2301,2305

> add_extralibs $osextralibs

> # Combine FFLDFLAGS and the LDFLAGS environment variable.

> LDFLAGS="$FFLDFLAGS $LDFLAGS"

2457a2319,2334

> if enabled_any libfaad libfaadbin ; then

>     if check_header faad.h; then

>         check_cc <<EOF

> #include <faad.h>

> #ifndef FAAD2_VERSION

> ok faad1

> #endif

> int main(void) { return 0; }

> EOF

>         test $? = 0 && enable libfaad2

>     else

>         die "FAAD test failed."

>     fi

> fi

2461a2339

> die_license_disabled gpl libfaad2

2463d2340

< die_license_disabled gpl libxavs

2525d2401

<     nogas=die

2553,2554c2429

<     check_asm dcbzl     '"dcbzl 0, %0" :: "r"(0)'

<     check_asm ibm_asm   '"add 0, 0, 0"'

---

>     check_asm dcbzl     '"dcbzl 0, 1"'

2560d2434

<         nogas=warn

2607,2609d2480

<     # check whether xmm clobbers are supported

<     check_asm xmm_clobbers '"":::"%xmm0"'

2628,2647c2499,2506

<     if ! disabled_any asm mmx yasm; then

<         if check_cmd $yasmexe --version; then

<             enabled x86_64 && yasm_extra="-m amd64"

<             yasm_debug="-g dwarf2"

<         elif check_cmd nasm -v; then

<             yasmexe=nasm

<             yasm_debug="-g -F dwarf"

<             enabled x86_64 && test "$objformat" = elf && objformat=elf64

<         fi

<         YASMFLAGS="-f $objformat $yasm_extra"

<         enabled pic               && append YASMFLAGS "-DPIC"

<         test -n "$extern_prefix"  && append YASMFLAGS "-DPREFIX"

<         case "$objformat" in

<             elf*) enabled debug && append YASMFLAGS $yasm_debug ;;

<         esac

<         check_yasm "pabsw xmm0, xmm0" && enable yasm ||

<             die "yasm not found, use --disable-yasm for a crippled build"

<     fi

---

>     YASMFLAGS="-f $objformat -DARCH_$(toupper $subarch)"

>     enabled     x86_64        && append YASMFLAGS "-m amd64"

>     enabled     pic           && append YASMFLAGS "-DPIC"

>     test -n "$extern_prefix"  && append YASMFLAGS "-DPREFIX"

>     case "$objformat" in

>         elf) enabled debug && append YASMFLAGS "-g dwarf2" ;;

>     esac

>     disabled yasm || { check_yasm "pabsw xmm0, xmm0" && enable yasm; }

2657,2662d2515

< if enabled asm; then

<     as=${gas:=$as}

<     check_asm gnu_as '".macro m n/n//n:.int 0/n.endm/nm x"' ||

<         $nogas "GNU assembler not found, install gas-preprocessor"

< fi

2672d2524

< check_func  fcntl

2682d2533

< check_func  mmap

2686d2536

< check_func  strtok_r

2691d2540

< check_func_headers windows.h MapViewOfFile

2719,2720c2568

< if ! disabled pthreads && ! enabled w32threads; then

<     enable pthreads

---

> if enabled pthreads; then

2732c2580

<         disable pthreads

---

>         die "ERROR: can't find pthreads library"

2745c2593

< disabled vaapi || check_lib va/va.h vaInitialize -lva

---

> check_lib va/va.h vaInitialize -lva

2761d2608

< enabled frei0r     && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }

2765a2613

> enabled libfaad    && require2 libfaad faad.h faacDecOpen -lfaad

2767c2615

< enabled libmp3lame && require  "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame

---

> enabled libmp3lame && require  libmp3lame lame/lame.h lame_init -lmp3lame -lm

2769,2772c2617,2618

< enabled libopencore_amrnb  && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb

< enabled libopencore_amrwb  && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb

< enabled libopencv  && { check_lib opencv/cv.h cvCreateImageHeader $(pkg-config --libs opencv) ||

<                         die "ERROR: libopencv not found"; }

---

> enabled libopencore_amrnb  && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb -lm

> enabled libopencore_amrwb  && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb -lm

2774,2775c2620

< enabled librtmp    && { check_lib librtmp/rtmp.h RTMP_Socket $(pkg-config --libs librtmp) ||

<                         die "ERROR: librtmp not found or RTMP_Socket() missing, librtmp version must be >= 2.2.f"; }

---

> enabled librtmp    && require  librtmp librtmp/rtmp.h RTMP_Init $(pkg-config --libs librtmp)

2781,2789c2626,2630

< enabled libvpx     && {

<     enabled libvpx_decoder && { check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||

<                                 die "ERROR: libvpx decoder version must be >=0.9.1"; }

<     enabled libvpx_encoder && { check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_enc_init_ver -lvpx ||

<                                 die "ERROR: libvpx encoder version must be >=0.9.1"; } }

< enabled libx264    && require  libx264 x264.h x264_encoder_encode -lx264 &&

<                       { check_cpp_condition x264.h "X264_BUILD >= 99" ||

<                         die "ERROR: libx264 version must be >= 0.99."; }

< enabled libxavs    && require  libxavs xavs.h xavs_encoder_encode -lxavs

---

> enabled libvpx     && require2 libvpx "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_dec_init_ver" -lvpx &&

>                       require2 libvpx "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver" -lvpx

> enabled libx264    && require  libx264 x264.h x264_encoder_encode -lx264 -lm &&

>                       { check_cpp_condition x264.h "X264_BUILD >= 83" ||

>                         die "ERROR: libx264 version must be >= 0.83."; }

2817c2658

<     check_type netinet/in.h "struct ipv6_mreq" -D_DARWIN_C_SOURCE

---

>     check_type netinet/in.h "struct ipv6_mreq"

2845,2847d2685

< # check that WM_CAP_DRIVER_CONNECT is defined to the proper value

< # w32api 3.12 had it defined wrong

< check_cpp_condition vfw.h "WM_CAP_DRIVER_CONNECT > WM_USER" && enable vfwcap_defines

2885d2722

< check_cflags -Wno-parentheses

2901c2738

< check_ldflags '-Wl,-rpath-link,/$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,/$(BUILD_ROOT)/libswscale -Wl,-rpath-link,/$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,/$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,/$(BUILD_ROOT)/libavformat -Wl,-rpath-link,/$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,/$(BUILD_ROOT)/libavcore -Wl,-rpath-link,/$(BUILD_ROOT)/libavutil'

---

> check_ldflags '-Wl,-rpath-link,/$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,/$(BUILD_ROOT)/libswscale -Wl,-rpath-link,/$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,/$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,/$(BUILD_ROOT)/libavformat -Wl,-rpath-link,/$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,/$(BUILD_ROOT)/libavutil'

2934d2770

<     # 10148: ignoring unknown option -Wno-parentheses

2936c2772

<     check_cflags -wd144,167,556,10006,10148,10156

---

>     check_cflags -wd144,167,556,10006,10156

2944,2948d2779

<     if enabled x86_32; then

<         test ${icc_version%%.*} -ge 11 && /

<             check_cflags -falign-stack=maintain-16-byte || /

<             disable aligned_stack

<     fi

2959c2790

<     check_cflags -Werror=implicit-function-declaration

---

>     check_cflags -Werror=implicit

2961,2962d2791

< elif enabled llvm_gcc; then

<     check_cflags -mllvm -stack-alignment=16

2964d2792

<     check_cflags -mllvm -stack-alignment=16

2968,2969c2796,2797

<     add_cflags -W${armcc_opt},--diag_suppress=2523

<     add_cflags -W${armcc_opt},--diag_suppress=1207

---

>     add_cflags -Wrvct,--diag_suppress=2523

>     add_cflags -Wrvct,--diag_suppress=1207

2973a2802,2809

> if enabled gprof; then

>     add_cflags  -p

>     add_ldflags -p

> fi

> # Find out if the .align argument is a power of two or not.

> check_asm asmalign_pot '".align 3"'

2990,2994d2825

<            $ACODEC_TESTS      /

<            $VCODEC_TESTS      /

<            $LAVF_TESTS        /

<            $LAVFI_TESTS       /

<            $SEEK_TESTS        /

3000a2832

> echo ".align is power-of-two    $asmalign_pot"

3038a2871

>     echo "performance report        ${powerpc_perf-no}"

3042a2876

> echo "gprof enabled             ${gprof-no}"

3049a2884

> echo "filters using lavformat   ${avfilter_lavf-no}"

3055d2889

< echo "frei0r enabled            ${frei0r-no}"

3058a2893,2894

> echo "libfaad enabled           ${libfaad-no}"

> echo "libfaad dlopened          ${libfaadbin-no}"

3064d2899

< echo "libopencv support         ${libopencv-no}"

3073d2907

< echo "libxavs enabled           ${libxavs-no}"

3082c2916,2918

<     print_enabled '_*' $list | sort | pr -3 -t

---

>     for part in $list; do

>         enabled $part && echo ${part%_*}

>     done | sort | pr -3 -t

3107d2942

<         libavcore

3110d2944

<         libavfilter/$arch

3127d2960

<         libavcore/Makefile

3130d2962

<         libavfilter/${arch}/Makefile

3142,3143d2973

< config_files="$TMPH config.mak"

3159d2988

< CC_IDENT=$cc_ident

3230d3058

< get_version LIBAVCORE   libavcore/avcore.h

3235a3064,3065

> enabled asmalign_pot || align_shift="1 <<"

3246c3076

< #define ASMALIGN(ZEROBITS) ".p2align " #ZEROBITS "//n//t"

---

> #define ASMALIGN(ZEROBITS) ".align $align_shift " #ZEROBITS "//n//t"

3249d3078

< #define SLIBSUF "$SLIBSUF"

3257,3261c3086

<     if enabled small; then

<         echo "#define av_always_inline inline"  >> $TMPH

<     else

<         echo "#define av_always_inline av_unused"  >> $TMPH

<     fi

---

>     echo "#define av_always_inline"  >> $TMPH

3264,3291c3089,3103

< if enabled yasm; then

<     append config_files $TMPASM

<     printf '' >$TMPASM

< fi

< print_config ARCH_   "$config_files" $ARCH_LIST

< print_config HAVE_   "$config_files" $HAVE_LIST

< print_config CONFIG_ "$config_files" $CONFIG_LIST       /

<                                      $CONFIG_EXTRA      /

<                                      $DECODER_LIST      /

<                                      $ENCODER_LIST      /

<                                      $HWACCEL_LIST      /

<                                      $PARSER_LIST       /

<                                      $BSF_LIST          /

<                                      $DEMUXER_LIST      /

<                                      $MUXER_LIST        /

<                                      $FILTER_LIST       /

<                                      $PROTOCOL_LIST     /

<                                      $INDEV_LIST        /

<                                      $OUTDEV_LIST       /

< cat >>config.mak <<EOF

< ACODEC_TESTS=$(print_enabled -n _test $ACODEC_TESTS)

< VCODEC_TESTS=$(print_enabled -n _test $VCODEC_TESTS)

< LAVF_TESTS=$(print_enabled   -n _test $LAVF_TESTS)

< LAVFI_TESTS=$(print_enabled  -n _test $LAVFI_TESTS)

< SEEK_TESTS=$(print_enabled   -n _test $SEEK_TESTS)

< EOF

---

> print_config ARCH_   $TMPH config.mak $ARCH_LIST

> print_config HAVE_   $TMPH config.mak $HAVE_LIST

> print_config CONFIG_ $TMPH config.mak $CONFIG_LIST       /

>                                       $CONFIG_EXTRA      /

>                                       $DECODER_LIST      /

>                                       $ENCODER_LIST      /

>                                       $HWACCEL_LIST      /

>                                       $PARSER_LIST       /

>                                       $BSF_LIST          /

>                                       $DEMUXER_LIST      /

>                                       $MUXER_LIST        /

>                                       $FILTER_LIST       /

>                                       $PROTOCOL_LIST     /

>                                       $INDEV_LIST        /

>                                       $OUTDEV_LIST       /

3298,3300d3109

< touch .config

< enabled yasm && cp_if_changed $TMPASM config.asm

3308c3117

< print_config AV_HAVE_ $TMPH $HAVE_LIST_PUB

---

> print_config AV_HAVE_ $TMPH /dev/null $HAVE_LIST_PUB

3314,3315d3122

< test -n "$WARNINGS" && printf "/n$WARNINGS"

3325d3131

< enabled ${name#lib} || return 0

3359,3360c3165

< pkgconfig_generate libavcore "FFmpeg multimedia shared core utilities library" "$LIBAVCORE_VERSION" "" "libavutil = $LIBAVUTIL_VERSION"

< pkgconfig_generate libavcodec "FFmpeg codec library" "$LIBAVCODEC_VERSION" "$extralibs" "libavcore = $LIBAVCORE_VERSION"

---

> pkgconfig_generate libavcodec "FFmpeg codec library" "$LIBAVCODEC_VERSION" "$extralibs" "libavutil = $LIBAVUTIL_VERSION"

3363,3364c3168,3171

< pkgconfig_generate libavfilter "FFmpeg video filtering library" "$LIBAVFILTER_VERSION" "$extralibs" "libavcore = $LIBAVCORE_VERSION"

< pkgconfig_generate libpostproc "FFmpeg post processing library" "$LIBPOSTPROC_VERSION"

---

> enabled avfilter &&

>     pkgconfig_generate libavfilter "FFmpeg video filtering library" "$LIBAVFILTER_VERSION" "$extralibs" "libavutil = $LIBAVUTIL_VERSION"

> enabled postproc &&

>     pkgconfig_generate libpostproc "FFmpeg post processing library" "$LIBPOSTPROC_VERSION"

Common subdirectories: ffmpeg/doc and ffmpeg-0.6.1/doc

diff ffmpeg/Doxyfile ffmpeg-0.6.1/Doxyfile

1c1

< # Doxyfile 1.5.6

---

> # Doxyfile 1.3-rc1

14c14

< # Project related configuration options

---

> # General configuration options

17,24d16

< # This tag specifies the encoding used for all characters in the config file

< # that follow. The default is UTF-8 which is also the encoding used for all

< # text before the first occurrence of this tag. Doxygen uses libiconv (or the

< # iconv built into libc) for the transcoding. See

< # http://www.gnu.org/software/libiconv for the list of possible encodings.

< DOXYFILE_ENCODING      = UTF-8

43,51d34

< # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create

< # 4096 sub-directories (in 2 levels) under the output directory of each output

< # format and will distribute the generated files over these directories.

< # Enabling this option can be useful when feeding doxygen a huge amount of

< # source files, where putting all generated files in the same directory would

< # otherwise cause performance problems for the file system.

< CREATE_SUBDIRS         = NO

56,61c39,42

< # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,

< # Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek,

< # Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages),

< # Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish,

< # Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish,

< # and Ukrainian.

---

> # Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch,

> # Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en

> # (Japanese with english messages), Korean, Norwegian, Polish, Portuguese,

> # Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish and Ukrainian.

65,274d45

< # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will

< # include brief member descriptions after the members that are listed in

< # the file and class documentation (similar to JavaDoc).

< # Set to NO to disable this.

< BRIEF_MEMBER_DESC      = YES

< # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend

< # the brief description of a member or function before the detailed description.

< # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the

< # brief descriptions will be completely suppressed.

< REPEAT_BRIEF           = YES

< # This tag implements a quasi-intelligent brief description abbreviator

< # that is used to form the text in various listings. Each string

< # in this list, if found as the leading text of the brief description, will be

< # stripped from the text and the result after processing the whole list, is

< # used as the annotated text. Otherwise, the brief description is used as-is.

< # If left blank, the following values are used ("$name" is automatically

< # replaced with the name of the entity): "The $name class" "The $name widget"

< # "The $name file" "is" "provides" "specifies" "contains"

< # "represents" "a" "an" "the"

< ABBREVIATE_BRIEF       =

< # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then

< # Doxygen will generate a detailed section even if there is only a brief

< # description.

< ALWAYS_DETAILED_SEC    = NO

< # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all

< # inherited members of a class in the documentation of that class as if those

< # members were ordinary class members. Constructors, destructors and assignment

< # operators of the base classes will not be shown.

< INLINE_INHERITED_MEMB  = NO

< # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full

< # path before files name in the file list and in the header files. If set

< # to NO the shortest path that makes the file name unique will be used.

< FULL_PATH_NAMES        = YES

< # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag

< # can be used to strip a user-defined part of the path. Stripping is

< # only done if one of the specified strings matches the left-hand part of

< # the path. The tag can be used to show relative paths in the file list.

< # If left blank the directory from which doxygen is run is used as the

< # path to strip.

< STRIP_FROM_PATH        = .

< # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of

< # the path mentioned in the documentation of a class, which tells

< # the reader which header file to include in order to use a class.

< # If left blank only the name of the header file containing the class

< # definition is used. Otherwise one should specify the include paths that

< # are normally passed to the compiler using the -I flag.

< STRIP_FROM_INC_PATH    =

< # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter

< # (but less readable) file names. This can be useful is your file systems

< # doesn't support long names like on DOS, Mac, or CD-ROM.

< SHORT_NAMES            = NO

< # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen

< # will interpret the first line (until the first dot) of a JavaDoc-style

< # comment as the brief description. If set to NO, the JavaDoc

< # comments will behave just like regular Qt-style comments

< # (thus requiring an explicit @brief command for a brief description.)

< JAVADOC_AUTOBRIEF      = YES

< # If the QT_AUTOBRIEF tag is set to YES then Doxygen will

< # interpret the first line (until the first dot) of a Qt-style

< # comment as the brief description. If set to NO, the comments

< # will behave just like regular Qt-style comments (thus requiring

< # an explicit /brief command for a brief description.)

< QT_AUTOBRIEF           = NO

< # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen

< # treat a multi-line C++ special comment block (i.e. a block of //! or ///

< # comments) as a brief description. This used to be the default behaviour.

< # The new default is to treat a multi-line C++ comment block as a detailed

< # description. Set this tag to YES if you prefer the old behaviour instead.

< MULTILINE_CPP_IS_BRIEF = NO

< # If the DETAILS_AT_TOP tag is set to YES then Doxygen

< # will output the detailed description near the top, like JavaDoc.

< # If set to NO, the detailed description appears after the member

< # documentation.

< DETAILS_AT_TOP         = NO

< # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented

< # member inherits the documentation from any documented member that it

< # re-implements.

< INHERIT_DOCS           = YES

< # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce

< # a new page for each member. If set to NO, the documentation of a member will

< # be part of the file/class/namespace that contains it.

< SEPARATE_MEMBER_PAGES  = NO

< # The TAB_SIZE tag can be used to set the number of spaces in a tab.

< # Doxygen uses this value to replace tabs by spaces in code fragments.

< TAB_SIZE               = 8

< # This tag can be used to specify a number of aliases that acts

< # as commands in the documentation. An alias has the form "name=value".

< # For example adding "sideeffect=/par Side Effects:/n" will allow you to

< # put the command /sideeffect (or @sideeffect) in the documentation, which

< # will result in a user-defined paragraph with heading "Side Effects:".

< # You can put /n's in the value part of an alias to insert newlines.

< ALIASES                =

< # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C

< # sources only. Doxygen will then generate output that is more tailored for C.

< # For instance, some of the names that are used will be different. The list

< # of all members will be omitted, etc.

< OPTIMIZE_OUTPUT_FOR_C  = YES

< # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java

< # sources only. Doxygen will then generate output that is more tailored for

< # Java. For instance, namespaces will be presented as packages, qualified

< # scopes will look different, etc.

< OPTIMIZE_OUTPUT_JAVA   = NO

< # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran

< # sources only. Doxygen will then generate output that is more tailored for

< # Fortran.

< OPTIMIZE_FOR_FORTRAN   = NO

< # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL

< # sources. Doxygen will then generate output that is tailored for

< # VHDL.

< OPTIMIZE_OUTPUT_VHDL   = NO

< # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want

< # to include (a tag file for) the STL sources as input, then you should

< # set this tag to YES in order to let doxygen match functions declarations and

< # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.

< # func(std::string) {}). This also make the inheritance and collaboration

< # diagrams that involve STL classes more complete and accurate.

< BUILTIN_STL_SUPPORT    = NO

< # If you use Microsoft's C++/CLI language, you should set this option to YES to

< # enable parsing support.

< CPP_CLI_SUPPORT        = NO

< # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.

< # Doxygen will parse them like normal C++ but will assume all classes use public

< # instead of private inheritance when no explicit protection keyword is present.

< SIP_SUPPORT            = NO

< # For Microsoft's IDL there are propget and propput attributes to indicate getter

< # and setter methods for a property. Setting this option to YES (the default)

< # will make doxygen to replace the get and set methods by a property in the

< # documentation. This will only work if the methods are indeed getting or

< # setting a simple type. If this is not the case, or you want to show the

< # methods anyway, you should set this option to NO.

< IDL_PROPERTY_SUPPORT   = YES

< # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC

< # tag is set to YES, then doxygen will reuse the documentation of the first

< # member in the group (if any) for the other members of the group. By default

< # all members of a group must be documented explicitly.

< DISTRIBUTE_GROUP_DOC   = NO

< # Set the SUBGROUPING tag to YES (the default) to allow class member groups of

< # the same type (for instance a group of public functions) to be put as a

< # subgroup of that type (e.g. under the Public Functions section). Set it to

< # NO to prevent subgrouping. Alternatively, this can be done per class using

< # the /nosubgrouping command.

< SUBGROUPING            = YES

< # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum

< # is documented as struct, union, or enum with the name of the typedef. So

< # typedef struct TypeS {} TypeT, will appear in the documentation as a struct

< # with name TypeT. When disabled the typedef will appear as a member of a file,

< # namespace, or class. And the struct will be named TypeS. This can typically

< # be useful for C code in case the coding convention dictates that all compound

< # types are typedef'ed and only the typedef is referenced, never the tag name.

< TYPEDEF_HIDES_STRUCT   = NO

< #---------------------------------------------------------------------------

< # Build related configuration options

< #---------------------------------------------------------------------------

298,312d68

< # This flag is only useful for Objective-C code. When set to YES local

< # methods, which are defined in the implementation section but not in

< # the interface are included in the documentation.

< # If set to NO (the default) only methods in the interface are included.

< EXTRACT_LOCAL_METHODS  = NO

< # If this flag is set to YES, the members of anonymous namespaces will be

< # extracted and appear in the documentation as a namespace called

< # 'anonymous_namespace{file}', where file will be replaced with the base

< # name of the file that contains the anonymous namespace. By default

< # anonymous namespace are hidden.

< EXTRACT_ANON_NSPACES   = NO

323c79

< # If set to NO (the default) these classes will be included in the various

---

> # If set to NO (the default) these class will be included in the various

341a98,137

> # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will

> # include brief member descriptions after the members that are listed in

> # the file and class documentation (similar to JavaDoc).

> # Set to NO to disable this.

> BRIEF_MEMBER_DESC      = YES

> # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend

> # the brief description of a member or function before the detailed description.

> # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the

> # brief descriptions will be completely suppressed.

> REPEAT_BRIEF           = YES

> # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then

> # Doxygen will generate a detailed section even if there is only a brief

> # description.

> ALWAYS_DETAILED_SEC    = NO

> # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited

> # members of a class in the documentation of that class as if those members were

> # ordinary class members. Constructors, destructors and assignment operators of

> # the base classes will not be shown.

> INLINE_INHERITED_MEMB  = NO

> # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full

> # path before files name in the file list and in the header files. If set

> # to NO the shortest path that makes the file name unique will be used.

> FULL_PATH_NAMES        = YES

> # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag

> # can be used to strip a user defined part of the path. Stripping is

> # only done if one of the specified strings matches the left-hand part of

> # the path. It is allowed to use relative paths in the argument list.

> STRIP_FROM_PATH        = .

350c146

< # file names in lower-case letters. If set to YES upper-case letters are also

---

> # file names in lower case letters. If set to YES upper case letters are also

353c149

< # and Mac users are advised to set this option to NO.

---

> # users are adviced to set this option to NO.

356a153,158

> # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter

> # (but less readable) file names. This can be useful is your file systems

> # doesn't support long names like on DOS, Mac, or CD-ROM.

> SHORT_NAMES            = NO

362a165,170

> # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen

> # will generate a verbatim copy of the header file for each class for

> # which an include is specified. Set to NO to disable this.

> VERBATIM_HEADERS       = YES

364c172

< # will put a list of the files that are included by a file in the documentation

---

> # will put list of the files that are included by a file in the documentation

368a177,205

> # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen

> # will interpret the first line (until the first dot) of a JavaDoc-style

> # comment as the brief description. If set to NO, the JavaDoc

> # comments  will behave just like the Qt-style comments (thus requiring an

> # explict @brief command for a brief description.

> JAVADOC_AUTOBRIEF      = YES

> # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen

> # treat a multi-line C++ special comment block (i.e. a block of //! or ///

> # comments) as a brief description. This used to be the default behaviour.

> # The new default is to treat a multi-line C++ comment block as a detailed

> # description. Set this tag to YES if you prefer the old behaviour instead.

> MULTILINE_CPP_IS_BRIEF = NO

> # If the DETAILS_AT_TOP tag is set to YES then Doxygen

> # will output the detailed description near the top, like JavaDoc.

> # If set to NO, the detailed description appears after the member

> # documentation.

> DETAILS_AT_TOP         = NO

> # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented

> # member inherits the documentation from any documented member that it

> # reimplements.

> INHERIT_DOCS           = YES

381,384c218,221

< # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the

< # brief documentation of file, namespace and class members alphabetically

< # by member name. If set to NO (the default) the members will appear in

< # declaration order.

---

> # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC

> # tag is set to YES, then doxygen will reuse the documentation of the first

> # member in the group (if any) for the other members of the group. By default

> # all members of a group must be documented explicitly.

386c223

< SORT_BRIEF_DOCS        = NO

---

> DISTRIBUTE_GROUP_DOC   = NO

388,400c225,226

< # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the

< # hierarchy of group names into alphabetical order. If set to NO (the default)

< # the group names will appear in their defined order.

< SORT_GROUP_NAMES       = NO

< # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be

< # sorted by fully-qualified names, including namespaces. If set to

< # NO (the default), the class list will be sorted only by class name,

< # not including the namespace part.

< # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.

< # Note: This option applies only to the class list, not to the

< # alphabetical list.

---

> # The TAB_SIZE tag can be used to set the number of spaces in a tab.

> # Doxygen uses this value to replace tabs by spaces in code fragments.

402c228

< SORT_BY_SCOPE_NAME     = NO

---

> TAB_SIZE               = 8

427a254,262

> # This tag can be used to specify a number of aliases that acts

> # as commands in the documentation. An alias has the form "name=value".

> # For example adding "sideeffect=/par Side Effects:/n" will allow you to

> # put the command /sideeffect (or @sideeffect) in the documentation, which

> # will result in a user defined paragraph with heading "Side Effects:".

> # You can put /n's in the value part of an alias to insert newlines.

> ALIASES                =

434c269

< # the initial value of a variable or define consists of for it to appear in

---

> # the initial value of a variable or define consist of for it to appear in

443,457c278,281

< # Set the SHOW_USED_FILES tag to NO to disable the list of files generated

< # at the bottom of the documentation of classes and structs. If set to YES the

< # list will mention the files that were used to generate the documentation.

< SHOW_USED_FILES        = YES

< # If the sources in your project are distributed over multiple directories

< # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy

< # in the documentation. The default is NO.

< SHOW_DIRECTORIES       = NO

< # Set the SHOW_FILES tag to NO to disable the generation of the Files page.

< # This will remove the Files entry from the Quick Index and from the

< # Folder Tree View (if specified). The default is YES.

---

> # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources

> # only. Doxygen will then generate output that is more tailored for C.

> # For instance some of the names that are used will be different. The list

> # of all members will be omitted, etc.

459c283

< SHOW_FILES             = YES

---

> OPTIMIZE_OUTPUT_FOR_C  = YES

461,463c285,288

< # Set the SHOW_NAMESPACES tag to NO to disable the generation of the

< # Namespaces page.  This will remove the Namespaces entry from the Quick Index

< # and from the Folder Tree View (if specified). The default is YES.

---

> # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources

> # only. Doxygen will then generate output that is more tailored for Java.

> # For instance namespaces will be presented as packages, qualified scopes

> # will look different, etc.

465c290

< SHOW_NAMESPACES        = YES

---

> OPTIMIZE_OUTPUT_JAVA   = NO

467,473c292,294

< # The FILE_VERSION_FILTER tag can be used to specify a program or script that

< # doxygen should invoke to get the current version for each file (typically from

< # the version control system). Doxygen will invoke the program by executing (via

< # popen()) the command <command> <input-file>, where <command> is the value of

< # the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file

< # provided by doxygen. Whatever the program writes to standard output

< # is used as the file version. See the manual for examples.

---

> # Set the SHOW_USED_FILES tag to NO to disable the list of files generated

> # at the bottom of the documentation of classes and structs. If set to YES the

> # list will mention the files that were used to generate the documentation.

475c296

< FILE_VERSION_FILTER    =

---

> SHOW_USED_FILES        = YES

484c305

< QUIET                  = YES

---

> QUIET                  = NO

498,512d318

< # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for

< # potential errors in the documentation, such as not documenting some

< # parameters in a documented function, or documenting parameters that

< # don't exist or using markup commands wrongly.

< WARN_IF_DOC_ERROR      = YES

< # This WARN_NO_PARAMDOC option can be abled to get warnings for

< # functions that are documented, but have no documentation for their parameters

< # or return value. If set to NO (the default) doxygen will only warn about

< # wrong or incomplete parameter documentation, but not about the absence of

< # documentation.

< WARN_NO_PARAMDOC       = NO

516,518c322

< # warning originated and the warning text. Optionally the format may contain

< # $version, which will be replaced by the version of the file (if it could

< # be obtained via FILE_VERSION_FILTER)

---

> # warning originated and the warning text.

539,546d342

< # This tag can be used to specify the character encoding of the source files

< # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

< # also the default input encoding. Doxygen uses libiconv (or the iconv built

< # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for

< # the list of possible encodings.

< INPUT_ENCODING         = UTF-8

551,552c347,348

< # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx

< # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90

---

> # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp

> # *.h++ *.idl *.odl

568,570c364,365

< # The EXCLUDE_SYMLINKS tag can be used select whether or not files or

< # directories that are symbolic links (a Unix filesystem feature) are excluded

< # from the input.

---

> # The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories

> # that are symbolic links (a Unix filesystem feature) are excluded from the input.

576,586c371

< # certain files from those directories. Note that the wildcards are matched

< # against the file with absolute path, so to exclude all test directories

< # for example use the pattern */test/*

< EXCLUDE_PATTERNS       = *.svn *.git *.d

< # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names

< # (namespaces, classes, functions, etc.) that should be excluded from the

< # output. The symbol name can be a fully qualified name, a word, or if the

< # wildcard * is used, a substring. Examples: ANamespace, AClass,

< # AClass::ANamespace, ANamespace::*Test

---

> # certain files from those directories.

588c373

< EXCLUDE_SYMBOLS        =

---

> EXCLUDE_PATTERNS       = *.svn *.git

621,622c406

< # to standard output.  If FILTER_PATTERNS is specified, this tag will be

< # ignored.

---

> # to standard output.

626,634d409

< # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern

< # basis.  Doxygen will compare the file name with each pattern and apply the

< # filter if there is a match.  The filters are a list of the form:

< # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further

< # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER

< # is applied to all files.

< FILTER_PATTERNS        =

647,648d421

< # Note: To get rid of all source code in the generated output, make sure also

< # VERBATIM_HEADERS is set to NO.

663c436

< # If the REFERENCED_BY_RELATION tag is set to YES

---

> # If the REFERENCED_BY_RELATION tag is set to YES (the default)

669c442

< # If the REFERENCES_RELATION tag is set to YES

---

> # If the REFERENCES_RELATION tag is set to YES (the default)

675,695d447

< # If the REFERENCES_LINK_SOURCE tag is set to YES (the default)

< # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from

< # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will

< # link to the source code.  Otherwise they will link to the documentstion.

< REFERENCES_LINK_SOURCE = YES

< # If the USE_HTAGS tag is set to YES then the references to source code

< # will point to the HTML generated by the htags(1) tool instead of doxygen

< # built-in source browser. The htags tool is part of GNU's global source

< # tagging system (see http://www.gnu.org/software/global/global.html). You

< # will need version 4.8.6 or higher.

< USE_HTAGS              = NO

< # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen

< # will generate a verbatim copy of the header file for each class for

< # which an include is specified. Set to NO to disable this.

< VERBATIM_HEADERS       = YES

752c504

< # The HTML_STYLESHEET tag can be used to specify a user-defined cascading

---

> # The HTML_STYLESHEET tag can be used to specify a user defined cascading

755,757c507

< # will generate a default style sheet. Note that doxygen will try to copy

< # the style sheet file to the HTML output directory, so don't put your own

< # stylesheet in the HTML output directory as well, or it will be erased!

---

> # will generate a default style sheet

769c519

< # Microsoft HTML help workshop to generate a compiled HTML help file (.chm)

---

> # Microsoft HTML help workshop to generate a compressed HTML help file (.chm)

774,806d523

< # If the GENERATE_DOCSET tag is set to YES, additional index files

< # will be generated that can be used as input for Apple's Xcode 3

< # integrated development environment, introduced with OSX 10.5 (Leopard).

< # To create a documentation set, doxygen will generate a Makefile in the

< # HTML output directory. Running make will produce the docset in that

< # directory and running "make install" will install the docset in

< # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find

< # it at startup.

< GENERATE_DOCSET        = NO

< # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the

< # feed. A documentation feed provides an umbrella under which multiple

< # documentation sets from a single provider (such as a company or product suite)

< # can be grouped.

< DOCSET_FEEDNAME        = "Doxygen generated docs"

< # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that

< # should uniquely identify the documentation set bundle. This should be a

< # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen

< # will append .docset to the name.

< DOCSET_BUNDLE_ID       = org.doxygen.Project

< # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML

< # documentation will contain sections that can be hidden and shown after the

< # page has loaded. For this to work a browser that supports

< # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox

< # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).

< HTML_DYNAMIC_SECTIONS  = NO

810c527

< # written to the html output directory.

---

> # written to the html output dir.

816,817c533,534

< # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run

< # the HTML help compiler on the generated index.hhp.

---

> # the HTML help compiler (hhc.exe). If non empty doxygen will try to run

> # the html help compiler on the generated index.hhp.

827,832d543

< # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING

< # is used to encode HtmlHelp index (hhk), content (hhc) and project file

< # content.

< CHM_INDEX_ENCODING     =

840c551

< # to the contents of the HTML help documentation and to the tree view.

---

> # to the contents of the Html help documentation and to the tree view.

855,858c566,567

< # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index

< # structure should be generated to display hierarchical information.

< # If the tag value is set to FRAME, a side panel will be generated

< # containing a tree-like index structure (just like the one that

---

> # If the GENERATE_TREEVIEW tag is set to YES, a side panel will be

> # generated containing a tree-like index structure (just like the one that

860,868c569,572

< # JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,

< # Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are

< # probably better off using the HTML help feature. Other possible values

< # for this tag are: HIERARCHIES, which will generate the Groups, Directories,

< # and Class Hiererachy pages using a tree view instead of an ordered list;

< # ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which

< # disables this behavior completely. For backwards compatibility with previous

< # releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE

< # respectively.

---

> # JavaScript and frames is required (for instance Mozilla, Netscape 4.0+,

> # or Internet explorer 4.0+). Note that for large projects the tree generation

> # can take a very long time. In such cases it is better to disable this feature.

> # Windows users are probably better off using the HTML help feature.

878,885d581

< # Use this tag to change the font size of Latex formulas included

< # as images in the HTML documentation. The default is 10. Note that

< # when you change the font size after a successful doxygen run you need

< # to manually remove any form_*.png images from the HTML output directory

< # to force them to be regenerated.

< FORMULA_FONTSIZE       = 10

893c589

< GENERATE_LATEX         = NO

---

> GENERATE_LATEX         = YES

956,961d651

< # If LATEX_HIDE_INDICES is set to YES then doxygen will not

< # include the index chapters (such as File Index, Compound Index, etc.)

< # in the output.

< LATEX_HIDE_INDICES     = NO

994c684

< # config file, i.e. a series of assignments. You only have to provide

---

> # config file, i.e. a series of assigments. You only have to provide

1038c728,730

< # the code including all documentation.

---

> # the code including all documentation. Note that this

> # feature is still experimental and incomplete at the

> # moment.

1042,1047d733

< # The XML_OUTPUT tag is used to specify where the XML pages will be put.

< # If a relative path is entered the value of OUTPUT_DIRECTORY will be

< # put in front of it. If left blank `xml' will be used as the default path.

< XML_OUTPUT             = xml

1060,1066d745

< # If the XML_PROGRAMLISTING tag is set to YES Doxygen will

< # dump the program listings (including syntax highlighting

< # and cross-referencing information) to the XML output. Note that

< # enabling this will significantly increase the size of the XML output.

< XML_PROGRAMLISTING     = YES

1131c810

< # PREDEFINED and EXPAND_AS_DEFINED tags.

---

> # PREDEFINED and EXPAND_AS_PREDEFINED tags.

1157,1159c836

< # omitted =1 is assumed. To prevent a macro definition from being

< # undefined via #undef or recursively expanded use the := operator

< # instead of the = operator.

---

> # omitted =1 is assumed.

1175,1176c852,853

< # function macros are typically used for boiler-plate code, and will confuse

< # the parser if not removed.

---

> # function macros are typically used for boiler-plate code, and will confuse the

> # parser if not removed.

1181c858

< # Configuration::additions related to external references

---

> # Configuration::addtions related to external references

1184,1197c861

< # The TAGFILES option can be used to specify one or more tagfiles.

< # Optionally an initial location of the external documentation

< # can be added for each tagfile. The format of a tag file without

< # this location is as follows:

< #   TAGFILES = file1 file2 ...

< # Adding location for the tag files is done as follows:

< #   TAGFILES = file1=loc1 "file2 = loc2" ...

< # where "loc1" and "loc2" can be relative or absolute paths or

< # URLs. If a location is present for each tag, the installdox tool

< # does not have to be run to correct the links.

< # Note that each tag file must have a unique name

< # (where the name does NOT include the path)

< # If a tag file is not located in the directory in which doxygen

< # is run, you must also specify the path to the tagfile here.

---

> # The TAGFILES tag can be used to specify one or more tagfiles.

1228,1232c892,895

< # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base

< # or super classes. Setting the tag to NO turns the diagrams off. Note that

< # this option is superseded by the HAVE_DOT option below. This is only a

< # fallback. It is recommended to install and use dot, since it yields more

< # powerful graphs.

---

> # generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or

> # super classes. Setting the tag to NO turns the diagrams off. Note that this

> # option is superceded by the HAVE_DOT option below. This is only a fallback. It is

> # recommended to install and use dot, since it yield more powerful graphs.

1236,1244d898

< # You can define message sequence charts within doxygen comments using the /msc

< # command. Doxygen will then run the mscgen tool (see

< # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the

< # documentation. The MSCGEN_PATH tag allows you to specify the directory where

< # the mscgen tool resides. If left empty the tool is assumed to be found in the

< # default search path.

< MSCGEN_PATH            =

1258,1275d911

< # By default doxygen will write a font called FreeSans.ttf to the output

< # directory and reference it in all dot files that doxygen generates. This

< # font does not include all possible unicode characters however, so when you need

< # these (or just want a differently looking font) you can specify the font name

< # using DOT_FONTNAME. You need need to make sure dot is able to find the font,

< # which can be done by putting it in a standard location or by setting the

< # DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory

< # containing the font.

< DOT_FONTNAME           = FreeSans

< # By default doxygen will tell dot to use the output directory to look for the

< # FreeSans.ttf font (which doxygen will put there itself). If you specify a

< # different font using DOT_FONTNAME you can set the path where dot

< # can find it using this tag.

< DOT_FONTPATH           =

1290,1300d925

< # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen

< # will generate a graph for groups, showing the direct groups dependencies

< GROUP_GRAPHS           = YES

< # If the UML_LOOK tag is set to YES doxygen will generate inheritance and

< # collaboration diagrams in a style similar to the OMG's Unified Modeling

< # Language.

< UML_LOOK               = NO

1320,1335d944

< # If the CALL_GRAPH and HAVE_DOT options are set to YES then

< # doxygen will generate a call dependency graph for every global function

< # or class method. Note that enabling this option will significantly increase

< # the time of a run. So in most cases it will be better to enable call graphs

< # for selected functions only using the /callgraph command.

< CALL_GRAPH             = NO

< # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then

< # doxygen will generate a caller dependency graph for every global function

< # or class method. Note that enabling this option will significantly increase

< # the time of a run. So in most cases it will be better to enable caller

< # graphs for selected functions only using the /callergraph command.

< CALLER_GRAPH           = NO

1341,1347d949

< # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES

< # then doxygen will show the dependencies a directory has on other directories

< # in a graphical way. The dependency relations are determined by the #include

< # relations between the files in the directories.

< DIRECTORY_GRAPH        = YES

1355c957

< # found. If left blank, it is assumed the dot tool can be found in the path.

---

> # found. If left blank, it is assumed the dot tool can be found on the path.

1365,1396c967,979

< # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of

< # nodes that will be shown in the graph. If the number of nodes in a graph

< # becomes larger than this value, doxygen will truncate the graph, which is

< # visualized by representing a node as a red box. Note that doxygen if the

< # number of direct children of the root node in a graph is already larger than

< # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note

< # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.

< DOT_GRAPH_MAX_NODES    = 50

< # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the

< # graphs generated by dot. A depth value of 3 means that only nodes reachable

< # from the root by following a path via at most 3 edges will be shown. Nodes

< # that lay further from the root node will be omitted. Note that setting this

< # option to 1 or 2 may greatly reduce the computation time needed for large

< # code bases. Also note that the size of a graph can be further restricted by

< # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.

< MAX_DOT_GRAPH_DEPTH    = 0

< # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent

< # background. This is enabled by default, which results in a transparent

< # background. Warning: Depending on the platform used, enabling this option

< # may lead to badly anti-aliased labels on the edges of a graph (i.e. they

< # become hard to read).

< DOT_TRANSPARENT        = YES

< # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output

< # files in one run (i.e. multiple -o and -T options on the command line). This

< # makes dot run faster, but since only newer versions of dot (>1.8.10)

< # support this, this feature is disabled by default.

---

> # The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width

> # (in pixels) of the graphs generated by dot. If a graph becomes larger than

> # this value, doxygen will try to truncate the graph, so that it fits within

> # the specified constraint. Beware that most browsers cannot cope with very

> # large images.

> MAX_DOT_GRAPH_WIDTH    = 1024

> # The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height

> # (in pixels) of the graphs generated by dot. If a graph becomes larger than

> # this value, doxygen will try to truncate the graph, so that it fits within

> # the specified constraint. Beware that most browsers cannot cope with very

> # large images.

1398c981

< DOT_MULTI_TARGETS      = NO

---

> MAX_DOT_GRAPH_HEIGHT   = 1024

1407c990

< # remove the intermediate dot files that are used to generate

---

> # remove the intermedate dot files that are used to generate

1413c996

< # Configuration::additions related to the search engine

---

> # Configuration::addtions related to the search engine

1419a1003,1037

> # The CGI_NAME tag should be the name of the CGI script that

> # starts the search engine (doxysearch) with the correct parameters.

> # A script with this name will be generated by doxygen.

> CGI_NAME               = search.cgi

> # The CGI_URL tag should be the absolute URL to the directory where the

> # cgi binaries are located. See the documentation of your http daemon for

> # details.

> CGI_URL                =

> # The DOC_URL tag should be the absolute URL to the directory where the

> # documentation is located. If left blank the absolute path to the

> # documentation, with file:// prepended to it, will be used.

> DOC_URL                =

> # The DOC_ABSPATH tag should be the absolute path to the directory where the

> # documentation is located. If left blank the directory on the local machine

> # will be used.

> DOC_ABSPATH            =

> # The BIN_ABSPATH tag must point to the directory where the doxysearch binary

> # is installed.

> BIN_ABSPATH            = /usr/local/bin/

> # The EXT_DOC_PATHS tag can be used to specify one or more paths to

> # documentation generated for other projects. This allows doxysearch to search

> # the documentation for these projects as well.

> EXT_DOC_PATHS          =

Binary files ffmpeg/ffmpeg and ffmpeg-0.6.1/ffmpeg differ

diff ffmpeg/ffmpeg.c ffmpeg-0.6.1/ffmpeg.c

39,42c39

< #include "libavcore/audioconvert.h"

< #include "libavcore/parseutils.h"

< #include "libavcore/samplefmt.h"

< #include "libavutil/colorspace.h"

---

> #include "libavcodec/colorspace.h"

44d40

< #include "libavutil/intreadwrite.h"

50,55d45

< #if CONFIG_AVFILTER

< # include "libavfilter/avfilter.h"

< # include "libavfilter/avfiltergraph.h"

< # include "libavfilter/vsrc_buffer.h"

< #endif

84c74,75

< #include "libavutil/avassert.h"

---

> #undef NDEBUG

> #include <assert.h>

97,99c88

< /**

<  * select an input file for an output file

<  */

---

> /** select an input file for an output file */

101,107d89

<     int  file;      //< file index

<     char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram

<     int  index;     //< stream/chapter/program number

< } AVMetaDataMap;

< typedef struct AVChapterMap {

<     int in_file;

109c91,92

< } AVChapterMap;

---

>     int in_file;

> } AVMetaDataMap;

114,116d96

< #if !FF_API_MAX_STREAMS

< #define MAX_STREAMS 1024    /* arbitrary sanity check value */

< #endif

121,122c101,102

< static double *input_files_ts_scale[MAX_FILES] = {NULL};

< static AVCodec **input_codecs = NULL;

---

> static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];

> static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];

124,125c104

< static int nb_input_codecs = 0;

< static int nb_input_files_ts_scale[MAX_FILES] = {0};

---

> static int nb_icodecs;

128c107

< static AVCodec **output_codecs = NULL;

---

> static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];

130c109

< static int nb_output_codecs = 0;

---

> static int nb_ocodecs;

132c111

< static AVStreamMap *stream_maps = NULL;

---

> static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];

135,136c114

< /* first item specifies output metadata, second is input */

< static AVMetaDataMap (*meta_data_maps)[2] = NULL;

---

> static AVMetaDataMap meta_data_maps[MAX_FILES];

138,147d115

< static int metadata_global_autocopy   = 1;

< static int metadata_streams_autocopy  = 1;

< static int metadata_chapters_autocopy = 1;

< static AVChapterMap *chapter_maps = NULL;

< static int nb_chapter_maps;

< /* indexed by output file stream index */

< static int *streamid_map = NULL;

< static int nb_streamid_map = 0;

153c121,130

< static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;

---

> static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;

> static int frame_padtop  = 0;

> static int frame_padbottom = 0;

> static int frame_padleft  = 0;

> static int frame_padright = 0;

> static int padcolor[3] = {16,128,128}; /* default to black */

> static int frame_topBand  = 0;

> static int frame_bottomBand = 0;

> static int frame_leftBand  = 0;

> static int frame_rightBand = 0;

163c140

< static unsigned int video_codec_tag = 0;

---

> static int video_codec_tag = 0;

173,176d149

< #if CONFIG_AVFILTER

< static char *vfilters = NULL;

< AVFilterGraph *graph = NULL;

< #endif

186c159

< static unsigned int audio_codec_tag = 0;

---

> static int audio_codec_tag = 0;

192c165

< static unsigned int subtitle_codec_tag = 0;

---

> static int subtitle_codec_tag = 0;

199c172

< static int64_t recording_timestamp = 0;

---

> static int64_t rec_timestamp = 0;

202c175,176

< static AVMetadata *metadata;

---

> static int metadata_count;

> static AVMetadataTag *metadata;

243d216

< static char *forced_key_frames = NULL;

244a218

> static int pgmyuv_compatibility_hack=0;

259a234

> static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];

277d251

<     AVBitStreamFilterContext *bitstream_filters;

290,293c264,282

<     /* forced key frames */

<     int64_t *forced_kf_pts;

<     int forced_kf_count;

<     int forced_kf_index;

---

>     /* cropping area sizes */

>     int video_crop;

>     int topBand;

>     int bottomBand;

>     int leftBand;

>     int rightBand;

>     /* cropping area of first frame */

>     int original_topBand;

>     int original_bottomBand;

>     int original_leftBand;

>     int original_rightBand;

>     /* padding area sizes */

>     int video_pad;

>     int padtop;

>     int padbottom;

>     int padleft;

>     int padright;

298,300d286

<     int resample_sample_fmt;

<     int resample_channels;

<     int resample_sample_rate;

307,309d292

< static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };

< static int nb_output_streams_for_file[MAX_FILES] = { 0 };

322d304

<     PtsCorrectionContext pts_ctx;

326,332d307

< #if CONFIG_AVFILTER

<     AVFilterContext *output_video_filter;

<     AVFilterContext *input_video_filter;

<     AVFrame *filter_frame;

<     int has_filter_frame;

<     AVFilterBufferRef *picref;

< #endif

348,421d322

< #if CONFIG_AVFILTER

< static int configure_filters(AVInputStream *ist, AVOutputStream *ost)

< {

<     AVFilterContext *last_filter, *filter;

<     /** filter graph containing all filters including input & output */

<     AVCodecContext *codec = ost->st->codec;

<     AVCodecContext *icodec = ist->st->codec;

<     FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };

<     char args[255];

<     int ret;

<     graph = avfilter_graph_alloc();

<     snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,

<              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);

<     ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),

<                                        "src", args, NULL, graph);

<     if (ret < 0)

<         return ret;

<     ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,

<                                        "out", NULL, &ffsink_ctx, graph);

<     if (ret < 0)

<         return ret;

<     last_filter = ist->input_video_filter;

<     if (codec->width  != icodec->width || codec->height != icodec->height) {

<         snprintf(args, 255, "%d:%d:flags=0x%X",

<                  codec->width,

<                  codec->height,

<                  (int)av_get_int(sws_opts, "sws_flags", NULL));

<         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),

<                                                 NULL, args, NULL, graph)) < 0)

<             return ret;

<         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)

<             return ret;

<         last_filter = filter;

<     }

<     snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));

<     graph->scale_sws_opts = av_strdup(args);

<     if (vfilters) {

<         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));

<         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));

<         outputs->name    = av_strdup("in");

<         outputs->filter_ctx = last_filter;

<         outputs->pad_idx = 0;

<         outputs->next    = NULL;

<         inputs->name    = av_strdup("out");

<         inputs->filter_ctx = ist->output_video_filter;

<         inputs->pad_idx = 0;

<         inputs->next    = NULL;

<         if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)

<             return ret;

<         av_freep(&vfilters);

<     } else {

<         if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)

<             return ret;

<     }

<     if ((ret = avfilter_graph_config(graph, NULL)) < 0)

<         return ret;

<     codec->width  = ist->output_video_filter->inputs[0]->w;

<     codec->height = ist->output_video_filter->inputs[0]->h;

<     return 0;

< }

< #endif /* CONFIG_AVFILTER */

424d324

<     av_log(NULL, AV_LOG_QUIET, "");

465a366,369

> #if CONFIG_BEOS_NETSERVER

>     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);

> #endif

473a378

> #if !CONFIG_BEOS_NETSERVER

481a387

> #endif

501c407

< static int ffmpeg_exit(int ret)

---

> static int av_exit(int ret)

515d420

<             av_free(s->streams[j]->info);

526d430

<         av_free(output_streams_for_file[i]);

528c432

<     for(i=0;i<nb_input_files;i++) {

---

>     for(i=0;i<nb_input_files;i++)

530,531d433

<         av_free(input_files_ts_scale[i]);

<     }

541,545d442

<     av_free(streamid_map);

<     av_free(input_codecs);

<     av_free(output_codecs);

<     av_free(stream_maps);

<     av_free(meta_data_maps);

553c450,458

<     uninit_opts();

---

> #if CONFIG_POWERPC_PERF

>     void powerpc_display_perf_report(void);

>     powerpc_display_perf_report();

> #endif /* CONFIG_POWERPC_PERF */

>     for (i=0;i<AVMEDIA_TYPE_NB;i++)

>         av_free(avcodec_opts[i]);

>     av_free(avformat_opts);

>     av_free(sws_opts);

559,562d463

< #if CONFIG_AVFILTER

<     avfilter_uninit();

< #endif

574,593d474

< /* similar to ff_dynarray_add() and av_fast_realloc() */

< static void *grow_array(void *array, int elem_size, int *size, int new_size)

< {

<     if (new_size >= INT_MAX / elem_size) {

<         fprintf(stderr, "Array too big./n");

<         ffmpeg_exit(1);

<     }

<     if (*size < new_size) {

<         uint8_t *tmp = av_realloc(array, new_size*elem_size);

<         if (!tmp) {

<             fprintf(stderr, "Could not alloc buffer./n");

<             ffmpeg_exit(1);

<         }

<         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);

<         *size = new_size;

<         return tmp;

<     }

<     return array;

< }

597c478

<         const enum AVSampleFormat *p= codec->sample_fmts;

---

>         const enum SampleFormat *p= codec->sample_fmts;

611c492

<         int best=0;

---

>         int best;

631,637d511

<         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){

<             if(st->codec->codec_id==CODEC_ID_MJPEG){

<                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};

<             }else if(st->codec->codec_id==CODEC_ID_LJPEG){

<                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};

<             }

<         }

642c516,520

<         if(*p == -1)

---

>         if(*p == -1

>            && !(   st->codec->codec_id==CODEC_ID_MJPEG

>                 && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL

>                 && (   st->codec->pix_fmt == PIX_FMT_YUV420P

>                     || st->codec->pix_fmt == PIX_FMT_YUV422P)))

647,667d524

< static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)

< {

<     int idx = oc->nb_streams - 1;

<     AVOutputStream *ost;

<     output_streams_for_file[file_idx] =

<         grow_array(output_streams_for_file[file_idx],

<                    sizeof(*output_streams_for_file[file_idx]),

<                    &nb_output_streams_for_file[file_idx],

<                    oc->nb_streams);

<     ost = output_streams_for_file[file_idx][idx] =

<         av_mallocz(sizeof(AVOutputStream));

<     if (!ost) {

<         fprintf(stderr, "Could not alloc output stream/n");

<         ffmpeg_exit(1);

<     }

<     ost->file_index = file_idx;

<     ost->index = idx;

<     return ost;

< }

678c535

<     s->nb_streams = 0;

---

>     s->nb_streams = ic->nb_streams;

683,684d539

<         s->nb_streams++;

691c546

<             ffmpeg_exit(1);

---

>             av_exit(1);

716,717d570

<         new_output_stream(s, nb_output_files);

752c605

<                 ffmpeg_exit(1);

---

>                 av_exit(1);

762c615

<         ffmpeg_exit(1);

---

>         av_exit(1);

777c630

<     int size_out, frame_bytes, ret, resample_changed;

---

>     int size_out, frame_bytes, ret;

780,781c633,634

<     int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;

<     int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;

---

>     int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;

>     int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;

788d640

<     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);

798c650

<         ffmpeg_exit(1);

---

>         av_exit(1);

805c657

<         ffmpeg_exit(1);

---

>         av_exit(1);

811,844c663,674

<     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||

<                        ost->resample_channels    != dec->channels   ||

<                        ost->resample_sample_rate != dec->sample_rate;

<     if ((ost->audio_resample && !ost->resample) || resample_changed) {

<         if (resample_changed) {

<             av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d/n",

<                    ist->file_index, ist->index,

<                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,

<                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);

<             ost->resample_sample_fmt  = dec->sample_fmt;

<             ost->resample_channels    = dec->channels;

<             ost->resample_sample_rate = dec->sample_rate;

<             if (ost->resample)

<                 audio_resample_close(ost->resample);

<         }

<         if (ost->resample_sample_fmt  == enc->sample_fmt &&

<             ost->resample_channels    == enc->channels   &&

<             ost->resample_sample_rate == enc->sample_rate) {

<             ost->resample = NULL;

<             ost->audio_resample = 0;

<         } else {

<             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)

<                 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling/n");

<             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,

<                                                    enc->sample_rate, dec->sample_rate,

<                                                    enc->sample_fmt,  dec->sample_fmt,

<                                                    16, 10, 0, 0.8);

<             if (!ost->resample) {

<                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz/n",

<                         dec->channels, dec->sample_rate,

<                         enc->channels, enc->sample_rate);

<                 ffmpeg_exit(1);

<             }

---

>     if (ost->audio_resample && !ost->resample) {

>         if (dec->sample_fmt != SAMPLE_FMT_S16)

>             fprintf(stderr, "Warning, using s16 intermediate sample format for resampling/n");

>         ost->resample = av_audio_resample_init(enc->channels,    dec->channels,

>                                                enc->sample_rate, dec->sample_rate,

>                                                enc->sample_fmt,  dec->sample_fmt,

>                                                16, 10, 0, 0.8);

>         if (!ost->resample) {

>             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz/n",

>                     dec->channels, dec->sample_rate,

>                     enc->channels, enc->sample_rate);

>             av_exit(1);

848c678

< #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))

---

> #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))

857,859c687,689

<                 av_get_sample_fmt_name(dec->sample_fmt),

<                 av_get_sample_fmt_name(enc->sample_fmt));

<             ffmpeg_exit(1);

---

>                 avcodec_get_sample_fmt_name(dec->sample_fmt),

>                 avcodec_get_sample_fmt_name(enc->sample_fmt));

>             av_exit(1);

866,868c696,698

<                 - av_fifo_size(ost->fifo)/(enc->channels * 2);

<         double idelta= delta*dec->sample_rate / enc->sample_rate;

<         int byte_delta= ((int)idelta)*2*dec->channels;

---

>                 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);

>         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;

>         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;

901c731

<                 av_assert0(ost->audio_resample);

---

>                 assert(ost->audio_resample);

910c740

<                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong

---

>                         - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong

916c746

<                                   size / (dec->channels * isize));

---

>                                   size / (ist->st->codec->channels * isize));

932c762

<                 ffmpeg_exit(1);

---

>                 av_exit(1);

944c774

<             ffmpeg_exit(1);

---

>             av_exit(1);

962c792

<                 ffmpeg_exit(1);

---

>                 av_exit(1);

971c801

<             write_frame(s, &pkt, enc, ost->bitstream_filters);

---

>             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

989c819

<             ffmpeg_exit(1);

---

>             av_exit(1);

997c827

<             ffmpeg_exit(1);

---

>             av_exit(1);

1006c836

<         write_frame(s, &pkt, enc, ost->bitstream_filters);

---

>         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

1067c897

<             ffmpeg_exit(1);

---

>             av_exit(1);

1095c925

<             ffmpeg_exit(1);

---

>             av_exit(1);

1111c941

<         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

---

>         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

1124a955

>     int64_t topBand, bottomBand, leftBand, rightBand;

1125a957

>     AVFrame picture_crop_temp, picture_pad_temp;

1128a961,963

>     avcodec_get_frame_defaults(&picture_crop_temp);

>     avcodec_get_frame_defaults(&picture_pad_temp);

1148c983

<                 ost->sync_opts= lrintf(sync_ipts);

---

>             ost->sync_opts= lrintf(sync_ipts);

1168c1003,1014

<     formatted_picture = in_picture;

---

>     if (ost->video_crop) {

>         if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {

>             fprintf(stderr, "error cropping picture/n");

>             if (exit_on_error)

>                 av_exit(1);

>             return;

>         }

>         formatted_picture = &picture_crop_temp;

>     } else {

>         formatted_picture = in_picture;

>     }

1171a1018,1029

>     if (ost->video_pad) {

>         final_picture = &ost->pict_tmp;

>         if (ost->video_resample) {

>             if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {

>                 fprintf(stderr, "error padding picture/n");

>                 if (exit_on_error)

>                     av_exit(1);

>                 return;

>             }

>             resampling_dst = &picture_pad_temp;

>         }

>     }

1173,1174c1031,1032

<     if (   ost->resample_height != ist->st->codec->height

<         || ost->resample_width  != ist->st->codec->width

---

>     if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))

>         || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))

1179c1037

<             ffmpeg_exit(1);

---

>             av_exit(1);

1182d1039

< #if !CONFIG_AVFILTER

1186,1187c1043,1044

<         if(  ost->resample_height != ist->st->codec->height

<           || ost->resample_width  != ist->st->codec->width

---

>         if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))

>           || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))

1189a1047,1067

>             /* keep bands proportional to the frame size */

>             topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;

>             bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;

>             leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;

>             rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;

>             /* sanity check to ensure no bad band sizes sneak in */

>             assert(topBand    <= INT_MAX && topBand    >= 0);

>             assert(bottomBand <= INT_MAX && bottomBand >= 0);

>             assert(leftBand   <= INT_MAX && leftBand   >= 0);

>             assert(rightBand  <= INT_MAX && rightBand  >= 0);

>             ost->topBand    = topBand;

>             ost->bottomBand = bottomBand;

>             ost->leftBand   = leftBand;

>             ost->rightBand  = rightBand;

>             ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);

>             ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);

>             ost->resample_pix_fmt= ist->st->codec->pix_fmt;

1194,1195c1072,1073

<                 ist->st->codec->width,

<                 ist->st->codec->height,

---

>                 ist->st->codec->width  - (ost->leftBand + ost->rightBand),

>                 ist->st->codec->height - (ost->topBand  + ost->bottomBand),

1197,1198c1075,1076

<                 ost->st->codec->width,

<                 ost->st->codec->height,

---

>                 ost->st->codec->width  - (ost->padleft  + ost->padright),

>                 ost->st->codec->height - (ost->padtop   + ost->padbottom),

1203c1081

<                 ffmpeg_exit(1);

---

>                 av_exit(1);

1209c1087,1092

< #endif

---

>     if (ost->video_pad) {

>         av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,

>                 enc->height, enc->width, enc->pix_fmt,

>                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);

>     }

1228c1111

<             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

---

>             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

1246c1129,1132

<             big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;

---

>             if (same_quality) {

>                 big_picture.quality = ist->st->quality;

>             }else

>                 big_picture.quality = ost->st->quality;

1253,1257d1138

<             if (ost->forced_kf_index < ost->forced_kf_count &&

<                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {

<                 big_picture.pict_type = FF_I_TYPE;

<                 ost->forced_kf_index++;

<             }

1263c1144

<                 ffmpeg_exit(1);

---

>                 av_exit(1);

1277c1158

<                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

---

>                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

1309c1190

<             ffmpeg_exit(1);

---

>             av_exit(1);

1470,1474c1351

<     int64_t pkt_pts = AV_NOPTS_VALUE;

< #if CONFIG_AVFILTER

<     int frame_available;

< #endif

---

>     int got_subtitle;

1476c1353

<     int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;

---

>     int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;

1493,1494d1369

<     if(pkt->pts != AV_NOPTS_VALUE)

<         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);

1547,1548d1421

<                     ist->st->codec->reordered_opaque = pkt_pts;

<                     pkt_pts = AV_NOPTS_VALUE;

1559d1431

<                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);

1570c1442

<                                                &subtitle, &got_picture, &avpkt);

---

>                                                &subtitle, &got_subtitle, &avpkt);

1573c1445

<                 if (!got_picture) {

---

>                 if (!got_subtitle) {

1607,1615d1478

< #if CONFIG_AVFILTER

<         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {

<             // add it to be filtered

<             av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,

<                                      ist->pts,

<                                      ist->st->codec->sample_aspect_ratio);

<         }

< #endif

1637,1640c1500

< #if CONFIG_AVFILTER

<         frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||

<             !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);

< #endif

---

1644,1651d1503

< #if CONFIG_AVFILTER

<         while (frame_available) {

<             AVRational ist_pts_tb;

<             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)

<                 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);

<             if (ist->picref)

<                 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);

< #endif

1663c1515

<                         av_assert0(ist->decoding_needed);

---

>                         assert(ist->decoding_needed);

1669,1672d1520

< #if CONFIG_AVFILTER

<                             if (ist->picref->video)

<                                 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;

< #endif

1735c1583

<                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);

---

>                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);

1742,1749d1589

< #if CONFIG_AVFILTER

<             frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&

<                               ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);

<             if(ist->picref)

<                 avfilter_unref_buffer(ist->picref);

<         }

< #endif

1753c1593,1601

<             avsubtitle_free(subtitle_to_free);

---

>             if (subtitle_to_free->rects != NULL) {

>                 for (i = 0; i < subtitle_to_free->num_rects; i++) {

>                     av_freep(&subtitle_to_free->rects[i]->pict.data[0]);

>                     av_freep(&subtitle_to_free->rects[i]->pict.data[1]);

>                     av_freep(&subtitle_to_free->rects[i]);

>                 }

>                 av_freep(&subtitle_to_free->rects);

>             }

>             subtitle_to_free->num_rects = 0;

1785c1633

<                                 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;

---

>                                 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;

1788c1636

<                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);

---

>                                 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);

1793,1795c1641,1643

<                                     if (allocated_audio_buf_size < frame_bytes)

<                                         ffmpeg_exit(1);

<                                     memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);

---

>                                     if (samples_size < frame_bytes)

>                                         av_exit(1);

>                                     memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);

1798c1646

<                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);

---

>                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);

1808c1656

<                                 ffmpeg_exit(1);

---

>                                 av_exit(1);

1817c1665

<                                 ffmpeg_exit(1);

---

>                                 av_exit(1);

1836c1684

<                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);

---

>                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

1886,1888c1734,1735

<         if (metadata_chapters_autocopy)

<             while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))

<                 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);

---

>         while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))

>             av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);

1899,1921d1745

< static void parse_forced_key_frames(char *kf, AVOutputStream *ost,

<                                     AVCodecContext *avctx)

< {

<     char *p;

<     int n = 1, i;

<     int64_t t;

<     for (p = kf; *p; p++)

<         if (*p == ',')

<             n++;

<     ost->forced_kf_count = n;

<     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);

<     if (!ost->forced_kf_pts) {

<         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array./n");

<         ffmpeg_exit(1);

<     }

<     for (i = 0; i < n; i++) {

<         p = i ? strchr(p, ',') + 1 : kf;

<         t = parse_time_or_die("force_key_frames", p, 1);

<         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);

<     }

< }

1925,1929c1749,1753

< static int transcode(AVFormatContext **output_files,

<                      int nb_output_files,

<                      AVFormatContext **input_files,

<                      int nb_input_files,

<                      AVStreamMap *stream_maps, int nb_stream_maps)

---

> static int av_transcode(AVFormatContext **output_files,

>                         int nb_output_files,

>                         AVFormatContext **input_files,

>                         int nb_input_files,

>                         AVStreamMap *stream_maps, int nb_stream_maps)

1988c1812

<         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {

---

>         if (!os->nb_streams) {

1991,1992c1815

<             ret = AVERROR(EINVAL);

<             goto fail;

---

>             av_exit(1);

1998,1999c1821

<         ret = AVERROR(EINVAL);

<         goto fail;

---

>         av_exit(1);

2010,2011c1832

<             ret = AVERROR(EINVAL);

<             goto fail;

---

>             av_exit(1);

2018,2019c1839

<             ret = AVERROR(EINVAL);

<             goto fail;

---

>             av_exit(1);

2025a1846,1852

>     for(i=0;i<nb_ostreams;i++) {

>         ost = av_mallocz(sizeof(AVOutputStream));

>         if (!ost)

>             goto fail;

>         ost_table[i] = ost;

>     }

2031c1858,1860

<             ost = ost_table[n] = output_streams_for_file[k][i];

---

>             ost = ost_table[n];

>             ost->file_index = k;

>             ost->index = i;

2044c1873

<                     ffmpeg_exit(1);

---

>                     av_exit(1);

2049,2064c1878,1894

<                 /* get corresponding input stream index : we select the first one with the right type */

<                 found = 0;

<                 for(j=0;j<nb_istreams;j++) {

<                     int skip=0;

<                     ist = ist_table[j];

<                     if(opt_programid){

<                         int pi,si;

<                         AVFormatContext *f= input_files[ ist->file_index ];

<                         skip=1;

<                         for(pi=0; pi<f->nb_programs; pi++){

<                             AVProgram *p= f->programs[pi];

<                             if(p->id == opt_programid)

<                                 for(si=0; si<p->nb_stream_indexes; si++){

<                                     if(f->streams[ p->stream_index[si] ] == ist->st)

<                                         skip=0;

<                                 }

---

>                     /* get corresponding input stream index : we select the first one with the right type */

>                     found = 0;

>                     for(j=0;j<nb_istreams;j++) {

>                         int skip=0;

>                         ist = ist_table[j];

>                         if(opt_programid){

>                             int pi,si;

>                             AVFormatContext *f= input_files[ ist->file_index ];

>                             skip=1;

>                             for(pi=0; pi<f->nb_programs; pi++){

>                                 AVProgram *p= f->programs[pi];

>                                 if(p->id == opt_programid)

>                                     for(si=0; si<p->nb_stream_indexes; si++){

>                                         if(f->streams[ p->stream_index[si] ] == ist->st)

>                                             skip=0;

>                                     }

>                             }

2066,2072c1896,1902

<                     }

<                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&

<                         ist->st->codec->codec_type == ost->st->codec->codec_type) {

<                         if(best_nb_frames < ist->st->codec_info_nb_frames){

<                             best_nb_frames= ist->st->codec_info_nb_frames;

<                             ost->source_index = j;

<                             found = 1;

---

>                         if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&

>                             ist->st->codec->codec_type == ost->st->codec->codec_type) {

>                             if(best_nb_frames < ist->st->codec_info_nb_frames){

>                                 best_nb_frames= ist->st->codec_info_nb_frames;

>                                 ost->source_index = j;

>                                 found = 1;

>                             }

2075d1904

<                 }

2094c1923

<                         ffmpeg_exit(1);

---

>                         av_exit(1);

2116,2119c1945,1947

<         if (metadata_streams_autocopy)

<             while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {

<                 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);

<             }

---

>         while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {

>             av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);

>         }

2126,2130d1953

<             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;

<             if (extra_size > INT_MAX)

<                 goto fail;

2143,2148c1966

<             codec->rc_max_rate    = icodec->rc_max_rate;

<             codec->rc_buffer_size = icodec->rc_buffer_size;

<             codec->extradata= av_mallocz(extra_size);

<             if (!codec->extradata)

<                 goto fail;

<             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);

---

>             codec->extradata= icodec->extradata;

2153,2154d1970

<                 av_reduce(&codec->time_base.num, &codec->time_base.den,

<                           codec->time_base.num, codec->time_base.den, INT_MAX);

2161c1977

<                     ffmpeg_exit(1);

---

>                     av_exit(1);

2192c2008

<                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);

---

>                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);

2197,2199d2012

<                 ost->resample_sample_fmt  = icodec->sample_fmt;

<                 ost->resample_sample_rate = icodec->sample_rate;

<                 ost->resample_channels    = icodec->channels;

2204c2017

<                     ffmpeg_exit(1);

---

>                     av_exit(1);

2206,2207c2019,2026

<                 ost->video_resample = (codec->width != icodec->width   ||

<                                        codec->height != icodec->height ||

---

>                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);

>                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);

>                 ost->video_resample = ((codec->width != icodec->width -

>                                 (frame_leftBand + frame_rightBand) +

>                                 (frame_padleft + frame_padright)) ||

>                         (codec->height != icodec->height -

>                                 (frame_topBand  + frame_bottomBand) +

>                                 (frame_padtop + frame_padbottom)) ||

2208a2028,2045

>                 if (ost->video_crop) {

>                     ost->topBand    = ost->original_topBand    = frame_topBand;

>                     ost->bottomBand = ost->original_bottomBand = frame_bottomBand;

>                     ost->leftBand   = ost->original_leftBand   = frame_leftBand;

>                     ost->rightBand  = ost->original_rightBand  = frame_rightBand;

>                 }

>                 if (ost->video_pad) {

>                     ost->padtop = frame_padtop;

>                     ost->padleft = frame_padleft;

>                     ost->padbottom = frame_padbottom;

>                     ost->padright = frame_padright;

>                     if (!ost->video_resample) {

>                         avcodec_get_frame_defaults(&ost->pict_tmp);

>                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,

>                                          codec->width, codec->height))

>                             goto fail;

>                     }

>                 }

2214c2051

<                         ffmpeg_exit(1);

---

>                         av_exit(1);

2218,2219c2055,2056

<                         icodec->width,

<                         icodec->height,

---

>                             icodec->width - (frame_leftBand + frame_rightBand),

>                             icodec->height - (frame_topBand + frame_bottomBand),

2221,2222c2058,2059

<                             codec->width,

<                             codec->height,

---

>                             codec->width - (frame_padleft + frame_padright),

>                             codec->height - (frame_padtop + frame_padbottom),

2227c2064

<                         ffmpeg_exit(1);

---

>                         av_exit(1);

2230d2066

< #if !CONFIG_AVFILTER

2233c2069

< #endif

---

2236,2237c2072,2073

<                 ost->resample_height = icodec->height;

<                 ost->resample_width  = icodec->width;

---

>                 ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);

>                 ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);

2241,2247d2076

< #if CONFIG_AVFILTER

<                 if (configure_filters(ist, ost)) {

<                     fprintf(stderr, "Error opening filters!/n");

<                     exit(1);

<                 }

< #endif

2270c2099

<                         ffmpeg_exit(1);

---

>                         av_exit(1);

2278c2107

<                         ffmpeg_exit(1);

---

>                         av_exit(1);

2303,2304c2132

<             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;

<             AVCodecContext *dec = ist_table[ost->source_index]->st->codec;

---

>             AVCodec *codec = output_codecs[i];

2313,2321d2140

<             if (dec->subtitle_header) {

<                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);

<                 if (!ost->st->codec->subtitle_header) {

<                     ret = AVERROR(ENOMEM);

<                     goto dump_format;

<                 }

<                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);

<                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;

<             }

2336c2155

<             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;

---

>             AVCodec *codec = input_codecs[i];

2363d2181

<         init_pts_correction(&ist->pts_ctx);

2369,2370c2187,2188

<         AVFormatContext *files[2];

<         AVMetadata      **meta[2];

---

>         AVFormatContext *out_file;

>         AVFormatContext *in_file;

2372,2390d2189

<         int j;

< #define METADATA_CHECK_INDEX(index, nb_elems, desc)/

<         if ((index) < 0 || (index) >= (nb_elems)) {/

<             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps/n",/

<                      (desc), (index));/

<             ret = AVERROR(EINVAL);/

<             goto dump_format;/

<         }

<         int out_file_index = meta_data_maps[i][0].file;

<         int in_file_index = meta_data_maps[i][1].file;

<         if (in_file_index < 0 || out_file_index < 0)

<             continue;

<         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")

<         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")

<         files[0] = output_files[out_file_index];

<         files[1] = input_files[in_file_index];

2392,2436c2191,2195

<         for (j = 0; j < 2; j++) {

<             AVMetaDataMap *map = &meta_data_maps[i][j];

<             switch (map->type) {

<             case 'g':

<                 meta[j] = &files[j]->metadata;

<                 break;

<             case 's':

<                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")

<                 meta[j] = &files[j]->streams[map->index]->metadata;

<                 break;

<             case 'c':

<                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")

<                 meta[j] = &files[j]->chapters[map->index]->metadata;

<                 break;

<             case 'p':

<                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")

<                 meta[j] = &files[j]->programs[map->index]->metadata;

<                 break;

<             }

<         }

<         mtag=NULL;

<         while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))

<             av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);

<     }

<     /* copy global metadata by default */

<     if (metadata_global_autocopy) {

<         AVMetadataTag *t = NULL;

<         while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))

<             for (i = 0; i < nb_output_files; i++)

<                 av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);

<     }

<     /* copy chapters according to chapter maps */

<     for (i = 0; i < nb_chapter_maps; i++) {

<         int infile  = chapter_maps[i].in_file;

<         int outfile = chapter_maps[i].out_file;

<         if (infile < 0 || outfile < 0)

<             continue;

<         if (infile >= nb_input_files) {

<             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping./n", infile);

---

>         int out_file_index = meta_data_maps[i].out_file;

>         int in_file_index = meta_data_maps[i].in_file;

>         if (out_file_index < 0 || out_file_index >= nb_output_files) {

>             snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",

>                      out_file_index, out_file_index, in_file_index);

2440,2441c2199,2201

<         if (outfile >= nb_output_files) {

<             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping./n",outfile);

---

>         if (in_file_index < 0 || in_file_index >= nb_input_files) {

>             snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",

>                      in_file_index, out_file_index, in_file_index);

2445c2205,2214

<         copy_chapters(infile, outfile);

---

>         out_file = output_files[out_file_index];

>         in_file = input_files[in_file_index];

>         mtag=NULL;

>         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))

>             av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);

>         av_metadata_conv(out_file, out_file->oformat->metadata_conv,

>                                     in_file->iformat->metadata_conv);

2449,2452c2218,2220

<     if (!nb_chapter_maps)

<         for (i = 0; i < nb_input_files; i++) {

<             if (!input_files[i]->nb_chapters)

<                 continue;

---

>     for (i = 0; i < nb_input_files; i++) {

>         if (!input_files[i]->nb_chapters)

>             continue;

2454,2458c2222,2225

<             for (j = 0; j < nb_output_files; j++)

<                 if ((ret = copy_chapters(i, j)) < 0)

<                     goto dump_format;

<             break;

<         }

---

>         for (j = 0; j < nb_output_files; j++)

>             if ((ret = copy_chapters(i, j)) < 0)

>                 goto dump_format;

>     }

2573c2340

<         if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))

---

>         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))

2612,2613c2379

<         if (pkt.stream_index < nb_input_files_ts_scale[file_index]

<             && input_files_ts_scale[file_index][pkt.stream_index]){

---

>         if(input_files_ts_scale[file_index][pkt.stream_index]){

2649c2415

<                 ffmpeg_exit(1);

---

>                 av_exit(1);

2696,2701d2461

< #if CONFIG_AVFILTER

<     if (graph) {

<         avfilter_graph_free(graph);

<         av_freep(&graph);

<     }

< #endif

2721,2722d2480

<                 if (ost->st->stream_copy)

<                     av_freep(&ost->st->codec->extradata);

2729d2486

<                 av_freep(&ost->st->codec->subtitle_header);

2731d2487

<                 av_free(ost->forced_kf_pts);

2747a2504,2511

>     /* compatibility stuff for pgmyuv */

>     if (!strcmp(arg, "pgmyuv")) {

>         pgmyuv_compatibility_hack=1;

> //        opt_image_format(arg);

>         arg = "image2";

>         fprintf(stderr, "pgmyuv format is deprecated, use image2/n");

>     }

2770c2534

<     if (av_parse_video_rate(&frame_rate, arg) < 0) {

---

>     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {

2772c2536

<         ffmpeg_exit(1);

---

>         av_exit(1);

2789c2553

< static int opt_frame_crop(const char *opt, const char *arg)

---

> static void opt_frame_crop_top(const char *arg)

2791,2792c2555,2606

<     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead/n", opt);

<     return AVERROR(EINVAL);

---

>     frame_topBand = atoi(arg);

>     if (frame_topBand < 0) {

>         fprintf(stderr, "Incorrect top crop size/n");

>         av_exit(1);

>     }

>     if ((frame_topBand) >= frame_height){

>         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

>         av_exit(1);

>     }

>     frame_height -= frame_topBand;

> }

> static void opt_frame_crop_bottom(const char *arg)

> {

>     frame_bottomBand = atoi(arg);

>     if (frame_bottomBand < 0) {

>         fprintf(stderr, "Incorrect bottom crop size/n");

>         av_exit(1);

>     }

>     if ((frame_bottomBand) >= frame_height){

>         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

>         av_exit(1);

>     }

>     frame_height -= frame_bottomBand;

> }

> static void opt_frame_crop_left(const char *arg)

> {

>     frame_leftBand = atoi(arg);

>     if (frame_leftBand < 0) {

>         fprintf(stderr, "Incorrect left crop size/n");

>         av_exit(1);

>     }

>     if ((frame_leftBand) >= frame_width){

>         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

>         av_exit(1);

>     }

>     frame_width -= frame_leftBand;

> }

> static void opt_frame_crop_right(const char *arg)

> {

>     frame_rightBand = atoi(arg);

>     if (frame_rightBand < 0) {

>         fprintf(stderr, "Incorrect right crop size/n");

>         av_exit(1);

>     }

>     if ((frame_rightBand) >= frame_width){

>         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

>         av_exit(1);

>     }

>     frame_width -= frame_rightBand;

2797c2611

<     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {

---

>     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {

2799c2613

<         ffmpeg_exit(1);

---

>         av_exit(1);

2803,2805c2617,2667

< static int opt_pad(const char *opt, const char *arg) {

<     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead/n", opt);

<     return -1;

---

> static void opt_pad_color(const char *arg) {

>     /* Input is expected to be six hex digits similar to

>        how colors are expressed in html tags (but without the #) */

>     int rgb = strtol(arg, NULL, 16);

>     int r,g,b;

>     r = (rgb >> 16);

>     g = ((rgb >> 8) & 255);

>     b = (rgb & 255);

>     padcolor[0] = RGB_TO_Y(r,g,b);

>     padcolor[1] = RGB_TO_U(r,g,b,0);

>     padcolor[2] = RGB_TO_V(r,g,b,0);

> }

> static void opt_frame_pad_top(const char *arg)

> {

>     frame_padtop = atoi(arg);

>     if (frame_padtop < 0) {

>         fprintf(stderr, "Incorrect top pad size/n");

>         av_exit(1);

>     }

> }

> static void opt_frame_pad_bottom(const char *arg)

> {

>     frame_padbottom = atoi(arg);

>     if (frame_padbottom < 0) {

>         fprintf(stderr, "Incorrect bottom pad size/n");

>         av_exit(1);

>     }

> }

> static void opt_frame_pad_left(const char *arg)

> {

>     frame_padleft = atoi(arg);

>     if (frame_padleft < 0) {

>         fprintf(stderr, "Incorrect left pad size/n");

>         av_exit(1);

>     }

> }

> static void opt_frame_pad_right(const char *arg)

> {

>     frame_padright = atoi(arg);

>     if (frame_padright < 0) {

>         fprintf(stderr, "Incorrect right pad size/n");

>         av_exit(1);

>     }

2814c2676

<             ffmpeg_exit(1);

---

>             av_exit(1);

2818c2680

<         ffmpeg_exit(0);

---

>         av_exit(0);

2841c2703

<         ffmpeg_exit(1);

---

>         av_exit(1);

2852c2714

<         ffmpeg_exit(1);

---

>         av_exit(1);

2856c2718,2721

<     av_metadata_set2(&metadata, arg, mid, 0);

---

>     metadata_count++;

>     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);

>     metadata[metadata_count-1].key  = av_strdup(arg);

>     metadata[metadata_count-1].value= av_strdup(mid);

2867c2732

<         ffmpeg_exit(1);

---

>         av_exit(1);

2889c2754

<         audio_sample_fmt = av_get_sample_fmt(arg);

---

>         audio_sample_fmt = avcodec_get_sample_fmt(arg);

2891,2892c2756,2757

<         list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);

<         ffmpeg_exit(0);

---

>         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);

>         av_exit(0);

2933a2799,2816

> static void opt_audio_tag(const char *arg)

> {

>     char *tail;

>     audio_codec_tag= strtol(arg, &tail, 0);

>     if(!tail || *tail)

>         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);

> }

> static void opt_video_tag(const char *arg)

> {

>     char *tail;

>     video_codec_tag= strtol(arg, &tail, 0);

>     if(!tail || *tail)

>         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);

> }

2944c2827

< static int opt_codec_tag(const char *opt, const char *arg)

---

> static void opt_subtitle_tag(const char *arg)

2947,2957c2830

<     uint32_t *codec_tag;

<     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :

<                 !strcmp(opt, "vtag") ? &video_codec_tag :

<                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;

<     if (!codec_tag)

<         return -1;

<     *codec_tag = strtol(arg, &tail, 0);

<     if (!tail || *tail)

<         *codec_tag = AV_RL32(arg);

---

>     subtitle_codec_tag= strtol(arg, &tail, 0);

2959c2832,2833

<     return 0;

---

>     if(!tail || *tail)

>         subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);

2967,2968c2841

<     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);

<     m = &stream_maps[nb_stream_maps-1];

---

>     m = &stream_maps[nb_stream_maps++];

2987,3007d2859

< static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)

< {

<     *endptr = arg;

<     if (*arg == ',') {

<         *type = *(++arg);

<         switch (*arg) {

<         case 'g':

<             break;

<         case 's':

<         case 'c':

<         case 'p':

<             *index = strtol(++arg, endptr, 0);

<             break;

<         default:

<             fprintf(stderr, "Invalid metadata type %c./n", *arg);

<             ffmpeg_exit(1);

<         }

<     } else

<         *type = 'g';

< }

3010c2862

<     AVMetaDataMap *m, *m1;

---

>     AVMetaDataMap *m;

3013,3014c2865

<     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),

<                                 &nb_meta_data_maps, nb_meta_data_maps + 1);

---

>     m = &meta_data_maps[nb_meta_data_maps++];

3016,3018c2867

<     m = &meta_data_maps[nb_meta_data_maps - 1][0];

<     m->file = strtol(arg, &p, 0);

<     parse_meta_type(p, &m->type, &m->index, &p);

---

>     m->out_file = strtol(arg, &p, 0);

3022,3046c2871

<     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];

<     m1->file = strtol(p, &p, 0);

<     parse_meta_type(p, &m1->type, &m1->index, &p);

<     if (m->type == 'g' || m1->type == 'g')

<         metadata_global_autocopy = 0;

<     if (m->type == 's' || m1->type == 's')

<         metadata_streams_autocopy = 0;

<     if (m->type == 'c' || m1->type == 'c')

<         metadata_chapters_autocopy = 0;

< }

< static void opt_map_chapters(const char *arg)

< {

<     AVChapterMap *c;

<     char *p;

<     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,

<                               nb_chapter_maps + 1);

<     c = &chapter_maps[nb_chapter_maps - 1];

<     c->out_file = strtol(arg, &p, 0);

<     if (*p)

<         p++;

<     c->in_file = strtol(p, &p, 0);

---

>     m->in_file = strtol(p, &p, 0);

3061c2886

<         ffmpeg_exit(1);

---

>         av_exit(1);

3063d2887

<     input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);

3079c2903

< static int opt_recording_timestamp(const char *opt, const char *arg)

---

> static int opt_rec_timestamp(const char *opt, const char *arg)

3081c2905

<     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;

---

>     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;

3103c2927

<         ffmpeg_exit(1);

---

>         av_exit(1);

3107c2931

<         ffmpeg_exit(1);

---

>         av_exit(1);

3120c2944

<         ffmpeg_exit(1);

---

>         av_exit(1);

3136c2960

<             ffmpeg_exit(1);

---

>             av_exit(1);

3151c2975

<         ffmpeg_exit(1);

---

>         av_exit(1);

3160,3161c2984,2985

<     ap->width = frame_width;

<     ap->height = frame_height;

---

>     ap->width = frame_width + frame_padleft + frame_padright;

>     ap->height = frame_height + frame_padtop + frame_padbottom;

3167c2991

<     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);

---

>     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);

3179a3004,3006

>     if(pgmyuv_compatibility_hack)

>         ic->video_codec_id= CODEC_ID_PGMYUV;

3184c3011

<         ffmpeg_exit(1);

---

>         av_exit(1);

3205c3032

<             ffmpeg_exit(1);

---

>             av_exit(1);

3217,3218c3044

<         av_close_input_file(ic);

<         ffmpeg_exit(1);

---

>         av_exit(1);

3240,3243c3066,3068

<         AVCodecContext *dec = st->codec;

<         avcodec_thread_init(dec, thread_count);

<         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);

<         switch (dec->codec_type) {

---

>         AVCodecContext *enc = st->codec;

>         avcodec_thread_init(enc, thread_count);

>         switch(enc->codec_type) {

3245,3251c3070,3076

<             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);

<             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);

<             //fprintf(stderr, "/nInput Audio channels: %d", dec->channels);

<             channel_layout    = dec->channel_layout;

<             audio_channels    = dec->channels;

<             audio_sample_rate = dec->sample_rate;

<             audio_sample_fmt  = dec->sample_fmt;

---

>             set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);

>             //fprintf(stderr, "/nInput Audio channels: %d", enc->channels);

>             channel_layout = enc->channel_layout;

>             audio_channels = enc->channels;

>             audio_sample_rate = enc->sample_rate;

>             audio_sample_fmt = enc->sample_fmt;

>             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);

3254,3258d3078

<             /* Note that av_find_stream_info can add more streams, and we

<              * currently have no chance of setting up lowres decoding

<              * early enough for them. */

<             if (dec->lowres)

<                 audio_sample_rate >>= dec->lowres;

3261,3264c3081,3083

<             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);

<             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);

<             frame_height = dec->height;

<             frame_width  = dec->width;

---

>             set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);

>             frame_height = enc->height;

>             frame_width = enc->width;

3268,3270c3087,3089

<                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);

<             frame_aspect_ratio *= (float) dec->width / dec->height;

<             frame_pix_fmt = dec->pix_fmt;

---

>                 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);

>             frame_aspect_ratio *= (float) enc->width / enc->height;

>             frame_pix_fmt = enc->pix_fmt;

3273,3278c3092,3095

<             if (dec->lowres) {

<                 dec->flags |= CODEC_FLAG_EMU_EDGE;

<                 frame_height >>= dec->lowres;

<                 frame_width  >>= dec->lowres;

<                 dec->height = frame_height;

<                 dec->width  = frame_width;

---

>             if(enc->lowres) {

>                 enc->flags |= CODEC_FLAG_EMU_EDGE;

>                 frame_height >>= enc->lowres;

>                 frame_width  >>= enc->lowres;

3281c3098

<                 dec->debug |= FF_DEBUG_MV;

---

>                 enc->debug |= FF_DEBUG_MV;

3283c3100

<             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {

---

>             if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {

3287c3104

<                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,

---

>                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,

3294a3112

>             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);

3303c3121

<             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);

---

>             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);

3308a3127

>             nb_icodecs++;

3367c3186

< static void new_video_stream(AVFormatContext *oc, int file_idx)

---

> static void new_video_stream(AVFormatContext *oc)

3370d3188

<     AVOutputStream *ost;

3373d3190

<     AVCodec *codec= NULL;

3375c3192

<     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

---

>     st = av_new_stream(oc, oc->nb_streams);

3378c3195

<         ffmpeg_exit(1);

---

>         av_exit(1);

3380,3396c3197,3198

<     ost = new_output_stream(oc, file_idx);

<     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);

<     if(!video_stream_copy){

<         if (video_codec_name) {

<             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,

<                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);

<             codec = avcodec_find_encoder_by_name(video_codec_name);

<             output_codecs[nb_output_codecs-1] = codec;

<         } else {

<             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);

<             codec = avcodec_find_encoder(codec_id);

<         }

<     }

<     avcodec_get_context_defaults3(st->codec, codec);

<     ost->bitstream_filters = video_bitstream_filters;

---

>     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);

>     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;

3423a3226

>         AVCodec *codec;

3425a3229,3238

>         if (video_codec_name) {

>             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,

>                                          video_enc->strict_std_compliance);

>             codec = avcodec_find_encoder_by_name(video_codec_name);

>             output_codecs[nb_ocodecs] = codec;

>         } else {

>             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);

>             codec = avcodec_find_encoder(codec_id);

>         }

3427c3240,3241

<         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);

---

>         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);

3434,3435c3248,3249

<         video_enc->width = frame_width;

<         video_enc->height = frame_height;

---

>         video_enc->width = frame_width + frame_padright + frame_padleft;

>         video_enc->height = frame_height + frame_padtop + frame_padbottom;

3461c3275

<                 ffmpeg_exit(1);

---

>                 av_exit(1);

3496,3498d3309

<         if (forced_key_frames)

<             parse_forced_key_frames(forced_key_frames, ost, video_enc);

3499a3311

>     nb_ocodecs++;

3508d3319

<     av_freep(&forced_key_frames);

3513c3324

< static void new_audio_stream(AVFormatContext *oc, int file_idx)

---

> static void new_audio_stream(AVFormatContext *oc)

3516,3517d3326

<     AVOutputStream *ost;

<     AVCodec *codec= NULL;

3521c3330

<     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

---

>     st = av_new_stream(oc, oc->nb_streams);

3524,3538c3333

<         ffmpeg_exit(1);

<     }

<     ost = new_output_stream(oc, file_idx);

<     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);

<     if(!audio_stream_copy){

<         if (audio_codec_name) {

<             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,

<                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);

<             codec = avcodec_find_encoder_by_name(audio_codec_name);

<             output_codecs[nb_output_codecs-1] = codec;

<         } else {

<             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);

<             codec = avcodec_find_encoder(codec_id);

<         }

---

>         av_exit(1);

3539a3335

>     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);

3541,3543c3337

<     avcodec_get_context_defaults3(st->codec, codec);

<     ost->bitstream_filters = audio_bitstream_filters;

---

>     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;

3562a3357,3369

>         AVCodec *codec;

>         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);

>         if (audio_codec_name) {

>             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,

>                                          audio_enc->strict_std_compliance);

>             codec = avcodec_find_encoder_by_name(audio_codec_name);

>             output_codecs[nb_ocodecs] = codec;

>         } else {

>             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);

>             codec = avcodec_find_encoder(codec_id);

>         }

3564d3370

<         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);

3574c3380

<         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)

---

>         if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)

3578a3385

>     nb_ocodecs++;

3591c3398

< static void new_subtitle_stream(AVFormatContext *oc, int file_idx)

---

> static void new_subtitle_stream(AVFormatContext *oc)

3594,3595d3400

<     AVOutputStream *ost;

<     AVCodec *codec=NULL;

3597d3401

<     enum CodecID codec_id;

3599c3403

<     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

---

>     st = av_new_stream(oc, oc->nb_streams);

3602c3406

<         ffmpeg_exit(1);

---

>         av_exit(1);

3604,3617c3408

<     ost = new_output_stream(oc, file_idx);

<     subtitle_enc = st->codec;

<     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);

<     if(!subtitle_stream_copy){

<         if (subtitle_codec_name) {

<             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,

<                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);

<             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);

<         } else {

<             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);

<             codec = avcodec_find_encoder(codec_id);

<         }

<     }

<     avcodec_get_context_defaults3(st->codec, codec);

---

>     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);

3619c3410

<     ost->bitstream_filters = subtitle_bitstream_filters;

---

>     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;

3621a3413

>     subtitle_enc = st->codec;

3627,3630d3418

<     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {

<         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

<         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;

<     }

3634,3635c3422,3425

<         subtitle_enc->codec_id = codec_id;

<         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);

---

>         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);

>         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,

>                                                    subtitle_enc->strict_std_compliance);

>         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);

3636a3427

>     nb_ocodecs++;

3648c3439

< static int opt_new_stream(const char *opt, const char *arg)

---

> static void opt_new_audio_stream(void)

3651d3441

<     int file_idx = nb_output_files - 1;

3654c3444

<         ffmpeg_exit(1);

---

>         av_exit(1);

3656,3662c3446,3447

<     oc = output_files[file_idx];

<     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);

<     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);

<     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);

<     else av_assert0(0);

<     return 0;

---

>     oc = output_files[nb_output_files - 1];

>     new_audio_stream(oc);

3665,3666c3450

< /* arg format is "output-stream-index:streamid-value". */

< static int opt_streamid(const char *opt, const char *arg)

---

> static void opt_new_video_stream(void)

3668,3670c3452,3459

<     int idx;

<     char *p;

<     char idx_str[16];

---

>     AVFormatContext *oc;

>     if (nb_output_files <= 0) {

>         fprintf(stderr, "At least one output file must be specified/n");

>         av_exit(1);

>     }

>     oc = output_files[nb_output_files - 1];

>     new_video_stream(oc);

> }

3672,3685c3461,3469

<     strncpy(idx_str, arg, sizeof(idx_str));

<     idx_str[sizeof(idx_str)-1] = '/0';

<     p = strchr(idx_str, ':');

<     if (!p) {

<         fprintf(stderr,

<                 "Invalid value '%s' for option '%s', required syntax is 'index:value'/n",

<                 arg, opt);

<         ffmpeg_exit(1);

<     }

<     *p++ = '/0';

<     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);

<     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);

<     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);

<     return 0;

---

> static void opt_new_subtitle_stream(void)

> {

>     AVFormatContext *oc;

>     if (nb_output_files <= 0) {

>         fprintf(stderr, "At least one output file must be specified/n");

>         av_exit(1);

>     }

>     oc = output_files[nb_output_files - 1];

>     new_subtitle_stream(oc);

3695d3478

<     AVMetadataTag *tag = NULL;

3703c3486

<         ffmpeg_exit(1);

---

>         av_exit(1);

3710c3493

<             ffmpeg_exit(1);

---

>             av_exit(1);

3718c3501

<             ffmpeg_exit(1);

---

>             av_exit(1);

3732c3515

<             ffmpeg_exit(1);

---

>             av_exit(1);

3753,3765c3536,3564

<         if (audio_disable)    use_audio    = 0;

<         if (video_disable)    use_video    = 0;

<         if (subtitle_disable) use_subtitle = 0;

<         if (use_video)    new_video_stream(oc, nb_output_files);

<         if (use_audio)    new_audio_stream(oc, nb_output_files);

<         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);

<         oc->timestamp = recording_timestamp;

<         while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))

<             av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);

<         av_metadata_free(&metadata);

---

>         if (audio_disable) {

>             use_audio = 0;

>         }

>         if (video_disable) {

>             use_video = 0;

>         }

>         if (subtitle_disable) {

>             use_subtitle = 0;

>         }

>         if (use_video) {

>             new_video_stream(oc);

>         }

>         if (use_audio) {

>             new_audio_stream(oc);

>         }

>         if (use_subtitle) {

>             new_subtitle_stream(oc);

>         }

>         oc->timestamp = rec_timestamp;

>         for(; metadata_count>0; metadata_count--){

>             av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,

>                                             metadata[metadata_count-1].value, 0);

>         }

>         av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);

3774c3573

<             ffmpeg_exit(1);

---

>             av_exit(1);

3790c3589

<                         ffmpeg_exit(1);

---

>                         av_exit(1);

3795c3594

<                     ffmpeg_exit(1);

---

>                     av_exit(1);

3803c3602

<             ffmpeg_exit(1);

---

>             av_exit(1);

3811c3610

<         ffmpeg_exit(1);

---

>         av_exit(1);

3819,3822c3618

<     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);

<     nb_streamid_map = 0;

<     av_freep(&forced_key_frames);

---

>     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);

3832c3628

<         ffmpeg_exit(1);

---

>         av_exit(1);

3884c3680

<             ffmpeg_exit(1);

---

>             av_exit(1);

3901a3698,3706

> /**

>  * Trivial log callback.

>  * Only suitable for show_help and similar since it lacks prefix handling.

>  */

> static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)

> {

>     vfprintf(stdout, fmt, vl);

> }

3911,3913d3715

<     AVCodec *c;

<     AVOutputFormat *oformat = NULL;

3940c3742

<     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

---

>     av_opt_show(avcodec_opts[0], NULL);

3942,3952c3744

<     /* individual codec options */

<     c = NULL;

<     while ((c = av_codec_next(c))) {

<         if (c->priv_class) {

<             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

<             printf("/n");

<         }

<     }

<     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

---

>     av_opt_show(avformat_opts, NULL);

3954,3963c3746

<     /* individual muxer options */

<     while ((oformat = av_oformat_next(oformat))) {

<         if (oformat->priv_class) {

<             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);

<             printf("/n");

<         }

<     }

<     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

---

>     av_opt_show(sws_opts, NULL);

4019c3802

<         ffmpeg_exit(1);

---

>         av_exit(1);

4107c3890

<         ffmpeg_exit(1);

---

>         av_exit(1);

4135c3918

<         ffmpeg_exit(1);

---

>         av_exit(1);

4153,4155c3936,3959

<     char *codec_name = *opt == 'v' ? video_codec_name :

<                        *opt == 'a' ? audio_codec_name :

<                                      subtitle_codec_name;

---

>     int i;

>     const char *base[3]= { getenv("FFMPEG_DATADIR"),

>                            getenv("HOME"),

>                            FFMPEG_DATADIR,

>                          };

>     if (*opt != 'f') {

>         for(i=0; i<3 && !f; i++){

>             if(!base[i])

>                 continue;

>             snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);

>             f= fopen(filename, "r");

>             if(!f){

>                 char *codec_name= *opt == 'v' ? video_codec_name :

>                                   *opt == 'a' ? audio_codec_name :

>                                                 subtitle_codec_name;

>                 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);

>                 f= fopen(filename, "r");

>             }

>         }

>     } else {

>         av_strlcpy(filename, arg, sizeof(filename));

>         f= fopen(filename, "r");

>     }

4157c3961

<     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {

---

>     if(!f){

4159c3963

<         ffmpeg_exit(1);

---

>         av_exit(1);

4169c3973

<             ffmpeg_exit(1);

---

>             av_exit(1);

4179c3983

<             ffmpeg_exit(1);

---

>             av_exit(1);

4195,4196c3999

<     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },

<     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },

---

>     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },

4202c4005

<     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },

---

>     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },

4237,4245c4040,4048

<     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

<     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

<     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

<     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

<     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

<     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

<     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

<     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

<     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },

---

>     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },

>     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },

>     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },

>     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },

>     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },

>     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },

>     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },

>     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },

>     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },

4262,4264d4064

< #if CONFIG_AVFILTER

<     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },

< #endif

4269,4270c4069,4070

<     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },

<     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },

---

>     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },

>     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },

4274,4275d4073

<     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },

<     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },

4285c4083

<     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },

---

>     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },

4287c4085

<     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },

---

>     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },

4294c4092

<     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },

---

>     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },

4296c4094

<     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },

---

>     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },

4321a4120

>     int i;

4324,4325d4122

<     av_log_set_flags(AV_LOG_SKIP_REPEATED);

4330,4332d4126

< #if CONFIG_AVFILTER

<     avfilter_register_all();

< #endif

4340c4134,4138

<     init_opts();

---

>     for(i=0; i<AVMEDIA_TYPE_NB; i++){

>         avcodec_opts[i]= avcodec_alloc_context2(i);

>     }

>     avformat_opts = avformat_alloc_context();

>     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);

4350c4148

<         ffmpeg_exit(1);

---

>         av_exit(1);

4356c4154

<         ffmpeg_exit(1);

---

>         av_exit(1);

4361c4159

<         ffmpeg_exit(1);

---

>         av_exit(1);

4365,4367c4163,4165

<     if (transcode(output_files, nb_output_files, input_files, nb_input_files,

<                   stream_maps, nb_stream_maps) < 0)

<         ffmpeg_exit(1);

---

>     if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,

>                      stream_maps, nb_stream_maps) < 0)

>         av_exit(1);

4374c4172

<     return ffmpeg_exit(0);

---

>     return av_exit(0);

diff ffmpeg/ffmpeg.d ffmpeg-0.6.1/ffmpeg.d

2,7c2,6

<  libavcore/samplefmt.h libavutil/avutil.h libavutil/common.h /

<  libavutil/attributes.h libavutil/avconfig.h libavutil/mem.h /

<  libavutil/avutil.h libavutil/error.h libavutil/mathematics.h /

<  libavutil/rational.h libavutil/intfloat_readwrite.h libavutil/log.h /

<  libavutil/pixfmt.h libavutil/cpu.h libavcore/audioconvert.h /

<  libavcore/avcore.h libavformat/avio.h libavutil/common.h libavutil/log.h /

---

>  libavutil/avutil.h libavutil/common.h libavutil/attributes.h /

>  libavutil/mem.h libavutil/error.h libavutil/avutil.h /

>  libavutil/mathematics.h libavutil/rational.h /

>  libavutil/intfloat_readwrite.h libavutil/log.h libavutil/pixfmt.h /

>  libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

9,18c8,12

<  libavutil/rational.h libavcodec/avcodec.h libavutil/opt.h /

<  libavcodec/audioconvert.h libavcore/audioconvert.h /

<  libavcore/parseutils.h libavcore/samplefmt.h libavutil/colorspace.h /

<  libavutil/fifo.h libavutil/intreadwrite.h libavutil/attributes.h /

<  libavutil/bswap.h libavutil/pixdesc.h libavutil/avstring.h /

<  libavutil/libm.h config.h libavformat/os_support.h /

<  libavfilter/avfilter.h libavcore/avcore.h libavfilter/avfiltergraph.h /

<  libavfilter/avfilter.h libavfilter/vsrc_buffer.h cmdutils.h /

<  libavcodec/avcodec.h libavutil/avassert.h libavutil/avutil.h /

<  libavutil/log.h cmdutils_common_opts.h

---

>  libavutil/rational.h libavcodec/avcodec.h libavcodec/audioconvert.h /

>  libavcodec/colorspace.h libavutil/fifo.h libavutil/pixdesc.h /

>  libavutil/avstring.h libavutil/libm.h config.h libavutil/attributes.h /

>  libavformat/os_support.h cmdutils.h libavcodec/avcodec.h /

>  cmdutils_common_opts.h

Binary files ffmpeg/ffmpeg_g and ffmpeg-0.6.1/ffmpeg_g differ

Binary files ffmpeg/ffmpeg.o and ffmpeg-0.6.1/ffmpeg.o differ

Only in ffmpeg: ffplay

diff ffmpeg/ffplay.c ffmpeg-0.6.1/ffplay.c

22,23d21

< #define _XOPEN_SOURCE 600

29d26

< #include "libavutil/colorspace.h"

31,33d27

< #include "libavcore/imgutils.h"

< #include "libavcore/parseutils.h"

< #include "libavcore/samplefmt.h"

37a32

> #include "libavcodec/colorspace.h"

43a39

> # include "libavfilter/graphparser.h"

86a83

> #if !CONFIG_AVFILTER

87a85

> #endif

111c109

<     AVFilterBufferRef *picref;

---

>     AVFilterPicRef *picref;

166c164

<     enum AVSampleFormat audio_src_fmt;

---

>     enum SampleFormat audio_src_fmt;

175d172

<     FFTSample *rdft_data;

210c207,210

<     PtsCorrectionContext pts_ctx;

---

>     int64_t faulty_pts;

>     int64_t faulty_dts;

>     int64_t last_dts_for_fault_detection;

>     int64_t last_pts_for_fault_detection;

264,265d263

< static int exit_on_keydown;

< static int exit_on_mousedown;

681c679,690

<     avsubtitle_free(&sp->sub);

---

>     int i;

>     for (i = 0; i < sp->sub.num_rects; i++)

>     {

>         av_freep(&sp->sub.rects[i]->pict.data[0]);

>         av_freep(&sp->sub.rects[i]->pict.data[1]);

>         av_freep(&sp->sub.rects[i]);

>     }

>     av_free(sp->sub.rects);

>     memset(&sp->sub, 0, sizeof(AVSubtitle));

697c706

<          if (vp->picref->video->pixel_aspect.num == 0)

---

>          if (vp->picref->pixel_aspect.num == 0)

700c709

<              aspect_ratio = av_q2d(vp->picref->video->pixel_aspect);

---

>              aspect_ratio = av_q2d(vp->picref->pixel_aspect);

913d921

<             av_free(s->rdft_data);

916d923

<             s->rdft_data= av_malloc(4*nb_freq*sizeof(*s->rdft_data));

919c926

<             FFTSample *data[2];

---

>             FFTSample data[2][2*nb_freq];

921d927

<                 data[ch] = s->rdft_data + 2*nb_freq*ch;

936,937c942

<                 int b= (nb_display_channels == 2 ) ? sqrt(w*sqrt(data[1][2*y+0]*data[1][2*y+0]

<                        + data[1][2*y+1]*data[1][2*y+1])) : a;

---

>                 int b= sqrt(w*sqrt(data[1][2*y+0]*data[1][2*y+0] + data[1][2*y+1]*data[1][2*y+1]));

1286c1291

<                    get_master_clock(is), av_diff, FFMAX(is->skip_frames-1, 0), aqsize / 1024, vqsize / 1024, sqsize, is->pts_ctx.num_faulty_dts, is->pts_ctx.num_faulty_pts);

---

>                    get_master_clock(is), av_diff, FFMAX(is->skip_frames-1, 0), aqsize / 1024, vqsize / 1024, sqsize, is->faulty_dts, is->faulty_pts);

1293,1343d1297

< static void stream_close(VideoState *is)

< {

<     VideoPicture *vp;

<     int i;

<     /* XXX: use a special url_shutdown call to abort parse cleanly */

<     is->abort_request = 1;

<     SDL_WaitThread(is->parse_tid, NULL);

<     SDL_WaitThread(is->refresh_tid, NULL);

<     /* free all pictures */

<     for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {

<         vp = &is->pictq[i];

< #if CONFIG_AVFILTER

<         if (vp->picref) {

<             avfilter_unref_buffer(vp->picref);

<             vp->picref = NULL;

<         }

< #endif

<         if (vp->bmp) {

<             SDL_FreeYUVOverlay(vp->bmp);

<             vp->bmp = NULL;

<         }

<     }

<     SDL_DestroyMutex(is->pictq_mutex);

<     SDL_DestroyCond(is->pictq_cond);

<     SDL_DestroyMutex(is->subpq_mutex);

<     SDL_DestroyCond(is->subpq_cond);

< #if !CONFIG_AVFILTER

<     if (is->img_convert_ctx)

<         sws_freeContext(is->img_convert_ctx);

< #endif

<     av_free(is);

< }

< static void do_exit(void)

< {

<     if (cur_stream) {

<         stream_close(cur_stream);

<         cur_stream = NULL;

<     }

<     uninit_opts();

< #if CONFIG_AVFILTER

<     avfilter_uninit();

< #endif

<     if (show_status)

<         printf("/n");

<     SDL_Quit();

<     av_log(NULL, AV_LOG_QUIET, "");

<     exit(0);

< }

1358c1312

<         avfilter_unref_buffer(vp->picref);

---

>         avfilter_unref_pic(vp->picref);

1373,1380d1326

<     if (!vp->bmp || vp->bmp->pitches[0] < vp->width) {

<         /* SDL allocates a buffer smaller than requested if the video

<          * overlay hardware is unable to support the requested size. */

<         fprintf(stderr, "Error: the video system does not support an image/n"

<                         "size of %dx%d pixels. Try using -lowres or -vf /"scale=w:h/"/n"

<                         "to reduce the image size./n", vp->width, vp->height );

<         do_exit();

<     }

1451c1397

<             avfilter_unref_buffer(vp->picref);

---

>             avfilter_unref_pic(vp->picref);

1561c1507,1508

<             init_pts_correction(&is->pts_ctx);

---

>             is->last_dts_for_fault_detection=

>             is->last_pts_for_fault_detection= INT64_MIN;

1578,1587c1525,1531

<             if (decoder_reorder_pts == -1) {

<                 *pts = guess_correct_pts(&is->pts_ctx, frame->reordered_opaque, pkt->dts);

<             } else if (decoder_reorder_pts) {

<                 *pts = frame->reordered_opaque;

<             } else {

<                 *pts = pkt->dts;

<             }

<             if (*pts == AV_NOPTS_VALUE) {

<                 *pts = 0;

---

>             if(pkt->dts != AV_NOPTS_VALUE){

>                 is->faulty_dts += pkt->dts <= is->last_dts_for_fault_detection;

>                 is->last_dts_for_fault_detection= pkt->dts;

>             }

>             if(frame->reordered_opaque != AV_NOPTS_VALUE){

>                 is->faulty_pts += frame->reordered_opaque <= is->last_pts_for_fault_detection;

>                 is->last_pts_for_fault_detection= frame->reordered_opaque;

1590a1535,1544

>         if(   (   decoder_reorder_pts==1

>                || (decoder_reorder_pts && is->faulty_pts<is->faulty_dts)

>                || pkt->dts == AV_NOPTS_VALUE)

>            && frame->reordered_opaque != AV_NOPTS_VALUE)

>             *pts= frame->reordered_opaque;

>         else if(pkt->dts != AV_NOPTS_VALUE)

>             *pts= pkt->dts;

>         else

>             *pts= 0;

1614c1568

<     AVFilterBufferRef  *ref;

---

>     AVFilterPicRef  *ref;

1616c1570

<     int i, w, h, stride[4];

---

>     int w, h, stride[4];

1619,1621d1572

<     if (codec->codec->capabilities & CODEC_CAP_NEG_LINESIZES)

<         perms |= AV_PERM_NEG_LINESIZES;

1639,1643c1590,1594

<     ref->video->w = codec->width;

<     ref->video->h = codec->height;

<     for(i = 0; i < 4; i ++) {

<         unsigned hshift = (i == 1 || i == 2) ? av_pix_fmt_descriptors[ref->format].log2_chroma_w : 0;

<         unsigned vshift = (i == 1 || i == 2) ? av_pix_fmt_descriptors[ref->format].log2_chroma_h : 0;

---

>     ref->w = codec->width;

>     ref->h = codec->height;

>     for(int i = 0; i < 3; i ++) {

>         unsigned hshift = i == 0 ? 0 : av_pix_fmt_descriptors[ref->pic->format].log2_chroma_w;

>         unsigned vshift = i == 0 ? 0 : av_pix_fmt_descriptors[ref->pic->format].log2_chroma_h;

1654,1656d1604

<     pic->reordered_opaque = codec->reordered_opaque;

<     if(codec->pkt) pic->pkt_pts = codec->pkt->pts;

<     else           pic->pkt_pts = AV_NOPTS_VALUE;

1663,1684c1611

<     avfilter_unref_buffer(pic->opaque);

< }

< static int input_reget_buffer(AVCodecContext *codec, AVFrame *pic)

< {

<     AVFilterBufferRef *ref = pic->opaque;

<     if (pic->data[0] == NULL) {

<         pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;

<         return codec->get_buffer(codec, pic);

<     }

<     if ((codec->width != ref->video->w) || (codec->height != ref->video->h) ||

<         (codec->pix_fmt != ref->format)) {

<         av_log(codec, AV_LOG_ERROR, "Picture properties changed./n");

<         return -1;

<     }

<     pic->reordered_opaque = codec->reordered_opaque;

<     if(codec->pkt) pic->pkt_pts = codec->pkt->pts;

<     else           pic->pkt_pts = AV_NOPTS_VALUE;

<     return 0;

---

>     avfilter_unref_pic(pic->opaque);

1700d1626

<         codec->reget_buffer   = input_reget_buffer;

1717c1643

<     AVFilterBufferRef *picref;

---

>     AVFilterPicRef *picref;

1728c1654

<         picref = avfilter_ref_buffer(priv->frame->opaque, ~0);

---

>         picref = avfilter_ref_pic(priv->frame->opaque, ~0);

1731,1733c1657,1658

<         av_image_copy(picref->data, picref->linesize,

<                       priv->frame->data, priv->frame->linesize,

<                       picref->format, link->w, link->h);

---

>         av_picture_copy((AVPicture *)&picref->data, (AVPicture *)priv->frame,

>                         picref->pic->format, link->w, link->h);

1739c1664

<     picref->video->pixel_aspect = priv->is->video_st->codec->sample_aspect_ratio;

---

>     picref->pixel_aspect = priv->is->video_st->codec->sample_aspect_ratio;

1765d1689

<     link->time_base = priv->is->video_st->time_base;

1788a1713,1758

> static void output_end_frame(AVFilterLink *link)

> {

> }

> static int output_query_formats(AVFilterContext *ctx)

> {

>     enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };

>     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));

>     return 0;

> }

> static int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,

>                                     int64_t *pts, int64_t *pos)

> {

>     AVFilterPicRef *pic;

>     if(avfilter_request_frame(ctx->inputs[0]))

>         return -1;

>     if(!(pic = ctx->inputs[0]->cur_pic))

>         return -1;

>     ctx->inputs[0]->cur_pic = NULL;

>     frame->opaque = pic;

>     *pts          = pic->pts;

>     *pos          = pic->pos;

>     memcpy(frame->data,     pic->data,     sizeof(frame->data));

>     memcpy(frame->linesize, pic->linesize, sizeof(frame->linesize));

>     return 1;

> }

> static AVFilter output_filter =

> {

>     .name      = "ffplay_output",

>     .query_formats = output_query_formats,

>     .inputs    = (AVFilterPad[]) {{ .name          = "default",

>                                     .type          = AVMEDIA_TYPE_VIDEO,

>                                     .end_frame     = output_end_frame,

>                                     .min_perms     = AV_PERM_READ, },

>                                   { .name = NULL }},

>     .outputs   = (AVFilterPad[]) {{ .name = NULL }},

> };

1801,1802d1770

<     char sws_flags_str[128];

<     FFSinkContext ffsink_ctx = { .pix_fmt = PIX_FMT_YUV420P };

1804,1813c1772,1780

<     AVFilterGraph *graph = avfilter_graph_alloc();

<     snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%d", sws_flags);

<     graph->scale_sws_opts = av_strdup(sws_flags_str);

<     if (avfilter_graph_create_filter(&filt_src, &input_filter, "src",

<                                      NULL, is, graph) < 0)

<         goto the_end;

<     if (avfilter_graph_create_filter(&filt_out, &ffsink, "out",

<                                      NULL, &ffsink_ctx, graph) < 0)

<         goto the_end;

---

>     AVFilterGraph *graph = av_mallocz(sizeof(AVFilterGraph));

>     graph->scale_sws_opts = av_strdup("sws_flags=bilinear");

>     if(!(filt_src = avfilter_open(&input_filter,  "src")))   goto the_end;

>     if(!(filt_out = avfilter_open(&output_filter, "out")))   goto the_end;

>     if(avfilter_init_filter(filt_src, NULL, is))             goto the_end;

>     if(avfilter_init_filter(filt_out, NULL, frame))          goto the_end;

1820c1787

<         outputs->filter_ctx = filt_src;

---

>         outputs->filter  = filt_src;

1825c1792

<         inputs->filter_ctx = filt_out;

---

>         inputs->filter  = filt_out;

1834a1802,1803

>     avfilter_graph_add_filter(graph, filt_src);

>     avfilter_graph_add_filter(graph, filt_out);

1836,1837c1805,1807

<     if (avfilter_graph_config(graph, NULL) < 0)

<         goto the_end;

---

>     if(avfilter_graph_check_validity(graph, NULL))           goto the_end;

>     if(avfilter_graph_config_formats(graph, NULL))           goto the_end;

>     if(avfilter_graph_config_links(graph, NULL))             goto the_end;

1845,1847d1814

< #else

<         AVFilterBufferRef *picref;

<         AVRational tb;

1852,1866c1819

<         ret = get_filtered_video_frame(filt_out, frame, &picref, &tb);

<         if (picref) {

<             pts_int = picref->pts;

<             pos     = picref->pos;

<             frame->opaque = picref;

<         }

<         if (av_cmp_q(tb, is->video_st->time_base)) {

<             int64_t pts1 = pts_int;

<             pts_int = av_rescale_q(pts_int, tb, is->video_st->time_base);

<             av_log(NULL, AV_LOG_DEBUG, "video_thread(): "

<                    "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"/n",

<                    tb.num, tb.den, pts1,

<                    is->video_st->time_base.num, is->video_st->time_base.den, pts_int);

<         }

---

>         ret = get_filtered_video_frame(filt_out, frame, &pts_int, &pos);

1893c1846

<     avfilter_graph_free(graph);

---

>     avfilter_graph_destroy(graph);

2103c2056

<                 is->reformat_ctx= av_audio_convert_alloc(AV_SAMPLE_FMT_S16, 1,

---

>                 is->reformat_ctx= av_audio_convert_alloc(SAMPLE_FMT_S16, 1,

2107,2108c2060,2061

<                         av_get_sample_fmt_name(dec->sample_fmt),

<                         av_get_sample_fmt_name(AV_SAMPLE_FMT_S16));

---

>                         avcodec_get_sample_fmt_name(dec->sample_fmt),

>                         avcodec_get_sample_fmt_name(SAMPLE_FMT_S16));

2117c2070

<                 int istride[6]= {av_get_bits_per_sample_fmt(dec->sample_fmt)/8};

---

>                 int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};

2256c2209

<     set_context_opts(avctx, avcodec_opts[avctx->codec_type], 0, codec);

---

>     set_context_opts(avctx, avcodec_opts[avctx->codec_type], 0);

2276c2229

<         is->audio_src_fmt= AV_SAMPLE_FMT_S16;

---

>         is->audio_src_fmt= SAMPLE_FMT_S16;

2407a2361,2362

>     int st_count[AVMEDIA_TYPE_NB]={0};

>     int st_best_packet_count[AVMEDIA_TYPE_NB];

2415a2371

>     memset(st_best_packet_count, -1, sizeof(st_best_packet_count));

2431c2387

<     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);

---

>     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);

2471c2427,2429

<     for (i = 0; i < ic->nb_streams; i++)

---

>     for(i = 0; i < ic->nb_streams; i++) {

>         AVStream *st= ic->streams[i];

>         AVCodecContext *avctx = st->codec;

2473,2490c2431,2453

<     if (!video_disable)

<         st_index[AVMEDIA_TYPE_VIDEO] =

<             av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,

<                                 wanted_stream[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);

<     if (!audio_disable)

<         st_index[AVMEDIA_TYPE_AUDIO] =

<             av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,

<                                 wanted_stream[AVMEDIA_TYPE_AUDIO],

<                                 st_index[AVMEDIA_TYPE_VIDEO],

<                                 NULL, 0);

<     if (!video_disable)

<         st_index[AVMEDIA_TYPE_SUBTITLE] =

<             av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,

<                                 wanted_stream[AVMEDIA_TYPE_SUBTITLE],

<                                 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?

<                                  st_index[AVMEDIA_TYPE_AUDIO] :

<                                  st_index[AVMEDIA_TYPE_VIDEO]),

<                                 NULL, 0);

---

>         if(avctx->codec_type >= (unsigned)AVMEDIA_TYPE_NB)

>             continue;

>         if(st_count[avctx->codec_type]++ != wanted_stream[avctx->codec_type] && wanted_stream[avctx->codec_type] >= 0)

>             continue;

>         if(st_best_packet_count[avctx->codec_type] >= st->codec_info_nb_frames)

>             continue;

>         st_best_packet_count[avctx->codec_type]= st->codec_info_nb_frames;

>         switch(avctx->codec_type) {

>         case AVMEDIA_TYPE_AUDIO:

>             if (!audio_disable)

>                 st_index[AVMEDIA_TYPE_AUDIO] = i;

>             break;

>         case AVMEDIA_TYPE_VIDEO:

>         case AVMEDIA_TYPE_SUBTITLE:

>             if (!video_disable)

>                 st_index[avctx->codec_type] = i;

>             break;

>         default:

>             break;

>         }

>     }

2575c2538

<         if(eof) {

---

>         if(url_feof(ic->pb) || eof) {

2596c2559

<             if (ret == AVERROR_EOF || url_feof(ic->pb))

---

>             if (ret == AVERROR_EOF)

2679a2643,2676

> static void stream_close(VideoState *is)

> {

>     VideoPicture *vp;

>     int i;

>     /* XXX: use a special url_shutdown call to abort parse cleanly */

>     is->abort_request = 1;

>     SDL_WaitThread(is->parse_tid, NULL);

>     SDL_WaitThread(is->refresh_tid, NULL);

>     /* free all pictures */

>     for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {

>         vp = &is->pictq[i];

> #if CONFIG_AVFILTER

>         if (vp->picref) {

>             avfilter_unref_pic(vp->picref);

>             vp->picref = NULL;

>         }

> #endif

>         if (vp->bmp) {

>             SDL_FreeYUVOverlay(vp->bmp);

>             vp->bmp = NULL;

>         }

>     }

>     SDL_DestroyMutex(is->pictq_mutex);

>     SDL_DestroyCond(is->pictq_cond);

>     SDL_DestroyMutex(is->subpq_mutex);

>     SDL_DestroyCond(is->subpq_cond);

> #if !CONFIG_AVFILTER

>     if (is->img_convert_ctx)

>         sws_freeContext(is->img_convert_ctx);

> #endif

>     av_free(is);

> }

2756a2754,2773

> static void do_exit(void)

> {

>     int i;

>     if (cur_stream) {

>         stream_close(cur_stream);

>         cur_stream = NULL;

>     }

>     for (i = 0; i < AVMEDIA_TYPE_NB; i++)

>         av_free(avcodec_opts[i]);

>     av_free(avformat_opts);

>     av_free(sws_opts);

> #if CONFIG_AVFILTER

>     avfilter_uninit();

> #endif

>     if (show_status)

>         printf("/n");

>     SDL_Quit();

>     exit(0);

> }

2780,2783d2796

<             if (exit_on_keydown) {

<                 do_exit();

<                 break;

<             }

2852,2855d2864

<             if (exit_on_mousedown) {

<                 do_exit();

<                 break;

<             }

2918c2927

<     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {

---

>     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {

3037,3038d3045

<     { "exitonkeydown", OPT_BOOL | OPT_EXPERT, {(void*)&exit_on_keydown}, "exit on key down", "" },

<     { "exitonmousedown", OPT_BOOL | OPT_EXPERT, {(void*)&exit_on_mousedown}, "exit on mouse down", "" },

3043c3050

<     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },

---

>     { "vfilters", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },

3059d3065

<     av_log_set_callback(log_callback_help);

3065,3075d3070

<     printf("/n");

<     av_opt_show2(avcodec_opts[0], NULL,

<                  AV_OPT_FLAG_DECODING_PARAM, 0);

<     printf("/n");

<     av_opt_show2(avformat_opts, NULL,

<                  AV_OPT_FLAG_DECODING_PARAM, 0);

< #if !CONFIG_AVFILTER

<     printf("/n");

<     av_opt_show2(sws_opts, NULL,

<                  AV_OPT_FLAG_ENCODING_PARAM, 0);

< #endif

3106,3108c3101

<     int flags;

<     av_log_set_flags(AV_LOG_SKIP_REPEATED);

---

>     int flags, i;

3120c3113,3119

<     init_opts();

---

>     for(i=0; i<AVMEDIA_TYPE_NB; i++){

>         avcodec_opts[i]= avcodec_alloc_context2(i);

>     }

>     avformat_opts = avformat_alloc_context();

> #if !CONFIG_AVFILTER

>     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);

> #endif

Only in ffmpeg: ffplay.d

Only in ffmpeg: ffplay_g

Only in ffmpeg: ffplay.o

Common subdirectories: ffmpeg/ffpresets and ffmpeg-0.6.1/ffpresets

Binary files ffmpeg/ffprobe and ffmpeg-0.6.1/ffprobe differ

diff ffmpeg/ffprobe.c ffmpeg-0.6.1/ffprobe.c

35d34

< static int do_show_packets = 0;

37a37

> static int convert_tags                 = 0;

104,114d103

< static char *ts_value_string (char *buf, int buf_size, int64_t ts)

< {

<     if (ts == AV_NOPTS_VALUE) {

<         snprintf(buf, buf_size, "N/A");

<     } else {

<         snprintf(buf, buf_size, "%"PRId64, ts);

<     }

<     return buf;

< }

127,156d115

< static void show_packet(AVFormatContext *fmt_ctx, AVPacket *pkt)

< {

<     char val_str[128];

<     AVStream *st = fmt_ctx->streams[pkt->stream_index];

<     printf("[PACKET]/n");

<     printf("codec_type=%s/n"   , media_type_string(st->codec->codec_type));

<     printf("stream_index=%d/n" , pkt->stream_index);

<     printf("pts=%s/n"          , ts_value_string  (val_str, sizeof(val_str), pkt->pts));

<     printf("pts_time=%s/n"     , time_value_string(val_str, sizeof(val_str), pkt->pts, &st->time_base));

<     printf("dts=%s/n"          , ts_value_string  (val_str, sizeof(val_str), pkt->dts));

<     printf("dts_time=%s/n"     , time_value_string(val_str, sizeof(val_str), pkt->dts, &st->time_base));

<     printf("duration=%s/n"     , ts_value_string  (val_str, sizeof(val_str), pkt->duration));

<     printf("duration_time=%s/n", time_value_string(val_str, sizeof(val_str), pkt->duration, &st->time_base));

<     printf("size=%s/n"         , value_string     (val_str, sizeof(val_str), pkt->size, unit_byte_str));

<     printf("pos=%"PRId64"/n"   , pkt->pos);

<     printf("flags=%c/n"        , pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_');

<     printf("[/PACKET]/n");

< }

< static void show_packets(AVFormatContext *fmt_ctx)

< {

<     AVPacket pkt;

<     av_init_packet(&pkt);

<     while (!av_read_frame(fmt_ctx, &pkt))

<         show_packet(fmt_ctx, &pkt);

< }

163a123

>     char a, b, c, d;

182,184c142,151

<         av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);

<         printf("codec_tag_string=%s/n", val_str);

<         printf("codec_tag=0x%04x/n", dec_ctx->codec_tag);

---

>         a = dec_ctx->codec_tag     & 0xff;

>         b = dec_ctx->codec_tag>>8  & 0xff;

>         c = dec_ctx->codec_tag>>16 & 0xff;

>         d = dec_ctx->codec_tag>>24 & 0xff;

>         printf("codec_tag_string=");

>         if (isprint(a)) printf("%c", a); else printf("[%d]", a);

>         if (isprint(b)) printf("%c", b); else printf("[%d]", b);

>         if (isprint(c)) printf("%c", c); else printf("[%d]", c);

>         if (isprint(d)) printf("%c", d); else printf("[%d]", d);

>         printf("/ncodec_tag=0x%04x/n", dec_ctx->codec_tag);

221a189,190

>     if (stream->language[0])

>         printf("language=%s/n",            stream->language);

254a224,225

>     if (convert_tags)

>         av_metadata_conv(fmt_ctx, NULL, fmt_ctx->iformat->metadata_conv);

267d237

<     set_context_opts(fmt_ctx, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);

308,310d277

<     if (do_show_packets)

<         show_packets(fmt_ctx);

352d318

<     av_log_set_callback(log_callback_help);

356,357d321

<     av_opt_show2(avformat_opts, NULL,

<                  AV_OPT_FLAG_DECODING_PARAM, 0);

369a334

>     { "convert_tags", OPT_BOOL, {(void*)&convert_tags}, "convert tag names to the FFmpeg generic tag names" },

380d344

<     { "show_packets", OPT_BOOL, {(void*)&do_show_packets}, "show packets info" },

382d345

<     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },

388,389d350

<     int ret;

395,396d355

<     avformat_opts = avformat_alloc_context();

407,411c366

<     ret = probe_file(input_filename);

<     av_free(avformat_opts);

<     return ret;

---

>     return probe_file(input_filename);

diff ffmpeg/ffprobe.d ffmpeg-0.6.1/ffprobe.d

2,7c2,6

<  libavcore/samplefmt.h libavutil/avutil.h libavutil/common.h /

<  libavutil/attributes.h libavutil/avconfig.h libavutil/mem.h /

<  libavutil/avutil.h libavutil/error.h libavutil/mathematics.h /

<  libavutil/rational.h libavutil/intfloat_readwrite.h libavutil/log.h /

<  libavutil/pixfmt.h libavutil/cpu.h libavcore/audioconvert.h /

<  libavcore/avcore.h libavformat/avio.h libavutil/common.h libavutil/log.h /

---

>  libavutil/avutil.h libavutil/common.h libavutil/attributes.h /

>  libavutil/mem.h libavutil/error.h libavutil/avutil.h /

>  libavutil/mathematics.h libavutil/rational.h /

>  libavutil/intfloat_readwrite.h libavutil/log.h libavutil/pixfmt.h /

>  libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

9,11c8,9

<  libavcodec/avcodec.h libavutil/opt.h libavutil/pixdesc.h /

<  libavdevice/avdevice.h cmdutils.h libswscale/swscale.h /

<  libavfilter/avfilter.h libavcore/avcore.h cmdutils_common_opts.h

---

>  libavcodec/avcodec.h libavutil/pixdesc.h libavdevice/avdevice.h /

>  cmdutils.h libswscale/swscale.h cmdutils_common_opts.h

Binary files ffmpeg/ffprobe_g and ffmpeg-0.6.1/ffprobe_g differ

Binary files ffmpeg/ffprobe.o and ffmpeg-0.6.1/ffprobe.o differ

Binary files ffmpeg/ffserver and ffmpeg-0.6.1/ffserver differ

diff ffmpeg/ffserver.c ffmpeg-0.6.1/ffserver.c

39d38

< #include "libavcore/parseutils.h"

95,98d93

< #if !FF_API_MAX_STREAMS

< #define MAX_STREAMS 20

< #endif

748c743

<                        "HTTP/1.0 503 Server too busy/r/n"

---

>                        "HTTP/1.0 200 Server too busy/r/n"

1597c1592

<         c->http_error = 503;

---

>         c->http_error = 200;

1600c1595

<                       "HTTP/1.0 503 Server too busy/r/n"

---

>                       "HTTP/1.0 200 Server too busy/r/n"

2314,2316c2309,2310

<             ret = av_read_frame(c->fmt_in, &pkt);

<             if (ret < 0) {

<                 if (c->stream->feed) {

---

>             if (av_read_frame(c->fmt_in, &pkt) < 0) {

>                 if (c->stream->feed && c->stream->feed->feed_opened) {

2321,2323d2314

<                 } else if (ret == AVERROR(EAGAIN)) {

<                     /* input not ready, come back later */

<                     return 0;

2380c2371,2372

<                         c->cur_pts -= c->first_pts;

---

>                         if (ist->start_time != AV_NOPTS_VALUE)

>                             c->cur_pts -= av_rescale_q(ist->start_time, ist->time_base, AV_TIME_BASE_Q);

2643d2634

<             return 0;

2756c2747,2754

<                 avcodec_copy_context(fst->codec, st->codec);

---

>                 memcpy(fst->codec, st->codec, sizeof(AVCodecContext));

>                 if (fst->codec->extradata_size) {

>                     fst->codec->extradata = av_malloc(fst->codec->extradata_size);

>                     if (!fst->codec->extradata)

>                         goto fail;

>                     memcpy(fst->codec->extradata, st->codec->extradata,

>                            fst->codec->extradata_size);

>                 }

2785c2783

<     struct tm *tm;

---

>     char *p;

2832,2833c2830,2834

<     tm = gmtime(&ti);

<     strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);

---

>     p = ctime(&ti);

>     strcpy(buf2, p);

>     p = buf2 + strlen(p) - 1;

>     if (*p == '/n')

>         *p = '/0';

2898c2899

<         ff_rtsp_parse_line(header, line, NULL, NULL);

---

>         ff_rtsp_parse_line(header, line, NULL);

2937c2938

<     AVStream *avs = NULL;

---

>     AVStream avs[MAX_STREAMS];

2955,2963d2955

< #if !FF_API_MAX_STREAMS

<     if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||

<         !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))

<         goto sdp_done;

< #endif

<     if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||

<         !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))

<         goto sdp_done;

2970,2974d2961

<  sdp_done:

< #if !FF_API_MAX_STREAMS

<     av_free(avc->streams);

< #endif

2977d2963

<     av_free(avs);

3001c2987

<     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

---

>     ff_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

3078c3064

<     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

---

>     ff_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

3221c3207

<     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

---

>     ff_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

3500d3485

<     fst->sample_aspect_ratio = (AVRational){0,1};

3881,3882c3866

<         if (!av->me_method)

<             av->me_method = ME_EPZS;

---

>         av->me_method = ME_EPZS;

3970,4012d3953

< static int ffserver_opt_preset(const char *arg,

<                        AVCodecContext *avctx, int type,

<                        enum CodecID *audio_id, enum CodecID *video_id)

< {

<     FILE *f=NULL;

<     char filename[1000], tmp[1000], tmp2[1000], line[1000];

<     int ret = 0;

<     AVCodec *codec = avcodec_find_encoder(avctx->codec_id);

<     if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,

<                               codec ? codec->name : NULL))) {

<         fprintf(stderr, "File for preset '%s' not found/n", arg);

<         return 1;

<     }

<     while(!feof(f)){

<         int e= fscanf(f, "%999[^/n]/n", line) - 1;

<         if(line[0] == '#' && !e)

<             continue;

<         e|= sscanf(line, "%999[^=]=%999[^/n]/n", tmp, tmp2) - 2;

<         if(e){

<             fprintf(stderr, "%s: Invalid syntax: '%s'/n", filename, line);

<             ret = 1;

<             break;

<         }

<         if(!strcmp(tmp, "acodec")){

<             *audio_id = opt_audio_codec(tmp2);

<         }else if(!strcmp(tmp, "vcodec")){

<             *video_id = opt_video_codec(tmp2);

<         }else if(!strcmp(tmp, "scodec")){

<             /* opt_subtitle_codec(tmp2); */

<         }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){

<             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'/n", filename, line, tmp, tmp2);

<             ret = 1;

<             break;

<         }

<     }

<     fclose(f);

<     return ret;

< }

4363c4304

<                 audio_enc.bit_rate = lrintf(atof(arg) * 1000);

---

>                 audio_enc.bit_rate = atoi(arg) * 1000;

4418c4359

<                 av_parse_video_size(&video_enc.width, &video_enc.height, arg);

---

>                 av_parse_video_frame_size(&video_enc.width, &video_enc.height, arg);

4428c4369

<                 if (av_parse_video_rate(&frame_rate, arg) < 0) {

---

>                 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {

4467,4483d4407

<         } else if (!strcasecmp(cmd, "AVPresetVideo") ||

<                    !strcasecmp(cmd, "AVPresetAudio")) {

<             AVCodecContext *avctx;

<             int type;

<             get_arg(arg, sizeof(arg), &p);

<             if (!strcasecmp(cmd, "AVPresetVideo")) {

<                 avctx = &video_enc;

<                 video_enc.codec_id = video_id;

<                 type = AV_OPT_FLAG_VIDEO_PARAM;

<             } else {

<                 avctx = &audio_enc;

<                 audio_enc.codec_id = audio_id;

<                 type = AV_OPT_FLAG_AUDIO_PARAM;

<             }

<             if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {

<                 ERROR("AVPreset error: %s/n", arg);

<             }

4709c4633

<     av_lfg_init(&random_state, av_get_random_seed());

---

>     av_lfg_init(&random_state, ff_random_get_seed());

diff ffmpeg/ffserver.d ffmpeg-0.6.1/ffserver.d

2,5c2,4

<  libavcodec/avcodec.h libavcore/samplefmt.h libavutil/avutil.h /

<  libavutil/common.h libavutil/attributes.h libavutil/avconfig.h /

<  libavutil/mem.h libavutil/avutil.h libavutil/error.h /

<  libavutil/mathematics.h libavutil/rational.h /

---

>  libavcodec/avcodec.h libavutil/avutil.h libavutil/common.h /

>  libavutil/attributes.h libavutil/mem.h libavutil/error.h /

>  libavutil/avutil.h libavutil/mathematics.h libavutil/rational.h /

7,8c6

<  libavutil/cpu.h libavcore/audioconvert.h libavcore/avcore.h /

<  libavformat/avio.h libavutil/common.h libavutil/log.h /

---

>  libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

13,16c11,13

<  libavutil/lfg.h libavutil/random_seed.h libavcore/parseutils.h /

<  libavutil/rational.h libavcodec/opt.h libavcodec/avcodec.h /

<  libavutil/opt.h cmdutils.h libavcodec/avcodec.h libswscale/swscale.h /

<  libavfilter/avfilter.h libavcore/avcore.h cmdutils_common_opts.h

---

>  libavutil/lfg.h libavutil/random_seed.h libavcodec/opt.h /

>  libavutil/rational.h libavcodec/avcodec.h cmdutils.h /

>  libavcodec/avcodec.h libswscale/swscale.h cmdutils_common_opts.h

Binary files ffmpeg/ffserver_g and ffmpeg-0.6.1/ffserver_g differ

Binary files ffmpeg/ffserver.o and ffmpeg-0.6.1/ffserver.o differ

Common subdirectories: ffmpeg/libavcodec and ffmpeg-0.6.1/libavcodec

Only in ffmpeg: libavcore

Common subdirectories: ffmpeg/libavdevice and ffmpeg-0.6.1/libavdevice

Common subdirectories: ffmpeg/libavfilter and ffmpeg-0.6.1/libavfilter

Common subdirectories: ffmpeg/libavformat and ffmpeg-0.6.1/libavformat

Common subdirectories: ffmpeg/libavutil and ffmpeg-0.6.1/libavutil

Common subdirectories: ffmpeg/libpostproc and ffmpeg-0.6.1/libpostproc

Common subdirectories: ffmpeg/libswscale and ffmpeg-0.6.1/libswscale

diff ffmpeg/LICENSE ffmpeg-0.6.1/LICENSE

16a17,18

> - optional MMX optimizations for YUV to RGB colorspace conversion in

>   libswscale/x86/yuv2rgb_template.c

17a20,21

>   libavcodec/x86/h264_deblock_sse2.asm

>   libavcodec/x86/h264_idct_sse2.asm

diff ffmpeg/MAINTAINERS ffmpeg-0.6.1/MAINTAINERS

24,26d23

< ffprobe:

<   ffprobe.c                             Stefano Sabatini

40c37

< documentation                           Mike Melanson

---

> documentation                           Mike Melanson, Diego Biurrun

104,105d100

<   table generation:

<     tableprint.c, tableprint.h          Reimar Doeffinger

117d111

<   ass*                                  Aurelien Jacobs

140d133

<   g722.c                                Martin Storsjo

162,163d154

<   libvorbis.c                           David Conrad

<   libxavs.c                             Stefan Gehrer

181d171

<   pgssubdec.c                           Reimar Doeffinger

201d190

<   srtdec.c                              Aurelien Jacobs

218c207

<   vorbis_dec.c                          Denes Balatoni, David Conrad

---

>   vorbis_dec.c                          Denes Balatoni

222d210

<   vp8                                   David Conrad, Jason Garrett-Glaser, Ronald Bultje

266d253

<   ass*                                  Aurelien Jacobs

269d255

<   caf*                                  Peter Ross

282c268

<   idroqdec.c                            Mike Melanson

---

>   idroq.c                               Mike Melanson

289d274

<   lxfdec.c                              Tomas H盲rdin

310d294

<   oma.c                                 Maxim Poliakovski

319,321c303,305

<   rtp.c, rtpenc.c                       Martin Storsjo

<   rtpdec_asf.*                          Ronald S. Bultje

<   rtpenc_mpv.*, rtpenc_aac.*            Martin Storsjo

---

>   rtp.c, rtpenc.c                       Luca Abeni

>   rtp_asf.*                             Ronald S. Bultje

>   rtp_mpv.*, rtp_aac.*                  Luca Abeni

323c307

<   sdp.c                                 Martin Storsjo

---

>   sdp.c                                 Luca Abeni

327d310

<   srtdec.c                              Aurelien Jacobs

339d321

<   mms*.c                                Ronald S. Bultje

349a332

> BeOS                                    Francois Revol

363d345

< Anton Khirnov                 6D0C 6625 56F8 65D1 E5F5 814B B50A 1241 C067 07AB

366d347

< Ben Littler                   3EE3 3723 E560 3214 A8CD 4DEB 2CDB FCE7 768C 8D2C

371d351

< Justin Ruggles                3136 ECC0 C10D 6C04 5F43 CA29 FCBE CD2A 3787 1EBF

373d352

< Luca Barbato                  6677 4209 213C 8843 5B67 29E7 E84C 78C2 84E9 0E34

380d358

< Robert Swain                  EE7A 56EA 4A81 A7B5 2001 A521 67FA 362D A2FC 3E71

382,383d359

< Stefano Sabatini              9A43 10F8 D32C D33C 48E7 C52C 5DF2 8E4D B2EE 066B

< Tomas H盲rdin                  D133 29CA 4EEC 9DB4 7076 F697 B04B 7403 3313 41FD

diff ffmpeg/Makefile ffmpeg-0.6.1/Makefile

16,17d15

< PODPAGES    = $(addprefix doc/, $(addsuffix .pod, $(PROGS-yes)))

< HTMLPAGES   = $(addprefix doc/, $(addsuffix .html, $(PROGS-yes)))

19c17

< HOSTPROGS   = $(addprefix tests/, audiogen videogen rotozoom tiny_psnr base64)

---

> HOSTPROGS   = $(addprefix tests/, audiogen videogen rotozoom tiny_psnr)

25d22

< ALLHTMLPAGES= $(addsuffix .html, $(BASENAMES))

33d29

< FFLIBS-$(CONFIG_AVCORE)   += avcore

61,66d56

< config.h: .config

< .config: $(wildcard $(FFLIBS:%=$(SRC_DIR)/lib%/all*.c))

< @-tput bold 2>/dev/null

< @-printf '/nWARNING: $(?F) newer than config.h, rerun configure/n/n'

< @-tput sgr0 2>/dev/null

94c84

< $(CC) $(CPPFLAGS) $(CFLAGS) -c $(CC_O) $<

---

> $(CC) $(CPPFLAGS) $(CFLAGS) $(CC_O) $<

96c86

< ffplay.o: CFLAGS += $(SDL_CFLAGS)

---

> ffplay.o ffplay.d: CFLAGS += $(SDL_CFLAGS)

114,122c104,106

< documentation: $(addprefix doc/, developer.html faq.html general.html libavfilter.html /

<                                  $(ALLHTMLPAGES) $(ALLMANPAGES))

< $(HTMLPAGES) $(PODPAGES): doc/fftools-common-opts.texi

< doc/ffmpeg.pod doc/ffmpeg.html: doc/bitstream_filters.texi doc/eval.texi doc/indevs.texi doc/filters.texi doc/outdevs.texi doc/protocols.texi doc/metadata.texi

< doc/ffplay.pod doc/ffplay.html: doc/eval.texi doc/indevs.texi doc/filters.texi doc/outdevs.texi doc/protocols.texi

< doc/ffprobe.pod doc/ffprobe.html: doc/indevs.texi doc/protocols.texi

< doc/libavfilter.html: doc/filters.texi

---

> documentation: $(addprefix doc/, developer.html faq.html ffmpeg-doc.html /

>                                  ffplay-doc.html ffprobe-doc.html ffserver-doc.html /

>                                  general.html libavfilter.html $(ALLMANPAGES))

129c113

< doc/%.pod: doc/%.texi

---

> doc/%.pod: doc/%-doc.texi

165c149

< $(RM) $(addprefix tests/,$(addsuffix $(HOSTEXESUF),audiogen videogen rotozoom tiny_psnr base64))

---

> $(RM) $(addprefix tests/,$(addsuffix $(HOSTEXESUF),audiogen videogen rotozoom tiny_psnr))

184c168

< fulltest test: codectest lavftest lavfitest seektest

---

> fulltest test: codectest lavftest seektest

189,202c173,294

< codectest: fate-codec

< lavftest:  fate-lavf

< lavfitest: fate-lavfi

< seektest:  fate-seek

< AREF = tests/data/acodec.ref.wav

< VREF = tests/data/vsynth1.ref.yuv

< REFS = $(AREF) $(VREF)

< $(REFS): TAG = GEN

< $(VREF): ffmpeg$(EXESUF) tests/vsynth1/00.pgm tests/vsynth2/00.pgm

< $(M)$(SRC_PATH)/tests/codec-regression.sh vref vsynth1 tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

< $(Q)$(SRC_PATH)/tests/codec-regression.sh vref vsynth2 tests/vsynth2 "$(TARGET_EXEC)" "$(TARGET_PATH)"

---

> ENCDEC = $(and $(CONFIG_$(1)_ENCODER),$(CONFIG_$(1)_DECODER))

> MUXDEM = $(and $(CONFIG_$(1)_MUXER),$(CONFIG_$(or $(2),$(1))_DEMUXER))

> VCODEC_TESTS =

> VCODEC_TESTS-$(call ENCDEC,ASV1)             += asv1

> VCODEC_TESTS-$(call ENCDEC,ASV2)             += asv2

> VCODEC_TESTS-$(call ENCDEC,DNXHD)            += dnxhd_1080i dnxhd_720p dnxhd_720p_rd

> VCODEC_TESTS-$(call ENCDEC,DVVIDEO)          += dv dv50

> VCODEC_TESTS-$(call ENCDEC,FFV1)             += ffv1

> VCODEC_TESTS-$(call ENCDEC,FLASHSV)          += flashsv

> VCODEC_TESTS-$(call ENCDEC,FLV)              += flv

> VCODEC_TESTS-$(call ENCDEC,H261)             += h261

> VCODEC_TESTS-$(call ENCDEC,H263)             += h263 h263p

> VCODEC_TESTS-$(call ENCDEC,HUFFYUV)          += huffyuv

> VCODEC_TESTS-$(call ENCDEC,JPEGLS)           += jpegls

> VCODEC_TESTS-$(call ENCDEC,MJPEG)            += mjpeg ljpeg

> VCODEC_TESTS-$(call ENCDEC,MPEG1VIDEO)       += mpeg mpeg1b

> VCODEC_TESTS-$(call ENCDEC,MPEG2VIDEO)       += mpeg2 mpeg2thread

> VCODEC_TESTS-$(call ENCDEC,MPEG4)            += mpeg4 mpeg4adv mpeg4nr mpeg4thread error rc

> VCODEC_TESTS-$(call ENCDEC,MSMPEG4V1)        += msmpeg4

> VCODEC_TESTS-$(call ENCDEC,MSMPEG4V2)        += msmpeg4v2

> VCODEC_TESTS-$(call ENCDEC,ROQ)              += roq

> VCODEC_TESTS-$(call ENCDEC,RV10)             += rv10

> VCODEC_TESTS-$(call ENCDEC,RV20)             += rv20

> VCODEC_TESTS-$(call ENCDEC,SNOW)             += snow snowll

> VCODEC_TESTS-$(call ENCDEC,SVQ1)             += svq1

> VCODEC_TESTS-$(call ENCDEC,WMV1)             += wmv1

> VCODEC_TESTS-$(call ENCDEC,WMV2)             += wmv2

> ACODEC_TESTS =

> ACODEC_TESTS-$(call ENCDEC,AC3)              += ac3

> ACODEC_TESTS-$(call ENCDEC,ADPCM_G726)       += g726

> ACODEC_TESTS-$(call ENCDEC,ADPCM_IMA_QT)     += adpcm_ima_qt

> ACODEC_TESTS-$(call ENCDEC,ADPCM_IMA_WAV)    += adpcm_ima_wav

> ACODEC_TESTS-$(call ENCDEC,ADPCM_MS)         += adpcm_ms

> ACODEC_TESTS-$(call ENCDEC,ADPCM_SWF)        += adpcm_swf

> ACODEC_TESTS-$(call ENCDEC,ADPCM_YAMAHA)     += adpcm_yam

> ACODEC_TESTS-$(call ENCDEC,ALAC)             += alac

> ACODEC_TESTS-$(call ENCDEC,FLAC)             += flac

> ACODEC_TESTS-$(call ENCDEC,MP2)              += mp2

> ACODEC_TESTS-$(call ENCDEC,PCM_S16LE)        += pcm         # fixme

> ACODEC_TESTS-$(call ENCDEC,WMAV1)            += wmav1

> ACODEC_TESTS-$(call ENCDEC,WMAV1)            += wmav2

> LAVF_TESTS =

> LAVF_TESTS-$(call MUXDEM,AIFF)               += aiff

> LAVF_TESTS-$(call MUXDEM,PCM_ALAW)           += alaw

> LAVF_TESTS-$(call MUXDEM,ASF)                += asf

> LAVF_TESTS-$(call MUXDEM,AU)                 += au

> LAVF_TESTS-$(call MUXDEM,AVI)                += avi

> LAVF_TESTS-$(call ENCDEC,BMP)                += bmp

> LAVF_TESTS-$(call MUXDEM,DV)                 += dv_fmt

> LAVF_TESTS-$(call MUXDEM,FFM)                += ffm

> LAVF_TESTS-$(call MUXDEM,FLV)                += flv_fmt

> LAVF_TESTS-$(call ENCDEC,GIF)                += gif

> LAVF_TESTS-$(call MUXDEM,GXF)                += gxf

> LAVF_TESTS-$(call ENCDEC,MJPEG)              += jpg

> LAVF_TESTS-$(call MUXDEM,MATROSKA)           += mkv

> LAVF_TESTS-$(call MUXDEM,MMF)                += mmf

> LAVF_TESTS-$(call MUXDEM,MOV)                += mov

> LAVF_TESTS-$(call MUXDEM,MPEG1SYSTEM,MPEGPS) += mpg

> LAVF_TESTS-$(call MUXDEM,PCM_MULAW)          += mulaw

> LAVF_TESTS-$(call MUXDEM,MXF)                += mxf

> LAVF_TESTS-$(call MUXDEM,NUT)                += nut

> LAVF_TESTS-$(call MUXDEM,OGG)                += ogg

> LAVF_TESTS-$(call ENCDEC,PBM)                += pbmpipe

> LAVF_TESTS-$(call ENCDEC,PCX)                += pcx

> LAVF_TESTS-$(call ENCDEC,PGM)                += pgm pgmpipe

> LAVF_TESTS-$(call MUXDEM,RAWVIDEO)           += pixfmt

> LAVF_TESTS-$(call ENCDEC,PPM)                += ppm ppmpipe

> LAVF_TESTS-$(call MUXDEM,RM)                 += rm

> LAVF_TESTS-$(call ENCDEC,SGI)                += sgi

> LAVF_TESTS-$(call MUXDEM,SWF)                += swf

> LAVF_TESTS-$(call ENCDEC,TARGA)              += tga

> LAVF_TESTS-$(call ENCDEC,TIFF)               += tiff

> LAVF_TESTS-$(call MUXDEM,MPEGTS)             += ts

> LAVF_TESTS-$(call MUXDEM,VOC)                += voc

> LAVF_TESTS-$(call MUXDEM,WAV)                += wav

> LAVF_TESTS-$(call MUXDEM,YUV4MPEGPIPE)       += yuv4mpeg

> LAVFI_TESTS =           /

>     crop                /

>     crop_scale          /

>     crop_scale_vflip    /

>     crop_vflip          /

>     null                /

>     scale200            /

>     scale500            /

>     vflip               /

>     vflip_crop          /

>     vflip_vflip         /

> ACODEC_TESTS := $(addprefix regtest-, $(ACODEC_TESTS) $(ACODEC_TESTS-yes))

> VCODEC_TESTS := $(addprefix regtest-, $(VCODEC_TESTS) $(VCODEC_TESTS-yes))

> LAVF_TESTS  := $(addprefix regtest-, $(LAVF_TESTS)  $(LAVF_TESTS-yes))

> LAVFI_TESTS := $(addprefix regtest-, $(LAVFI_TESTS) $(LAVFI_TESTS-yes))

> CODEC_TESTS = $(VCODEC_TESTS) $(ACODEC_TESTS)

> codectest: $(CODEC_TESTS)

> lavftest:  $(LAVF_TESTS)

> lavfitest: $(LAVFI_TESTS)

> $(ACODEC_TESTS): regtest-aref

> $(VCODEC_TESTS): regtest-vref

> $(LAVF_TESTS) $(LAVFI_TESTS): regtest-ref

> REFFILE = $(SRC_PATH)/tests/ref/$(1)/$(2:regtest-%=%)

> RESFILE = tests/data/$(2:regtest-%=%).$(1).regression

> define CODECTEST_CMD

> $(SRC_PATH)/tests/codec-regression.sh $@ vsynth1 tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

> $(SRC_PATH)/tests/codec-regression.sh $@ vsynth2 tests/vsynth2 "$(TARGET_EXEC)" "$(TARGET_PATH)"

> endef

> regtest-ref: regtest-aref regtest-vref

> regtest-vref: ffmpeg$(EXESUF) tests/vsynth1/00.pgm tests/vsynth2/00.pgm

> $(CODECTEST_CMD)

> regtest-aref: ffmpeg$(EXESUF) tests/data/asynth1.sw

> @$(SRC_PATH)/tests/codec-regression.sh $@ acodec tests/acodec "$(TARGET_EXEC)" "$(TARGET_PATH)"

204,205c296,318

< $(AREF): ffmpeg$(EXESUF) tests/data/asynth1.sw

< $(M)$(SRC_PATH)/tests/codec-regression.sh aref acodec tests/acodec "$(TARGET_EXEC)" "$(TARGET_PATH)"

---

> $(VCODEC_TESTS): tests/tiny_psnr$(HOSTEXESUF)

> @echo "TEST VCODEC $(@:regtest-%=%)"

> @$(CODECTEST_CMD)

> @diff -u -w $(call REFFILE,vsynth1,$@) $(call RESFILE,vsynth1,$@)

> @diff -u -w $(call REFFILE,vsynth2,$@) $(call RESFILE,vsynth2,$@)

> $(ACODEC_TESTS): tests/tiny_psnr$(HOSTEXESUF)

> @echo "TEST ACODEC $(@:regtest-%=%)"

> @$(SRC_PATH)/tests/codec-regression.sh $@ acodec tests/acodec "$(TARGET_EXEC)" "$(TARGET_PATH)"

> @diff -u -w $(call REFFILE,acodec,$@) $(call RESFILE,acodec,$@)

> $(LAVF_TESTS):

> @echo "TEST LAVF  $(@:regtest-%=%)"

> @$(SRC_PATH)/tests/lavf-regression.sh $@ lavf tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

> @diff -u -w $(call REFFILE,lavf,$@) $(call RESFILE,lavf,$@)

> $(LAVFI_TESTS):

> @echo "TEST LAVFI $(@:regtest-%=%)"

> @$(SRC_PATH)/tests/lavfi-regression.sh $@ lavfi tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

> @diff -u -w $(call REFFILE,lavfi,$@) $(call RESFILE,lavfi,$@)

> seektest: codectest lavftest tests/seek_test$(EXESUF)

> $(SRC_PATH)/tests/seek-regression.sh $(SRC_PATH) "$(TARGET_EXEC)" "$(TARGET_PATH)"

215,216c328,329

< @mkdir -p tests/vsynth1

< $(M)$(BUILD_ROOT)/$< 'tests/vsynth1/'

---

> mkdir -p tests/vsynth1

> $(BUILD_ROOT)/$< 'tests/vsynth1/'

219,220c332,333

< @mkdir -p tests/vsynth2

< $(M)$(BUILD_ROOT)/$< 'tests/vsynth2/' $(SRC_PATH)/tests/lena.pnm

---

> mkdir -p tests/vsynth2

> $(BUILD_ROOT)/$< 'tests/vsynth2/' $(SRC_PATH)/tests/lena.pnm

223,226c336,337

< @mkdir -p tests/data

< $(M)$(BUILD_ROOT)/$< $@

< tests/data/asynth1.sw tests/vsynth%/00.pgm: TAG = GEN

---

> mkdir -p tests/data

> $(BUILD_ROOT)/$< $@

231,278d341

< tools/lavfi-showfiltfmts$(EXESUF): tools/lavfi-showfiltfmts.o $(FF_DEP_LIBS)

< $(LD) $(FF_LDFLAGS) -o $@ $< $(FF_EXTRALIBS)

< include $(SRC_PATH_BARE)/tests/fate.mak

< include $(SRC_PATH_BARE)/tests/fate2.mak

< include $(SRC_PATH_BARE)/tests/fate/aac.mak

< include $(SRC_PATH_BARE)/tests/fate/als.mak

< include $(SRC_PATH_BARE)/tests/fate/fft.mak

< include $(SRC_PATH_BARE)/tests/fate/h264.mak

< include $(SRC_PATH_BARE)/tests/fate/mp3.mak

< include $(SRC_PATH_BARE)/tests/fate/vorbis.mak

< include $(SRC_PATH_BARE)/tests/fate/vp8.mak

< FATE_ACODEC  = $(ACODEC_TESTS:%=fate-acodec-%)

< FATE_VSYNTH1 = $(VCODEC_TESTS:%=fate-vsynth1-%)

< FATE_VSYNTH2 = $(VCODEC_TESTS:%=fate-vsynth2-%)

< FATE_VCODEC  = $(FATE_VSYNTH1) $(FATE_VSYNTH2)

< FATE_LAVF    = $(LAVF_TESTS:%=fate-lavf-%)

< FATE_LAVFI   = $(LAVFI_TESTS:%=fate-lavfi-%)

< FATE_SEEK    = $(SEEK_TESTS:seek_%=fate-seek-%)

< FATE = $(FATE_ACODEC)                                                   /

<        $(FATE_VCODEC)                                                   /

<        $(FATE_LAVF)                                                     /

<        $(FATE_LAVFI)                                                    /

<        $(FATE_SEEK)                                                     /

< $(FATE_ACODEC): $(AREF)

< $(FATE_VCODEC): $(VREF)

< $(FATE_LAVF):   $(REFS)

< $(FATE_LAVFI):  $(REFS) tools/lavfi-showfiltfmts$(EXESUF)

< $(FATE_SEEK):   fate-codec fate-lavf tests/seek_test$(EXESUF)

< $(FATE_ACODEC):  CMD = codectest acodec

< $(FATE_VSYNTH1): CMD = codectest vsynth1

< $(FATE_VSYNTH2): CMD = codectest vsynth2

< $(FATE_LAVF):    CMD = lavftest

< $(FATE_LAVFI):   CMD = lavfitest

< $(FATE_SEEK):    CMD = seektest

< fate-codec:  fate-acodec fate-vcodec

< fate-acodec: $(FATE_ACODEC)

< fate-vcodec: $(FATE_VCODEC)

< fate-lavf:   $(FATE_LAVF)

< fate-lavfi:  $(FATE_LAVFI)

< fate-seek:   $(FATE_SEEK)

280c343,347

< FATE += $(FATE_TESTS)

---

> include $(SRC_PATH_BARE)/tests/fate.mak

> fate: $(FATE_TESTS)

> $(FATE_TESTS): ffmpeg$(EXESUF)

> @echo "TEST FATE   $(@:fate-%=%)"

> @$(SRC_PATH)/tests/fate-run.sh $@ "$(SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)" '$(CMD)'

282c349

< $(FATE_TESTS):

---

> fate:

286,297c353

< FATE_UTILS = base64 tiny_psnr

< fate: $(FATE)

< $(FATE): ffmpeg$(EXESUF) $(FATE_UTILS:%=tests/%$(HOSTEXESUF))

< @echo "TEST    $(@:fate-%=%)"

< $(Q)$(SRC_PATH)/tests/fate-run.sh $@ "$(SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)" '$(CMD)' '$(CMP)' '$(REF)' '$(FUZZ)'

< fate-list:

< @printf '%s/n' $(sort $(FATE))

< .PHONY: documentation *test regtest-* alltools check config

---

> .PHONY: documentation *test regtest-* zlib-error alltools check config

Only in ffmpeg-0.6.1: RELEASE

diff ffmpeg/subdir.mak ffmpeg-0.6.1/subdir.mak

13c13

< $(SUBDIR)%-test.o: $(SUBDIR)%-test.c

---

> $(SUBDIR)%-test.o: $(SUBDIR)%.c

16c16

< $(SUBDIR)%-test.o: $(SUBDIR)%.c

---

> $(SUBDIR)%-test.o: $(SUBDIR)%-test.c

Only in ffmpeg: .svn

Common subdirectories: ffmpeg/tests and ffmpeg-0.6.1/tests

Common subdirectories: ffmpeg/tools and ffmpeg-0.6.1/tools

Only in ffmpeg-0.6.1: VERSION

diff ffmpeg/version.h ffmpeg-0.6.1/version.h

1c1

< #define FFMPEG_VERSION "SVN-r26268"

---

> #define FFMPEG_VERSION "0.6.1"

diff ffmpeg/version.sh ffmpeg-0.6.1/version.sh

34,38d33

< if [ -z "$2" ]; then

<     echo "$version"

<     exit

< fi

 

 

===================================-u了一下======================================

root@ubuntu:/home/zhangbin/Documents# diff -u  ffmpeg ffmpeg-0.6.1 > diff-result1.txt

 

diff -u ffmpeg/Changelog ffmpeg-0.6.1/Changelog

--- ffmpeg/Changelog 2011-01-08 09:07:51.374711421 -0800

+++ ffmpeg-0.6.1/Changelog 2010-10-18 03:52:44.000000000 -0700

@@ -1,76 +1,15 @@

 Entries are sorted chronologically from oldest to youngest within each release,

 releases are sorted from youngest to oldest.

 

+version 0.6.1:

 

-version <next>:

-

-- WebM support in Matroska de/muxer

-- low overhead Ogg muxing

-- MMS-TCP support

-- VP8 de/encoding via libvpx

-- Demuxer for On2's IVF format

-- Pictor/PC Paint decoder

-- HE-AAC v2 decoder

-- libfaad2 wrapper removed

-- DTS-ES extension (XCh) decoding support

-- native VP8 decoder

-- RTSP tunneling over HTTP

-- RTP depacketization of SVQ3

-- -strict inofficial replaced by -strict unofficial

-- ffplay -exitonkeydown and -exitonmousedown options added

-- native GSM / GSM MS decoder

-- RTP depacketization of QDM2

-- ANSI/ASCII art playback system

-- Lego Mindstorms RSO de/muxer

-- libavcore added

-- SubRip subtitle file muxer and demuxer

-- Chinese AVS encoding via libxavs

-- ffprobe -show_packets option added

-- RTP packetization of Theora and Vorbis

-- RTP depacketization of MP4A-LATM

-- RTP packetization and depacketization of VP8

-- hflip filter

-- Apple HTTP Live Streaming demuxer

-- a64 codec

-- MMS-HTTP support

-- G.722 ADPCM audio encoder/decoder

-- R10k video decoder

-- ocv_smooth filter

-- frei0r wrapper filter

-- change crop filter syntax to width:height:x:y

-- make the crop filter accept parametric expressions

-- make ffprobe accept AVFormatContext options

-- yadif filter

-- blackframe filter

-- Demuxer for Leitch/Harris' VR native stream format (LXF)

-- RTP depacketization of the X-QT QuickTime format

-- SAP (Session Announcement Protocol, RFC 2974) muxer and demuxer

-- cropdetect filter

-- ffmpeg -crop* options removed

-- transpose filter added

-- ffmpeg -force_key_frames option added

-- demuxer for receiving raw rtp:// URLs without an SDP description

-- single stream LATM/LOAS decoder

-- setpts filter added

-- Win64 support for optimized asm functions

-- MJPEG/AVI1 to JPEG/JFIF bitstream filter

-- ASS subtitle encoder and decoder

-- IEC 61937 encapsulation for E-AC3 and TrueHD (for HDMI passthrough)

-- overlay filter added

-- rename aspect filter to setdar, and pixelaspect to setsar

-- IEC 61937 demuxer

-- Mobotix .mxg demuxer

-- frei0r source added

-- hqdn3d filter added

-- RTP depacketization of QCELP

-- FLAC parser added

-- gradfun filter added

-- AMR-WB decoder

-- replace the ocv_smooth filter with a more generic ocv filter

-- Windows Televison (WTV) demuxer

-- FFmpeg metadata format muxer and demuxer

-- SubRip (srt) subtitle decoder

-- floating-point AC-3 encoder added

+- fix autodetection of E-AC-3 substream samples

+- performance fix for seekable HTTP

+- backport AAC-HE v2 from trunk

+- add missing VP80 fourcc code for the VP8 codec

+- small documentation fixes

+- fix several potentially exploitable issues in the FLIC decoder

+  (addresses CVE-2010-3429)

 

 

 version 0.6:

@@ -79,7 +18,7 @@

 - deprecated vhook subsystem removed

 - deprecated old scaler removed

 - VQF demuxer

-- Alpha channel scaler

+- alpha channel scaler

 - PCX encoder

 - RTP packetization of H.263

 - RTP packetization of AMR

@@ -148,7 +87,11 @@

 - 35% faster VP3/Theora decoding

 - faster AAC decoding

 - faster H.264 decoding

-- RealAudio 1.0 (14.4K) encoder

+- WebM support in Matroska de/muxer

+- low overhead Ogg muxing

+- VP8 de/encoding via libvpx

+- CODEC_CAP_EXPERIMENTAL added

+

 

 

 version 0.5:

@@ -313,6 +256,7 @@

 - generic metadata API

 

 

+

 version 0.4.9-pre1:

 

 - DV encoder, DV muxer

@@ -397,6 +341,7 @@

 - FunCom ISS audio file demuxer and according ADPCM decoding

 

 

+

 version 0.4.8:

 

 - MPEG-2 video encoding (Michael)

@@ -408,6 +353,7 @@

 - Duck DK3 and DK4 ADPCM audio decoders (Mike Melanson)

 

 

+

 version 0.4.7:

 

 - RealAudio 1.0 (14_4) and 2.0 (28_8) native decoders. Author unknown, code from mplayerhq

@@ -449,6 +395,7 @@

 .. And lots more new enhancements and fixes.

 

 

+

 version 0.4.6:

 

 - completely new integer only MPEG audio layer 1/2/3 decoder rewritten

@@ -486,6 +433,7 @@

 - 16-bit and 15-bit RGB/BGR/GBR support (Bisqwit)

 

 

+

 version 0.4.5:

 

 - some header fixes (Zdenek Kabelac <kabi at informatics.muni.cz>)

@@ -517,6 +465,7 @@

 - added JPEG image format support (input/output)

 

 

+

 version 0.4.4:

 

 - fixed some std header definitions (Bjorn Lindgren

@@ -542,6 +491,7 @@

   segfault)

 

 

+

 version 0.4.3:

 

 - BGR24 patch (initial patch by Jeroen Vreeken <pe1rxq at amsat.org>)

@@ -563,6 +513,7 @@

   instead of a protocol)

 

 

+

 version 0.4.2:

 

 - added H.263/MPEG-4/MSMPEG4 decoding support. MPEG-4 decoding support

@@ -593,6 +544,7 @@

 - factorized some motion estimation code

 

 

+

 version 0.4.0:

 

 - removing grab code from ffserver and moved it to ffmpeg. Added

@@ -621,11 +573,13 @@

   codecs

 

 

+

 version 0.3.4:

 

 - added stereo in MPEG audio encoder

 

 

+

 version 0.3.3:

 

 - added 'high quality' mode which use motion vectors. It can be used in

@@ -634,12 +588,14 @@

   bitrates and large GOP size

 

 

+

 version 0.3.2: small fixes

 

 - ASF fixes

 - put_seek bug fix

 

 

+

 version 0.3.1: added avi/divx support

 

 - added AVI support

@@ -647,4 +603,5 @@

 - added sound for flash format (not tested)

 

 

+

 version 0.3: initial public release

diff -u ffmpeg/cmdutils.c ffmpeg-0.6.1/cmdutils.c

--- ffmpeg/cmdutils.c 2011-01-08 09:07:51.374711421 -0800

+++ ffmpeg-0.6.1/cmdutils.c 2010-05-23 11:50:16.000000000 -0700

@@ -36,9 +36,7 @@

 #include "libpostproc/postprocess.h"

 #include "libavutil/avstring.h"

 #include "libavutil/pixdesc.h"

-#include "libavutil/eval.h"

 #include "libavcodec/opt.h"

-#include "libavcore/avcore.h"

 #include "cmdutils.h"

 #include "version.h"

 #if CONFIG_NETWORK

@@ -49,47 +47,18 @@

 #endif

 

 const char **opt_names;

-const char **opt_values;

 static int opt_name_count;

 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];

 AVFormatContext *avformat_opts;

 struct SwsContext *sws_opts;

 

-const int this_year = 2011;

-

-void init_opts(void)

-{

-    int i;

-    for (i = 0; i < AVMEDIA_TYPE_NB; i++)

-        avcodec_opts[i] = avcodec_alloc_context2(i);

-    avformat_opts = avformat_alloc_context();

-#if CONFIG_SWSCALE

-    sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);

-#endif

-}

-

-void uninit_opts(void)

-{

-    int i;

-    for (i = 0; i < AVMEDIA_TYPE_NB; i++)

-        av_freep(&avcodec_opts[i]);

-    av_freep(&avformat_opts->key);

-    av_freep(&avformat_opts);

-#if CONFIG_SWSCALE

-    av_freep(&sws_opts);

-#endif

-}

-

-void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)

-{

-    vfprintf(stdout, fmt, vl);

-}

+const int this_year = 2010;

 

 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)

 {

     char *tail;

     const char *error;

-    double d = av_strtod(numstr, &tail);

+    double d = strtod(numstr, &tail);

     if (*tail)

         error= "Expected number for %s but found: %s/n";

     else if (d < min || d > max)

@@ -222,21 +191,21 @@

     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; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){

+    for(type=0; type<AVMEDIA_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 && avformat_opts)

+    if(!o)

         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);

     if(!o && sws_opts)

         ret = av_set_string3(sws_opts, opt, arg, 1, &o);

     if(!o){

-        if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])

+        if(opt[0] == 'a')

             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);

-        else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])

+        else if(opt[0] == 'v')

             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);

-        else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])

+        else if(opt[0] == 's')

             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);

     }

     if (o && ret < 0) {

@@ -244,35 +213,17 @@

         exit(1);

     }

     if (!o) {

-        AVCodec *p = NULL;

-        AVOutputFormat *oformat = NULL;

-        while ((p=av_codec_next(p))){

-            AVClass *c= p->priv_class;

-            if(c && av_find_opt(&c, opt, NULL, 0, 0))

-                break;

-        }

-        if (!p) {

-            while ((oformat = av_oformat_next(oformat))) {

-                const AVClass *c = oformat->priv_class;

-                if (c && av_find_opt(&c, opt, NULL, 0, 0))

-                    break;

-            }

-        }

-        if(!p && !oformat){

-            fprintf(stderr, "Unrecognized option '%s'/n", opt);

-            exit(1);

-        }

+        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_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));

-    opt_values[opt_name_count]= o ? NULL : arg;

     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));

-    opt_names[opt_name_count++]= o ? o->name : opt;

+    opt_names[opt_name_count++]= o->name;

 

-    if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))

+    if(avcodec_opts[0]->debug || avformat_opts->debug)

         av_log_set_level(AV_LOG_DEBUG);

     return 0;

 }

@@ -325,22 +276,9 @@

     return 0;

 }

 

-void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)

+void set_context_opts(void *ctx, void *opts_ctx, int flags)

 {

     int i;

-    void *priv_ctx=NULL;

-    if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){

-        AVCodecContext *avctx= ctx;

-        if(codec && codec->priv_class && avctx->priv_data){

-            priv_ctx= avctx->priv_data;

-        }

-    } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {

-        AVFormatContext *avctx = ctx;

-        if (avctx->oformat && avctx->oformat->priv_class) {

-            priv_ctx = avctx->priv_data;

-        }

-    }

-

     for(i=0; i<opt_name_count; i++){

         char buf[256];

         const AVOption *opt;

@@ -348,12 +286,6 @@

         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */

         if(str && ((opt->flags & flags) == flags))

             av_set_string3(ctx, opt_names[i], str, 1, NULL);

-        /* We need to use a differnt system to pass options to the private context because

-           it is not known which codec and thus context kind that will be when parsing options

-           we thus use opt_values directly instead of opts_ctx */

-        if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){

-            av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);

-        }

     }

 }

 

@@ -367,51 +299,46 @@

     fprintf(stderr, "%s: %s/n", filename, errbuf_ptr);

 }

 

-static int warned_cfg = 0;

+#define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent)             /

+    if (CONFIG_##LIBNAME) {                                             /

+        unsigned int version = libname##_version();                     /

+        fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d/n",    /

+                indent? "  " : "", #libname,                            /

+                LIB##LIBNAME##_VERSION_MAJOR,                           /

+                LIB##LIBNAME##_VERSION_MINOR,                           /

+                LIB##LIBNAME##_VERSION_MICRO,                           /

+                version >> 16, version >> 8 & 0xff, version & 0xff);    /

+    }

+

+static void print_all_lib_versions(FILE* outstream, int indent)

+{

+    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);

+    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);

+    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);

+    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);

+    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);

+    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);

+    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);

+}

 

-#define INDENT        1

-#define SHOW_VERSION  2

-#define SHOW_CONFIG   4

+static void maybe_print_config(const char *lib, const char *cfg)

+{

+    static int warned_cfg;

 

-#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 /

-    if (CONFIG_##LIBNAME) {                                             /

-        const char *indent = flags & INDENT? "  " : "";                 /

-        if (flags & SHOW_VERSION) {                                     /

-            unsigned int version = libname##_version();                 /

-            fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d/n", /

-                    indent, #libname,                                   /

-                    LIB##LIBNAME##_VERSION_MAJOR,                       /

-                    LIB##LIBNAME##_VERSION_MINOR,                       /

-                    LIB##LIBNAME##_VERSION_MICRO,                       /

-                    version >> 16, version >> 8 & 0xff, version & 0xff); /

-        }                                                               /

-        if (flags & SHOW_CONFIG) {                                      /

-            const char *cfg = libname##_configuration();                /

-            if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    /

-                if (!warned_cfg) {                                      /

-                    fprintf(outstream,                                  /

-                            "%sWARNING: library configuration mismatch/n", /

-                            indent);                                    /

-                    warned_cfg = 1;                                     /

-                }                                                       /

-                fprintf(stderr, "%s%-11s configuration: %s/n",          /

-                        indent, #libname, cfg);                         /

-            }                                                           /

-        }                                                               /

-    }                                                                   /

-

-static void print_all_libs_info(FILE* outstream, int flags)

-{

-    PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);

-    PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);

-    PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);

-    PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);

-    PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);

-    PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);

-    PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);

-    PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);

+    if (strcmp(FFMPEG_CONFIGURATION, cfg)) {

+        if (!warned_cfg) {

+            fprintf(stderr, "  WARNING: library configuration mismatch/n");

+            warned_cfg = 1;

+        }

+        fprintf(stderr, "  %-11s configuration: %s/n", lib, cfg);

+    }

 }

 

+#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 the FFmpeg developers/n",

@@ -419,13 +346,19 @@

     fprintf(stderr, "  built on %s %s with %s %s/n",

             __DATE__, __TIME__, CC_TYPE, CC_VERSION);

     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "/n");

-    print_all_libs_info(stderr, INDENT|SHOW_CONFIG);

-    print_all_libs_info(stderr, INDENT|SHOW_VERSION);

+    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());

+    PRINT_LIB_CONFIG(POSTPROC, "libpostproc", postproc_configuration());

+    print_all_lib_versions(stderr, 1);

 }

 

 void show_version(void) {

     printf("%s " FFMPEG_VERSION "/n", program_name);

-    print_all_libs_info(stdout, SHOW_VERSION);

+    print_all_lib_versions(stdout, 0);

 }

 

 void show_license(void)

@@ -646,18 +579,9 @@

 {

     URLProtocol *up=NULL;

 

-    printf("Supported file protocols:/n"

-           "I.. = Input  supported/n"

-           ".O. = Output supported/n"

-           "..S = Seek   supported/n"

-           "FLAGS NAME/n"

-           "----- /n");

+    printf("Supported file protocols:/n");

     while((up = av_protocol_next(up)))

-        printf("%c%c%c   %s/n",

-               up->url_read  ? 'I' : '.',

-               up->url_write ? 'O' : '.',

-               up->url_seek  ? 'S' : '.',

-               up->name);

+        printf("%s/n", up->name);

 }

 

 void show_filters(void)

@@ -738,123 +662,3 @@

     fclose(f);

     return 0;

 }

-

-void init_pts_correction(PtsCorrectionContext *ctx)

-{

-    ctx->num_faulty_pts = ctx->num_faulty_dts = 0;

-    ctx->last_pts = ctx->last_dts = INT64_MIN;

-}

-

-int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)

-{

-    int64_t pts = AV_NOPTS_VALUE;

-

-    if (dts != AV_NOPTS_VALUE) {

-        ctx->num_faulty_dts += dts <= ctx->last_dts;

-        ctx->last_dts = dts;

-    }

-    if (reordered_pts != AV_NOPTS_VALUE) {

-        ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;

-        ctx->last_pts = reordered_pts;

-    }

-    if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)

-       && reordered_pts != AV_NOPTS_VALUE)

-        pts = reordered_pts;

-    else

-        pts = dts;

-

-    return pts;

-}

-

-FILE *get_preset_file(char *filename, size_t filename_size,

-                      const char *preset_name, int is_path, const char *codec_name)

-{

-    FILE *f = NULL;

-    int i;

-    const char *base[3]= { getenv("FFMPEG_DATADIR"),

-                           getenv("HOME"),

-                           FFMPEG_DATADIR,

-                         };

-

-    if (is_path) {

-        av_strlcpy(filename, preset_name, filename_size);

-        f = fopen(filename, "r");

-    } else {

-        for (i = 0; i < 3 && !f; i++) {

-            if (!base[i])

-                continue;

-            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);

-            f = fopen(filename, "r");

-            if (!f && codec_name) {

-                snprintf(filename, filename_size,

-                         "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);

-                f = fopen(filename, "r");

-            }

-        }

-    }

-

-    return f;

-}

-

-#if CONFIG_AVFILTER

-

-static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)

-{

-    FFSinkContext *priv = ctx->priv;

-

-    if (!opaque)

-        return AVERROR(EINVAL);

-    *priv = *(FFSinkContext *)opaque;

-

-    return 0;

-}

-

-static void null_end_frame(AVFilterLink *inlink) { }

-

-static int ffsink_query_formats(AVFilterContext *ctx)

-{

-    FFSinkContext *priv = ctx->priv;

-    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };

-

-    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));

-    return 0;

-}

-

-AVFilter ffsink = {

-    .name      = "ffsink",

-    .priv_size = sizeof(FFSinkContext),

-    .init      = ffsink_init,

-

-    .query_formats = ffsink_query_formats,

-

-    .inputs    = (AVFilterPad[]) {{ .name          = "default",

-                                    .type          = AVMEDIA_TYPE_VIDEO,

-                                    .end_frame     = null_end_frame,

-                                    .min_perms     = AV_PERM_READ, },

-                                  { .name = NULL }},

-    .outputs   = (AVFilterPad[]) {{ .name = NULL }},

-};

-

-int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,

-                             AVFilterBufferRef **picref_ptr, AVRational *tb)

-{

-    int ret;

-    AVFilterBufferRef *picref;

-

-    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)

-        return ret;

-    if (!(picref = ctx->inputs[0]->cur_buf))

-        return AVERROR(ENOENT);

-    *picref_ptr = picref;

-    ctx->inputs[0]->cur_buf = NULL;

-    *tb = ctx->inputs[0]->time_base;

-

-    memcpy(frame->data,     picref->data,     sizeof(frame->data));

-    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));

-    frame->interlaced_frame = picref->video->interlaced;

-    frame->top_field_first  = picref->video->top_field_first;

-

-    return 1;

-}

-

-#endif /* CONFIG_AVFILTER */

diff -u ffmpeg/cmdutils.d ffmpeg-0.6.1/cmdutils.d

--- ffmpeg/cmdutils.d 2011-01-08 09:20:02.429718727 -0800

+++ ffmpeg-0.6.1/cmdutils.d 2011-01-07 06:54:42.874853455 -0800

@@ -1,14 +1,10 @@

 cmdutils.o: cmdutils.c config.h libavformat/avformat.h /

- libavcodec/avcodec.h libavcore/samplefmt.h libavutil/avutil.h /

- libavutil/common.h libavutil/attributes.h libavutil/avconfig.h /

- libavutil/mem.h libavutil/avutil.h libavutil/error.h /

- libavutil/mathematics.h libavutil/rational.h /

+ libavcodec/avcodec.h libavutil/avutil.h libavutil/common.h /

+ libavutil/attributes.h libavutil/mem.h libavutil/error.h /

+ libavutil/avutil.h libavutil/mathematics.h libavutil/rational.h /

  libavutil/intfloat_readwrite.h libavutil/log.h libavutil/pixfmt.h /

- libavutil/cpu.h libavcore/audioconvert.h libavcore/avcore.h /

- libavformat/avio.h libavutil/common.h libavutil/log.h /

- libavfilter/avfilter.h libavcore/avcore.h libavdevice/avdevice.h /

- libswscale/swscale.h libpostproc/postprocess.h libavutil/avstring.h /

- libavutil/pixdesc.h libavutil/eval.h libavutil/avutil.h libavcodec/opt.h /

- libavutil/rational.h libavcodec/avcodec.h libavutil/opt.h /

- libavcore/avcore.h cmdutils.h libavcodec/avcodec.h version.h /

- libavformat/network.h config.h

+ libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

+ libavfilter/avfilter.h libavdevice/avdevice.h libswscale/swscale.h /

+ libpostproc/postprocess.h libavutil/avstring.h libavutil/pixdesc.h /

+ libavcodec/opt.h libavutil/rational.h libavcodec/avcodec.h cmdutils.h /

+ libavcodec/avcodec.h version.h libavformat/network.h config.h

diff -u ffmpeg/cmdutils.h ffmpeg-0.6.1/cmdutils.h

--- ffmpeg/cmdutils.h 2011-01-08 09:07:51.374711421 -0800

+++ ffmpeg-0.6.1/cmdutils.h 2010-05-19 04:46:40.000000000 -0700

@@ -45,30 +45,13 @@

 extern struct SwsContext *sws_opts;

 

 /**

- * Initialize the cmdutils option system, in particular

- * allocate the *_opts contexts.

- */

-void init_opts(void);

-/**

- * Uninitialize the cmdutils option system, in particular

- * free the *_opts contexts and their contents.

- */

-void uninit_opts(void);

-

-/**

- * Trivial log callback.

- * Only suitable for show_help and similar since it lacks prefix handling.

- */

-void log_callback_help(void* ptr, int level, const char* fmt, va_list vl);

-

-/**

  * Fallback for options that are not explicitly handled, these will be

  * parsed through AVOptions.

  */

 int opt_default(const char *opt, const char *arg);

 

 /**

- * Set the libav* libraries log level.

+ * Sets the libav* libraries log level.

  */

 int opt_loglevel(const char *opt, const char *arg);

 

@@ -78,8 +61,8 @@

 int opt_timelimit(const char *opt, const char *arg);

 

 /**

- * Parse a string and return its corresponding value as a double.

- * Exit from the application if the string cannot be correctly

+ * Parses a string and returns its corresponding value as a double.

+ * Exits from the application if the string cannot be correctly

  * parsed or the corresponding value is invalid.

  *

  * @param context the context of the value to be set (e.g. the

@@ -93,8 +76,8 @@

 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max);

 

 /**

- * Parse a string specifying a time and return its corresponding

- * value as a number of microseconds. Exit from the application if

+ * Parses a string specifying a time and returns its corresponding

+ * value as a number of microseconds. Exits from the application if

  * the string cannot be correctly parsed.

  *

  * @param context the context of the value to be set (e.g. the

@@ -139,9 +122,9 @@

 void show_help_options(const OptionDef *options, const char *msg, int mask, int value);

 

 /**

- * Parse the command line arguments.

+ * Parses the command line arguments.

  * @param options Array with the definitions required to interpret every

- * option of the form: -option_name [argument]

+ * option of the form: -<option_name> [<argument>]

  * @param parse_arg_function Name of the function called to process every

  * argument without a leading option name flag. NULL if such arguments do

  * not have to be processed.

@@ -149,10 +132,10 @@

 void parse_options(int argc, char **argv, const OptionDef *options,

                    void (* parse_arg_function)(const char*));

 

-void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec);

+void set_context_opts(void *ctx, void *opts_ctx, int flags);

 

 /**

- * Print an error message to stderr, indicating filename and a human

+ * Prints an error message to stderr, indicating filename and a human

  * readable description of the error code err.

  *

  * If strerror_r() is not available the use of this function in a

@@ -165,140 +148,76 @@

 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts);

 

 /**

- * Print the program banner to stderr. The banner contents depend on the

+ * Prints the program banner to stderr. The banner contents depend on the

  * current version of the repository and of the libav* libraries used by

  * the program.

  */

 void show_banner(void);

 

 /**

- * Print the version of the program to stdout. The version message

+ * Prints the version of the program to stdout. The version message

  * depends on the current versions of the repository and of the libav*

  * libraries.

  */

 void show_version(void);

 

 /**

- * Print the license of the program to stdout. The license depends on

+ * Prints the license of the program to stdout. The license depends on

  * the license of the libraries compiled into the program.

  */

 void show_license(void);

 

 /**

- * Print a listing containing all the formats supported by the

+ * Prints a listing containing all the formats supported by the

  * program.

  */

 void show_formats(void);

 

 /**

- * Print a listing containing all the codecs supported by the

+ * Prints a listing containing all the codecs supported by the

  * program.

  */

 void show_codecs(void);

 

 /**

- * Print a listing containing all the filters supported by the

+ * Prints a listing containing all the filters supported by the

  * program.

  */

 void show_filters(void);

 

 /**

- * Print a listing containing all the bit stream filters supported by the

+ * Prints a listing containing all the bit stream filters supported by the

  * program.

  */

 void show_bsfs(void);

 

 /**

- * Print a listing containing all the protocols supported by the

+ * Prints a listing containing all the protocols supported by the

  * program.

  */

 void show_protocols(void);

 

 /**

- * Print a listing containing all the pixel formats supported by the

+ * Prints a listing containing all the pixel formats supported by the

  * program.

  */

 void show_pix_fmts(void);

 

 /**

- * Return a positive value if a line read from standard input

- * starts with [yY], otherwise return 0.

+ * Returns a positive value if reads from standard input a line

+ * starting with [yY], otherwise returns 0.

  */

 int read_yesno(void);

 

 /**

- * Read the file with name filename, and put its content in a newly

+ * Reads the file with name filename, and puts its content in a newly

  * allocated 0-terminated buffer.

  *

- * @param bufptr location where pointer to buffer is returned

- * @param size   location where size of buffer is returned

+ * @param bufptr puts here the pointer to the newly allocated buffer

+ * @param size puts here the size of the newly allocated buffer

  * @return 0 in case of success, a negative value corresponding to an

  * AVERROR error code in case of failure.

  */

 int read_file(const char *filename, char **bufptr, size_t *size);

 

-typedef struct {

-    int64_t num_faulty_pts; /// Number of incorrect PTS values so far

-    int64_t num_faulty_dts; /// Number of incorrect DTS values so far

-    int64_t last_pts;       /// PTS of the last frame

-    int64_t last_dts;       /// DTS of the last frame

-} PtsCorrectionContext;

-

-/**

- * Reset the state of the PtsCorrectionContext.

- */

-void init_pts_correction(PtsCorrectionContext *ctx);

-

-/**

- * Attempt to guess proper monotonic timestamps for decoded video frames

- * which might have incorrect times. Input timestamps may wrap around, in

- * which case the output will as well.

- *

- * @param pts the pts field of the decoded AVPacket, as passed through

- * AVCodecContext.reordered_opaque

- * @param dts the dts field of the decoded AVPacket

- * @return one of the input values, may be AV_NOPTS_VALUE

- */

-int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t pts, int64_t dts);

-

-/**

- * Get a file corresponding to a preset file.

- *

- * If is_path is non-zero, look for the file in the path preset_name.

- * Otherwise search for a file named arg.ffpreset in the directories

- * $FFMPEG_DATADIR (if set), $HOME/.ffmpeg, and in the datadir defined

- * at configuration time, in that order. If no such file is found and

- * codec_name is defined, then search for a file named

- * codec_name-preset_name.ffpreset in the above-mentioned directories.

- *

- * @param filename buffer where the name of the found filename is written

- * @param filename_size size in bytes of the filename buffer

- * @param preset_name name of the preset to search

- * @param is_path tell if preset_name is a filename path

- * @param codec_name name of the codec for which to look for the

- * preset, may be NULL

- */

-FILE *get_preset_file(char *filename, size_t filename_size,

-                      const char *preset_name, int is_path, const char *codec_name);

-

-#if CONFIG_AVFILTER

-#include "libavfilter/avfilter.h"

-

-typedef struct {

-    enum PixelFormat pix_fmt;

-} FFSinkContext;

-

-extern AVFilter ffsink;

-

-/**

- * Extract a frame from sink.

- *

- * @return a negative error in case of failure, 1 if one frame has

- * been extracted successfully.

- */

-int get_filtered_video_frame(AVFilterContext *sink, AVFrame *frame,

-                             AVFilterBufferRef **picref, AVRational *pts_tb);

-

-#endif /* CONFIG_AVFILTER */

-

 #endif /* FFMPEG_CMDUTILS_H */

Binary files ffmpeg/cmdutils.o and ffmpeg-0.6.1/cmdutils.o differ

diff -u ffmpeg/common.mak ffmpeg-0.6.1/common.mak

--- ffmpeg/common.mak 2011-01-08 09:07:51.378864202 -0800

+++ ffmpeg-0.6.1/common.mak 2010-03-17 07:43:04.000000000 -0700

@@ -26,19 +26,15 @@

 MSG    = $@

 M      = @$(call ECHO,$(TAG),$@);

 $(foreach VAR,$(BRIEF), /

-    $(eval override $(VAR) = @$$(call ECHO,$(VAR),$$(MSG)); $($(VAR))))

-$(foreach VAR,$(SILENT),$(eval override $(VAR) = @$($(VAR))))

+    $(eval $(VAR) = @$$(call ECHO,$(VAR),$$(MSG)); $($(VAR))))

+$(foreach VAR,$(SILENT),$(eval $(VAR) = @$($(VAR))))

 $(eval INSTALL = @$(call ECHO,INSTALL,$$(^:$(SRC_DIR)/%=%)); $(INSTALL))

 endif

 

-ALLFFLIBS = avcodec avcore avdevice avfilter avformat avutil postproc swscale

+ALLFFLIBS = avcodec avdevice avfilter avformat avutil postproc swscale

 

-IFLAGS   := -I$(BUILD_ROOT_REL) -I$(SRC_PATH)

-CPPFLAGS := $(IFLAGS) $(CPPFLAGS)

+CPPFLAGS := -I$(BUILD_ROOT_REL) -I$(SRC_PATH) $(CPPFLAGS)

 CFLAGS   += $(ECFLAGS)

-YASMFLAGS += $(IFLAGS) -Pconfig.asm

-

-HOSTCFLAGS += $(IFLAGS)

 

 %.o: %.c

  $(CCDEP)

@@ -58,10 +54,6 @@

 

 %.c %.h: TAG = GEN

 

-# Dummy rule to stop make trying to rebuild removed or renamed headers

-%.h:

- @:

-

 install: install-libs install-headers

 install-libs: install-libs-yes

 

@@ -107,8 +99,11 @@

 $(HOSTPROGS): %$(HOSTEXESUF): %.o

  $(HOSTCC) $(HOSTLDFLAGS) -o $@ $< $(HOSTLIBS)

 

+DEPS := $(OBJS:.o=.d)

+depend dep: $(DEPS)

+

 CLEANSUFFIXES     = *.d *.o *~ *.ho *.map *.ver

 DISTCLEANSUFFIXES = *.pc

 LIBSUFFIXES       = *.a *.lib *.so *.so.* *.dylib *.dll *.def *.dll.a *.exp

 

--include $(wildcard $(OBJS:.o=.d))

+-include $(wildcard $(DEPS))

Only in ffmpeg: .config

Only in ffmpeg: config.asm

Only in ffmpeg-0.6.1: config.err

Only in ffmpeg: config.fate

diff -u ffmpeg/config.h ffmpeg-0.6.1/config.h

--- ffmpeg/config.h 2011-01-08 09:12:55.899438456 -0800

+++ ffmpeg-0.6.1/config.h 2011-01-07 06:49:27.444200516 -0800

@@ -1,16 +1,15 @@

 /* Automatically generated by configure - do not modify! */

 #ifndef FFMPEG_CONFIG_H

 #define FFMPEG_CONFIG_H

-#define FFMPEG_CONFIGURATION "--enable-shared --enable-gpl --enable-nonfree --enable-pthreads --enable-libfaac --enable-libmp3lame --enable-libtheora --enable-libxvid --enable-x11grab --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopencore-amrnb --enable-version3"

-#define FFMPEG_LICENSE "nonfree and unredistributable"

+#define FFMPEG_CONFIGURATION ""

+#define FFMPEG_LICENSE "LGPL version 2.1 or later"

 #define FFMPEG_DATADIR "/usr/local/share/ffmpeg"

 #define CC_TYPE "gcc"

 #define CC_VERSION __VERSION__

 #define restrict restrict

-#define ASMALIGN(ZEROBITS) ".p2align " #ZEROBITS "/n/t"

+#define ASMALIGN(ZEROBITS) ".align 1 << " #ZEROBITS "/n/t"

 #define EXTERN_PREFIX ""

 #define EXTERN_ASM 

-#define SLIBSUF ".so"

 #define ARCH_ALPHA 0

 #define ARCH_ARM 0

 #define ARCH_AVR32 0

@@ -49,11 +48,11 @@

 #define HAVE_SSSE3 1

 #define HAVE_VIS 0

 #define HAVE_BIGENDIAN 0

-#define HAVE_FAST_UNALIGNED 1

-#define HAVE_PTHREADS 1

+#define HAVE_BEOSTHREADS 0

+#define HAVE_OS2THREADS 0

+#define HAVE_PTHREADS 0

 #define HAVE_W32THREADS 0

-#define HAVE_ALIGNED_STACK 1

-#define HAVE_ALSA_ASOUNDLIB_H 1

+#define HAVE_ALSA_ASOUNDLIB_H 0

 #define HAVE_ALTIVEC_H 0

 #define HAVE_ARPA_INET_H 1

 #define HAVE_ATTRIBUTE_MAY_ALIAS 1

@@ -78,16 +77,14 @@

 #define HAVE_FAST_64BIT 0

 #define HAVE_FAST_CLZ 1

 #define HAVE_FAST_CMOV 0

-#define HAVE_FCNTL 1

+#define HAVE_FAST_UNALIGNED 1

 #define HAVE_FORK 1

 #define HAVE_GETADDRINFO 1

 #define HAVE_GETHRTIME 0

 #define HAVE_GETPROCESSMEMORYINFO 0

 #define HAVE_GETPROCESSTIMES 0

 #define HAVE_GETRUSAGE 1

-#define HAVE_GNU_AS 1

 #define HAVE_STRUCT_RUSAGE_RU_MAXRSS 1

-#define HAVE_IBM_ASM 0

 #define HAVE_INET_ATON 1

 #define HAVE_INLINE_ASM 1

 #define HAVE_ISATTY 1

@@ -107,23 +104,20 @@

 #define HAVE_MACHINE_IOCTL_BT848_H 0

 #define HAVE_MACHINE_IOCTL_METEOR_H 0

 #define HAVE_MALLOC_H 1

-#define HAVE_MAPVIEWOFFILE 0

 #define HAVE_MEMALIGN 1

 #define HAVE_MKSTEMP 1

-#define HAVE_MMAP 1

 #define HAVE_PLD 0

 #define HAVE_POSIX_MEMALIGN 1

 #define HAVE_ROUND 1

 #define HAVE_ROUNDF 1

-#define HAVE_SDL 1

-#define HAVE_SDL_VIDEO_SIZE 1

+#define HAVE_SDL 0

+#define HAVE_SDL_VIDEO_SIZE 0

 #define HAVE_SETMODE 0

 #define HAVE_SOCKLEN_T 1

 #define HAVE_SOUNDCARD_H 0

 #define HAVE_POLL_H 1

 #define HAVE_SETRLIMIT 1

 #define HAVE_STRERROR_R 1

-#define HAVE_STRTOK_R 1

 #define HAVE_STRUCT_ADDRINFO 1

 #define HAVE_STRUCT_IPV6_MREQ 1

 #define HAVE_STRUCT_SOCKADDR_IN6 1

@@ -139,14 +133,13 @@

 #define HAVE_SYS_VIDEOIO_H 0

 #define HAVE_TEN_OPERANDS 1

 #define HAVE_TERMIOS_H 1

-#define HAVE_THREADS 1

+#define HAVE_THREADS 0

 #define HAVE_TRUNCF 1

 #define HAVE_VFP_ARGS 0

 #define HAVE_VIRTUALALLOC 0

 #define HAVE_WINSOCK2_H 0

 #define HAVE_XFORM_ASM 0

-#define HAVE_XMM_CLOBBERS 0

-#define HAVE_YASM 1

+#define HAVE_YASM 0

 #define CONFIG_BSFS 1

 #define CONFIG_DECODERS 1

 #define CONFIG_DEMUXERS 1

@@ -160,49 +153,48 @@

 #define CONFIG_PROTOCOLS 1

 #define CONFIG_AANDCT 1

 #define CONFIG_AVCODEC 1

-#define CONFIG_AVCORE 1

 #define CONFIG_AVDEVICE 1

-#define CONFIG_AVFILTER 1

+#define CONFIG_AVFILTER 0

+#define CONFIG_AVFILTER_LAVF 0

 #define CONFIG_AVFORMAT 1

 #define CONFIG_AVISYNTH 0

+#define CONFIG_BEOS_NETSERVER 0

 #define CONFIG_BZLIB 0

 #define CONFIG_DCT 1

-#define CONFIG_DOC 1

+#define CONFIG_DOC 0

 #define CONFIG_DWT 1

 #define CONFIG_DXVA2 0

 #define CONFIG_FASTDIV 1

 #define CONFIG_FFMPEG 1

-#define CONFIG_FFPLAY 1

+#define CONFIG_FFPLAY 0

 #define CONFIG_FFPROBE 1

 #define CONFIG_FFSERVER 1

 #define CONFIG_FFT 1

-#define CONFIG_FREI0R 0

 #define CONFIG_GOLOMB 1

-#define CONFIG_GPL 1

+#define CONFIG_GPL 0

+#define CONFIG_GPROF 0

 #define CONFIG_GRAY 0

 #define CONFIG_H264DSP 1

-#define CONFIG_H264PRED 1

 #define CONFIG_HARDCODED_TABLES 0

-#define CONFIG_HUFFMAN 1

 #define CONFIG_LIBDC1394 0

 #define CONFIG_LIBDIRAC 0

-#define CONFIG_LIBFAAC 1

+#define CONFIG_LIBFAAC 0

+#define CONFIG_LIBFAAD 0

+#define CONFIG_LIBFAADBIN 0

 #define CONFIG_LIBGSM 0

-#define CONFIG_LIBMP3LAME 1

+#define CONFIG_LIBMP3LAME 0

 #define CONFIG_LIBNUT 0

-#define CONFIG_LIBOPENCORE_AMRNB 1

-#define CONFIG_LIBOPENCORE_AMRWB 1

-#define CONFIG_LIBOPENCV 0

+#define CONFIG_LIBOPENCORE_AMRNB 0

+#define CONFIG_LIBOPENCORE_AMRWB 0

 #define CONFIG_LIBOPENJPEG 0

 #define CONFIG_LIBRTMP 0

 #define CONFIG_LIBSCHROEDINGER 0

 #define CONFIG_LIBSPEEX 0

-#define CONFIG_LIBTHEORA 1

+#define CONFIG_LIBTHEORA 0

 #define CONFIG_LIBVORBIS 0

 #define CONFIG_LIBVPX 0

 #define CONFIG_LIBX264 0

-#define CONFIG_LIBXAVS 0

-#define CONFIG_LIBXVID 1

+#define CONFIG_LIBXVID 0

 #define CONFIG_LPC 1

 #define CONFIG_LSP 1

 #define CONFIG_MDCT 1

@@ -210,13 +202,13 @@

 #define CONFIG_MLIB 0

 #define CONFIG_MPEGAUDIO_HP 1

 #define CONFIG_NETWORK 1

-#define CONFIG_NONFREE 1

+#define CONFIG_NONFREE 0

 #define CONFIG_PIC 0

 #define CONFIG_POSTPROC 0

+#define CONFIG_POWERPC_PERF 0

 #define CONFIG_RDFT 1

-#define CONFIG_RTPDEC 1

 #define CONFIG_RUNTIME_CPUDETECT 0

-#define CONFIG_SHARED 1

+#define CONFIG_SHARED 0

 #define CONFIG_SMALL 0

 #define CONFIG_SRAM 0

 #define CONFIG_STATIC 1

@@ -224,16 +216,15 @@

 #define CONFIG_SWSCALE_ALPHA 1

 #define CONFIG_VAAPI 0

 #define CONFIG_VDPAU 0

-#define CONFIG_VERSION3 1

-#define CONFIG_X11GRAB 1

-#define CONFIG_ZLIB 1

+#define CONFIG_VERSION3 0

+#define CONFIG_X11GRAB 0

+#define CONFIG_ZLIB 0

 #define CONFIG_AVUTIL 1

-#define CONFIG_GPLV3 1

+#define CONFIG_GPLV3 0

 #define CONFIG_LGPLV3 0

 #define CONFIG_AASC_DECODER 1

 #define CONFIG_AMV_DECODER 1

 #define CONFIG_ANM_DECODER 1

-#define CONFIG_ANSI_DECODER 1

 #define CONFIG_ASV1_DECODER 1

 #define CONFIG_ASV2_DECODER 1

 #define CONFIG_AURA_DECODER 1

@@ -254,7 +245,7 @@

 #define CONFIG_DPX_DECODER 1

 #define CONFIG_DSICINVIDEO_DECODER 1

 #define CONFIG_DVVIDEO_DECODER 1

-#define CONFIG_DXA_DECODER 1

+#define CONFIG_DXA_DECODER 0

 #define CONFIG_EACMV_DECODER 1

 #define CONFIG_EAMAD_DECODER 1

 #define CONFIG_EATGQ_DECODER 1

@@ -266,7 +257,7 @@

 #define CONFIG_ESCAPE124_DECODER 1

 #define CONFIG_FFV1_DECODER 1

 #define CONFIG_FFVHUFF_DECODER 1

-#define CONFIG_FLASHSV_DECODER 1

+#define CONFIG_FLASHSV_DECODER 0

 #define CONFIG_FLIC_DECODER 1

 #define CONFIG_FLV_DECODER 1

 #define CONFIG_FOURXM_DECODER 1

@@ -316,14 +307,12 @@

 #define CONFIG_PCX_DECODER 1

 #define CONFIG_PGM_DECODER 1

 #define CONFIG_PGMYUV_DECODER 1

-#define CONFIG_PICTOR_DECODER 1

-#define CONFIG_PNG_DECODER 1

+#define CONFIG_PNG_DECODER 0

 #define CONFIG_PPM_DECODER 1

 #define CONFIG_PTX_DECODER 1

 #define CONFIG_QDRAW_DECODER 1

 #define CONFIG_QPEG_DECODER 1

 #define CONFIG_QTRLE_DECODER 1

-#define CONFIG_R10K_DECODER 1

 #define CONFIG_R210_DECODER 1

 #define CONFIG_RAWVIDEO_DECODER 1

 #define CONFIG_RL2_DECODER 1

@@ -349,7 +338,7 @@

 #define CONFIG_TMV_DECODER 1

 #define CONFIG_TRUEMOTION1_DECODER 1

 #define CONFIG_TRUEMOTION2_DECODER 1

-#define CONFIG_TSCC_DECODER 1

+#define CONFIG_TSCC_DECODER 0

 #define CONFIG_TXD_DECODER 1

 #define CONFIG_ULTI_DECODER 1

 #define CONFIG_V210_DECODER 1

@@ -365,7 +354,6 @@

 #define CONFIG_VP6_DECODER 1

 #define CONFIG_VP6A_DECODER 1

 #define CONFIG_VP6F_DECODER 1

-#define CONFIG_VP8_DECODER 1

 #define CONFIG_VQA_DECODER 1

 #define CONFIG_WMV1_DECODER 1

 #define CONFIG_WMV2_DECODER 1

@@ -375,15 +363,13 @@

 #define CONFIG_XAN_WC3_DECODER 1

 #define CONFIG_XL_DECODER 1

 #define CONFIG_YOP_DECODER 1

-#define CONFIG_ZLIB_DECODER 1

-#define CONFIG_ZMBV_DECODER 1

+#define CONFIG_ZLIB_DECODER 0

+#define CONFIG_ZMBV_DECODER 0

 #define CONFIG_AAC_DECODER 1

-#define CONFIG_AAC_LATM_DECODER 1

 #define CONFIG_AC3_DECODER 1

 #define CONFIG_ALAC_DECODER 1

 #define CONFIG_ALS_DECODER 1

 #define CONFIG_AMRNB_DECODER 1

-#define CONFIG_AMRWB_DECODER 1

 #define CONFIG_APE_DECODER 1

 #define CONFIG_ATRAC1_DECODER 1

 #define CONFIG_ATRAC3_DECODER 1

@@ -394,22 +380,15 @@

 #define CONFIG_DSICINAUDIO_DECODER 1

 #define CONFIG_EAC3_DECODER 1

 #define CONFIG_FLAC_DECODER 1

-#define CONFIG_GSM_DECODER 1

-#define CONFIG_GSM_MS_DECODER 1

 #define CONFIG_IMC_DECODER 1

 #define CONFIG_MACE3_DECODER 1

 #define CONFIG_MACE6_DECODER 1

 #define CONFIG_MLP_DECODER 1

 #define CONFIG_MP1_DECODER 1

-#define CONFIG_MP1FLOAT_DECODER 1

 #define CONFIG_MP2_DECODER 1

-#define CONFIG_MP2FLOAT_DECODER 1

 #define CONFIG_MP3_DECODER 1

-#define CONFIG_MP3FLOAT_DECODER 1

 #define CONFIG_MP3ADU_DECODER 1

-#define CONFIG_MP3ADUFLOAT_DECODER 1

 #define CONFIG_MP3ON4_DECODER 1

-#define CONFIG_MP3ON4FLOAT_DECODER 1

 #define CONFIG_MPC7_DECODER 1

 #define CONFIG_MPC8_DECODER 1

 #define CONFIG_NELLYMOSER_DECODER 1

@@ -440,7 +419,6 @@

 #define CONFIG_PCM_F32LE_DECODER 1

 #define CONFIG_PCM_F64BE_DECODER 1

 #define CONFIG_PCM_F64LE_DECODER 1

-#define CONFIG_PCM_LXF_DECODER 1

 #define CONFIG_PCM_MULAW_DECODER 1

 #define CONFIG_PCM_S8_DECODER 1

 #define CONFIG_PCM_S16BE_DECODER 1

@@ -472,7 +450,6 @@

 #define CONFIG_ADPCM_EA_R2_DECODER 1

 #define CONFIG_ADPCM_EA_R3_DECODER 1

 #define CONFIG_ADPCM_EA_XAS_DECODER 1

-#define CONFIG_ADPCM_G722_DECODER 1

 #define CONFIG_ADPCM_G726_DECODER 1

 #define CONFIG_ADPCM_IMA_AMV_DECODER 1

 #define CONFIG_ADPCM_IMA_DK3_DECODER 1

@@ -492,23 +469,20 @@

 #define CONFIG_ADPCM_THP_DECODER 1

 #define CONFIG_ADPCM_XA_DECODER 1

 #define CONFIG_ADPCM_YAMAHA_DECODER 1

-#define CONFIG_ASS_DECODER 1

 #define CONFIG_DVBSUB_DECODER 1

 #define CONFIG_DVDSUB_DECODER 1

 #define CONFIG_PGSSUB_DECODER 1

-#define CONFIG_SRT_DECODER 1

 #define CONFIG_XSUB_DECODER 1

 #define CONFIG_LIBDIRAC_DECODER 0

+#define CONFIG_LIBFAAD_DECODER 0

 #define CONFIG_LIBGSM_DECODER 0

 #define CONFIG_LIBGSM_MS_DECODER 0

-#define CONFIG_LIBOPENCORE_AMRNB_DECODER 1

-#define CONFIG_LIBOPENCORE_AMRWB_DECODER 1

+#define CONFIG_LIBOPENCORE_AMRNB_DECODER 0

+#define CONFIG_LIBOPENCORE_AMRWB_DECODER 0

 #define CONFIG_LIBOPENJPEG_DECODER 0

 #define CONFIG_LIBSCHROEDINGER_DECODER 0

 #define CONFIG_LIBSPEEX_DECODER 0

 #define CONFIG_LIBVPX_DECODER 0

-#define CONFIG_A64MULTI_ENCODER 1

-#define CONFIG_A64MULTI5_ENCODER 1

 #define CONFIG_ASV1_ENCODER 1

 #define CONFIG_ASV2_ENCODER 1

 #define CONFIG_BMP_ENCODER 1

@@ -516,7 +490,7 @@

 #define CONFIG_DVVIDEO_ENCODER 1

 #define CONFIG_FFV1_ENCODER 1

 #define CONFIG_FFVHUFF_ENCODER 1

-#define CONFIG_FLASHSV_ENCODER 1

+#define CONFIG_FLASHSV_ENCODER 0

 #define CONFIG_FLV_ENCODER 1

 #define CONFIG_GIF_ENCODER 1

 #define CONFIG_H261_ENCODER 1

@@ -537,7 +511,7 @@

 #define CONFIG_PCX_ENCODER 1

 #define CONFIG_PGM_ENCODER 1

 #define CONFIG_PGMYUV_ENCODER 1

-#define CONFIG_PNG_ENCODER 1

+#define CONFIG_PNG_ENCODER 0

 #define CONFIG_PPM_ENCODER 1

 #define CONFIG_QTRLE_ENCODER 1

 #define CONFIG_RAWVIDEO_ENCODER 1

@@ -552,19 +526,16 @@

 #define CONFIG_V210_ENCODER 1

 #define CONFIG_WMV1_ENCODER 1

 #define CONFIG_WMV2_ENCODER 1

-#define CONFIG_ZLIB_ENCODER 1

-#define CONFIG_ZMBV_ENCODER 1

+#define CONFIG_ZLIB_ENCODER 0

+#define CONFIG_ZMBV_ENCODER 0

 #define CONFIG_AAC_ENCODER 1

 #define CONFIG_AC3_ENCODER 1

-#define CONFIG_AC3_FIXED_ENCODER 1

 #define CONFIG_ALAC_ENCODER 1

 #define CONFIG_FLAC_ENCODER 1

 #define CONFIG_MP2_ENCODER 1

 #define CONFIG_NELLYMOSER_ENCODER 1

-#define CONFIG_RA_144_ENCODER 1

 #define CONFIG_SONIC_ENCODER 1

 #define CONFIG_SONIC_LS_ENCODER 1

-#define CONFIG_VORBIS_ENCODER 1

 #define CONFIG_WMAV1_ENCODER 1

 #define CONFIG_WMAV2_ENCODER 1

 #define CONFIG_PCM_ALAW_ENCODER 1

@@ -591,34 +562,30 @@

 #define CONFIG_PCM_ZORK_ENCODER 1

 #define CONFIG_ROQ_DPCM_ENCODER 1

 #define CONFIG_ADPCM_ADX_ENCODER 1

-#define CONFIG_ADPCM_G722_ENCODER 1

 #define CONFIG_ADPCM_G726_ENCODER 1

 #define CONFIG_ADPCM_IMA_QT_ENCODER 1

 #define CONFIG_ADPCM_IMA_WAV_ENCODER 1

 #define CONFIG_ADPCM_MS_ENCODER 1

 #define CONFIG_ADPCM_SWF_ENCODER 1

 #define CONFIG_ADPCM_YAMAHA_ENCODER 1

-#define CONFIG_ASS_ENCODER 1

 #define CONFIG_DVBSUB_ENCODER 1

 #define CONFIG_DVDSUB_ENCODER 1

 #define CONFIG_XSUB_ENCODER 1

 #define CONFIG_LIBDIRAC_ENCODER 0

-#define CONFIG_LIBFAAC_ENCODER 1

+#define CONFIG_LIBFAAC_ENCODER 0

 #define CONFIG_LIBGSM_ENCODER 0

 #define CONFIG_LIBGSM_MS_ENCODER 0

-#define CONFIG_LIBMP3LAME_ENCODER 1

-#define CONFIG_LIBOPENCORE_AMRNB_ENCODER 1

+#define CONFIG_LIBMP3LAME_ENCODER 0

+#define CONFIG_LIBOPENCORE_AMRNB_ENCODER 0

 #define CONFIG_LIBSCHROEDINGER_ENCODER 0

-#define CONFIG_LIBTHEORA_ENCODER 1

+#define CONFIG_LIBTHEORA_ENCODER 0

 #define CONFIG_LIBVORBIS_ENCODER 0

 #define CONFIG_LIBVPX_ENCODER 0

 #define CONFIG_LIBX264_ENCODER 0

-#define CONFIG_LIBXAVS_ENCODER 0

-#define CONFIG_LIBXVID_ENCODER 1

+#define CONFIG_LIBXVID_ENCODER 0

 #define CONFIG_H263_VAAPI_HWACCEL 0

 #define CONFIG_H264_DXVA2_HWACCEL 0

 #define CONFIG_H264_VAAPI_HWACCEL 0

-#define CONFIG_MPEG2_DXVA2_HWACCEL 0

 #define CONFIG_MPEG2_VAAPI_HWACCEL 0

 #define CONFIG_MPEG4_VAAPI_HWACCEL 0

 #define CONFIG_VC1_DXVA2_HWACCEL 0

@@ -626,7 +593,6 @@

 #define CONFIG_WMV3_DXVA2_HWACCEL 0

 #define CONFIG_WMV3_VAAPI_HWACCEL 0

 #define CONFIG_AAC_PARSER 1

-#define CONFIG_AAC_LATM_PARSER 1

 #define CONFIG_AC3_PARSER 1

 #define CONFIG_CAVSVIDEO_PARSER 1

 #define CONFIG_DCA_PARSER 1

@@ -634,7 +600,6 @@

 #define CONFIG_DNXHD_PARSER 1

 #define CONFIG_DVBSUB_PARSER 1

 #define CONFIG_DVDSUB_PARSER 1

-#define CONFIG_FLAC_PARSER 1

 #define CONFIG_H261_PARSER 1

 #define CONFIG_H263_PARSER 1

 #define CONFIG_H264_PARSER 1

@@ -646,13 +611,10 @@

 #define CONFIG_PNM_PARSER 1

 #define CONFIG_VC1_PARSER 1

 #define CONFIG_VP3_PARSER 1

-#define CONFIG_VP8_PARSER 1

 #define CONFIG_AAC_ADTSTOASC_BSF 1

-#define CONFIG_CHOMP_BSF 1

 #define CONFIG_DUMP_EXTRADATA_BSF 1

 #define CONFIG_H264_MP4TOANNEXB_BSF 1

 #define CONFIG_IMX_DUMP_HEADER_BSF 1

-#define CONFIG_MJPEG2JPEG_BSF 1

 #define CONFIG_MJPEGA_DUMP_HEADER_BSF 1

 #define CONFIG_MP3_HEADER_COMPRESS_BSF 1

 #define CONFIG_MP3_HEADER_DECOMPRESS_BSF 1

@@ -668,7 +630,6 @@

 #define CONFIG_ANM_DEMUXER 1

 #define CONFIG_APC_DEMUXER 1

 #define CONFIG_APE_DEMUXER 1

-#define CONFIG_APPLEHTTP_DEMUXER 1

 #define CONFIG_ASF_DEMUXER 1

 #define CONFIG_ASS_DEMUXER 1

 #define CONFIG_AU_DEMUXER 1

@@ -693,13 +654,11 @@

 #define CONFIG_EA_CDATA_DEMUXER 1

 #define CONFIG_EAC3_DEMUXER 1

 #define CONFIG_FFM_DEMUXER 1

-#define CONFIG_FFMETADATA_DEMUXER 1

 #define CONFIG_FILMSTRIP_DEMUXER 1

 #define CONFIG_FLAC_DEMUXER 1

 #define CONFIG_FLIC_DEMUXER 1

 #define CONFIG_FLV_DEMUXER 1

 #define CONFIG_FOURXM_DEMUXER 1

-#define CONFIG_G722_DEMUXER 1

 #define CONFIG_GSM_DEMUXER 1

 #define CONFIG_GXF_DEMUXER 1

 #define CONFIG_H261_DEMUXER 1

@@ -713,9 +672,7 @@

 #define CONFIG_IPMOVIE_DEMUXER 1

 #define CONFIG_ISS_DEMUXER 1

 #define CONFIG_IV8_DEMUXER 1

-#define CONFIG_IVF_DEMUXER 1

 #define CONFIG_LMLM4_DEMUXER 1

-#define CONFIG_LXF_DEMUXER 1

 #define CONFIG_M4V_DEMUXER 1

 #define CONFIG_MATROSKA_DEMUXER 1

 #define CONFIG_MJPEG_DEMUXER 1

@@ -734,7 +691,6 @@

 #define CONFIG_MTV_DEMUXER 1

 #define CONFIG_MVI_DEMUXER 1

 #define CONFIG_MXF_DEMUXER 1

-#define CONFIG_MXG_DEMUXER 1

 #define CONFIG_NC_DEMUXER 1

 #define CONFIG_NSV_DEMUXER 1

 #define CONFIG_NUT_DEMUXER 1

@@ -769,10 +725,7 @@

 #define CONFIG_RM_DEMUXER 1

 #define CONFIG_ROQ_DEMUXER 1

 #define CONFIG_RPL_DEMUXER 1

-#define CONFIG_RSO_DEMUXER 1

-#define CONFIG_RTP_DEMUXER 1

 #define CONFIG_RTSP_DEMUXER 1

-#define CONFIG_SAP_DEMUXER 1

 #define CONFIG_SDP_DEMUXER 1

 #define CONFIG_SEGAFILM_DEMUXER 1

 #define CONFIG_SHORTEN_DEMUXER 1

@@ -780,8 +733,6 @@

 #define CONFIG_SMACKER_DEMUXER 1

 #define CONFIG_SOL_DEMUXER 1

 #define CONFIG_SOX_DEMUXER 1

-#define CONFIG_SPDIF_DEMUXER 1

-#define CONFIG_SRT_DEMUXER 1

 #define CONFIG_STR_DEMUXER 1

 #define CONFIG_SWF_DEMUXER 1

 #define CONFIG_THP_DEMUXER 1

@@ -790,7 +741,6 @@

 #define CONFIG_TRUEHD_DEMUXER 1

 #define CONFIG_TTA_DEMUXER 1

 #define CONFIG_TXD_DEMUXER 1

-#define CONFIG_TTY_DEMUXER 1

 #define CONFIG_VC1_DEMUXER 1

 #define CONFIG_VC1T_DEMUXER 1

 #define CONFIG_VMD_DEMUXER 1

@@ -801,13 +751,11 @@

 #define CONFIG_WC3_DEMUXER 1

 #define CONFIG_WSAUD_DEMUXER 1

 #define CONFIG_WSVQA_DEMUXER 1

-#define CONFIG_WTV_DEMUXER 1

 #define CONFIG_WV_DEMUXER 1

 #define CONFIG_XA_DEMUXER 1

 #define CONFIG_YOP_DEMUXER 1

 #define CONFIG_YUV4MPEGPIPE_DEMUXER 1

 #define CONFIG_LIBNUT_DEMUXER 0

-#define CONFIG_A64_MUXER 1

 #define CONFIG_AC3_MUXER 1

 #define CONFIG_ADTS_MUXER 1

 #define CONFIG_AIFF_MUXER 1

@@ -818,7 +766,6 @@

 #define CONFIG_AU_MUXER 1

 #define CONFIG_AVI_MUXER 1

 #define CONFIG_AVM2_MUXER 1

-#define CONFIG_CAVSVIDEO_MUXER 1

 #define CONFIG_CRC_MUXER 1

 #define CONFIG_DAUD_MUXER 1

 #define CONFIG_DIRAC_MUXER 1

@@ -827,13 +774,10 @@

 #define CONFIG_DV_MUXER 1

 #define CONFIG_EAC3_MUXER 1

 #define CONFIG_FFM_MUXER 1

-#define CONFIG_FFMETADATA_MUXER 1

 #define CONFIG_FILMSTRIP_MUXER 1

 #define CONFIG_FLAC_MUXER 1

 #define CONFIG_FLV_MUXER 1

 #define CONFIG_FRAMECRC_MUXER 1

-#define CONFIG_FRAMEMD5_MUXER 1

-#define CONFIG_G722_MUXER 1

 #define CONFIG_GIF_MUXER 1

 #define CONFIG_GXF_MUXER 1

 #define CONFIG_H261_MUXER 1

@@ -843,7 +787,6 @@

 #define CONFIG_IMAGE2PIPE_MUXER 1

 #define CONFIG_IPOD_MUXER 1

 #define CONFIG_M4V_MUXER 1

-#define CONFIG_MD5_MUXER 1

 #define CONFIG_MATROSKA_MUXER 1

 #define CONFIG_MATROSKA_AUDIO_MUXER 1

 #define CONFIG_MJPEG_MUXER 1

@@ -891,13 +834,10 @@

 #define CONFIG_RAWVIDEO_MUXER 1

 #define CONFIG_RM_MUXER 1

 #define CONFIG_ROQ_MUXER 1

-#define CONFIG_RSO_MUXER 1

 #define CONFIG_RTP_MUXER 1

 #define CONFIG_RTSP_MUXER 1

-#define CONFIG_SAP_MUXER 1

 #define CONFIG_SOX_MUXER 1

 #define CONFIG_SPDIF_MUXER 1

-#define CONFIG_SRT_MUXER 1

 #define CONFIG_SWF_MUXER 1

 #define CONFIG_TG2_MUXER 1

 #define CONFIG_TGP_MUXER 1

@@ -908,48 +848,21 @@

 #define CONFIG_WEBM_MUXER 1

 #define CONFIG_YUV4MPEGPIPE_MUXER 1

 #define CONFIG_LIBNUT_MUXER 0

-#define CONFIG_ANULL_FILTER 1

-#define CONFIG_ANULLSRC_FILTER 1

-#define CONFIG_ANULLSINK_FILTER 1

-#define CONFIG_BLACKFRAME_FILTER 1

-#define CONFIG_COPY_FILTER 1

+#define CONFIG_ASPECT_FILTER 1

 #define CONFIG_CROP_FILTER 1

-#define CONFIG_CROPDETECT_FILTER 1

-#define CONFIG_DRAWBOX_FILTER 1

-#define CONFIG_FIFO_FILTER 1

 #define CONFIG_FORMAT_FILTER 1

-#define CONFIG_FREI0R_FILTER 0

-#define CONFIG_GRADFUN_FILTER 1

-#define CONFIG_HFLIP_FILTER 1

-#define CONFIG_HQDN3D_FILTER 1

 #define CONFIG_NOFORMAT_FILTER 1

 #define CONFIG_NULL_FILTER 1

-#define CONFIG_OCV_FILTER 0

-#define CONFIG_OVERLAY_FILTER 1

-#define CONFIG_PAD_FILTER 1

-#define CONFIG_PIXDESCTEST_FILTER 1

+#define CONFIG_PIXELASPECT_FILTER 1

 #define CONFIG_SCALE_FILTER 1

-#define CONFIG_SETDAR_FILTER 1

-#define CONFIG_SETPTS_FILTER 1

-#define CONFIG_SETSAR_FILTER 1

-#define CONFIG_SETTB_FILTER 1

 #define CONFIG_SLICIFY_FILTER 1

-#define CONFIG_TRANSPOSE_FILTER 1

 #define CONFIG_UNSHARP_FILTER 1

 #define CONFIG_VFLIP_FILTER 1

-#define CONFIG_YADIF_FILTER 1

-#define CONFIG_BUFFER_FILTER 1

-#define CONFIG_COLOR_FILTER 1

-#define CONFIG_FREI0R_SRC_FILTER 0

 #define CONFIG_NULLSRC_FILTER 1

 #define CONFIG_NULLSINK_FILTER 1

-#define CONFIG_CONCAT_PROTOCOL 1

 #define CONFIG_FILE_PROTOCOL 1

 #define CONFIG_GOPHER_PROTOCOL 1

 #define CONFIG_HTTP_PROTOCOL 1

-#define CONFIG_MMSH_PROTOCOL 1

-#define CONFIG_MMST_PROTOCOL 1

-#define CONFIG_MD5_PROTOCOL 1

 #define CONFIG_PIPE_PROTOCOL 1

 #define CONFIG_RTMP_PROTOCOL 1

 #define CONFIG_RTMPT_PROTOCOL 1

@@ -959,7 +872,9 @@

 #define CONFIG_RTP_PROTOCOL 1

 #define CONFIG_TCP_PROTOCOL 1

 #define CONFIG_UDP_PROTOCOL 1

-#define CONFIG_ALSA_INDEV 1

+#define CONFIG_CONCAT_PROTOCOL 1

+#define CONFIG_ALSA_INDEV 0

+#define CONFIG_AUDIO_BEOS_INDEV 0

 #define CONFIG_BKTR_INDEV 0

 #define CONFIG_DV1394_INDEV 1

 #define CONFIG_JACK_INDEV 0

@@ -969,6 +884,7 @@

 #define CONFIG_VFWCAP_INDEV 0

 #define CONFIG_X11_GRAB_DEVICE_INDEV 0

 #define CONFIG_LIBDC1394_INDEV 0

-#define CONFIG_ALSA_OUTDEV 1

+#define CONFIG_ALSA_OUTDEV 0

+#define CONFIG_AUDIO_BEOS_OUTDEV 0

 #define CONFIG_OSS_OUTDEV 1

 #endif /* FFMPEG_CONFIG_H */

Only in ffmpeg: config.log

diff -u ffmpeg/config.mak ffmpeg-0.6.1/config.mak

--- ffmpeg/config.mak 2011-01-08 09:12:55.846734442 -0800

+++ ffmpeg-0.6.1/config.mak 2011-01-07 06:49:27.406699842 -0800

@@ -1,7 +1,7 @@

 # Automatically generated by configure - do not modify!

 ifndef FFMPEG_CONFIG_MAK

 FFMPEG_CONFIG_MAK=1

-FFMPEG_CONFIGURATION=--enable-shared --enable-gpl --enable-nonfree --enable-pthreads --enable-libfaac --enable-libmp3lame --enable-libtheora --enable-libxvid --enable-x11grab --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopencore-amrnb --enable-version3

+FFMPEG_CONFIGURATION=

 prefix=/usr/local

 LIBDIR=$(DESTDIR)${prefix}/lib

 SHLIBDIR=$(DESTDIR)${prefix}/lib

@@ -9,10 +9,9 @@

 BINDIR=$(DESTDIR)${prefix}/bin

 DATADIR=$(DESTDIR)${prefix}/share/ffmpeg

 MANDIR=$(DESTDIR)${prefix}/share/man

-SRC_PATH="/home/zhangbin/Documents/ffmpeg"

-SRC_PATH_BARE=/home/zhangbin/Documents/ffmpeg

-BUILD_ROOT="/home/zhangbin/Documents/ffmpeg"

-CC_IDENT=gcc 4.4.3 (Ubuntu 4.4.3-4ubuntu5)

+SRC_PATH="/home/zhangbin/Documents/ffmpeg-0.6.1"

+SRC_PATH_BARE=/home/zhangbin/Documents/ffmpeg-0.6.1

+BUILD_ROOT="/home/zhangbin/Documents/ffmpeg-0.6.1"

 ARCH=x86

 CC=gcc

 AS=gcc

@@ -26,13 +25,13 @@

 LN_S=ln -sf

 STRIP=strip

 CPPFLAGS= -D_ISOC99_SOURCE -D_POSIX_C_SOURCE=200112 -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE

-CFLAGS=   -std=c99 -fomit-frame-pointer -pthread -g -Wdeclaration-after-statement -Wall -Wno-parentheses -Wno-switch -Wdisabled-optimization -Wpointer-arith -Wredundant-decls -Wno-pointer-sign -Wcast-qual -Wwrite-strings -Wtype-limits -Wundef -Wmissing-prototypes -O3 -fno-math-errno -fno-signed-zeros -fno-tree-vectorize -Werror=implicit-function-declaration -Werror=missing-prototypes

+CFLAGS=   -std=c99 -fomit-frame-pointer -g -Wdeclaration-after-statement -Wall -Wno-switch -Wdisabled-optimization -Wpointer-arith -Wredundant-decls -Wno-pointer-sign -Wcast-qual -Wwrite-strings -Wtype-limits -Wundef -Wmissing-prototypes -O3 -fno-math-errno -fno-signed-zeros -fno-tree-vectorize -Werror=implicit -Werror=missing-prototypes

 ASFLAGS=   -g

 CC_O=-o $@

-LDFLAGS= -Wl,--warn-common -Wl,--as-needed -Wl,-rpath-link,$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,$(BUILD_ROOT)/libswscale -Wl,-rpath-link,$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,$(BUILD_ROOT)/libavformat -Wl,-rpath-link,$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,$(BUILD_ROOT)/libavcore -Wl,-rpath-link,$(BUILD_ROOT)/libavutil -Wl,-Bsymbolic

+LDFLAGS=  -Wl,--warn-common -Wl,--as-needed -Wl,-rpath-link,$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,$(BUILD_ROOT)/libswscale -Wl,-rpath-link,$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,$(BUILD_ROOT)/libavformat -Wl,-rpath-link,$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,$(BUILD_ROOT)/libavutil -Wl,-Bsymbolic

 FFSERVERLDFLAGS=-Wl,-E

 SHFLAGS=-shared -Wl,-soname,$$(@F) -Wl,--version-script,$(SUBDIR)lib$(NAME).ver

-YASMFLAGS=-f elf  -g dwarf2

+YASMFLAGS=-f elf -DARCH_X86_32 -g dwarf2

 BUILDSUF=

 FULLNAME=$(NAME)$(BUILDSUF)

 LIBPREF=lib

@@ -54,10 +53,10 @@

 HOSTLIBS=-lm

 TARGET_EXEC=

 TARGET_PATH=$(CURDIR)

-SDL_LIBS=-L/usr/lib -lSDL

-SDL_CFLAGS=-I/usr/include/SDL -D_GNU_SOURCE=1 -D_REENTRANT

+SDL_LIBS=

+SDL_CFLAGS=

 LIB_INSTALL_EXTRA_CMD=$$(RANLIB) "$(LIBDIR)/$(LIBNAME)"

-EXTRALIBS=-ldl -lasound -lxvidcore -ltheoraenc -ltheoradec -logg -lopencore-amrwb -lopencore-amrnb -lmp3lame -lfaac -lm -pthread -lz 

+EXTRALIBS=  -lm -ldl

 INSTALL=install

 LIBTARGET=

 SLIBNAME=$(SLIBPREF)$(FULLNAME)$(SLIBSUF)

@@ -68,21 +67,19 @@

 SLIB_INSTALL_EXTRA_CMD=

 SLIB_UNINSTALL_EXTRA_CMD=

 SAMPLES=

-libswscale_VERSION=0.12.0

+libswscale_VERSION=0.11.0

 libswscale_VERSION_MAJOR=0

 libpostproc_VERSION=51.2.0

 libpostproc_VERSION_MAJOR=51

-libavcodec_VERSION=52.107.0

+libavcodec_VERSION=52.72.2

 libavcodec_VERSION_MAJOR=52

-libavcore_VERSION=0.16.0

-libavcore_VERSION_MAJOR=0

-libavdevice_VERSION=52.2.3

+libavdevice_VERSION=52.2.0

 libavdevice_VERSION_MAJOR=52

-libavformat_VERSION=52.92.0

+libavformat_VERSION=52.64.2

 libavformat_VERSION_MAJOR=52

-libavutil_VERSION=50.36.0

+libavutil_VERSION=50.15.1

 libavutil_VERSION_MAJOR=50

-libavfilter_VERSION=1.72.0

+libavfilter_VERSION=1.19.0

 libavfilter_VERSION_MAJOR=1

 !ARCH_ALPHA=yes

 !ARCH_ARM=yes

@@ -122,11 +119,11 @@

 HAVE_SSSE3=yes

 !HAVE_VIS=yes

 !HAVE_BIGENDIAN=yes

-HAVE_FAST_UNALIGNED=yes

-HAVE_PTHREADS=yes

+!HAVE_BEOSTHREADS=yes

+!HAVE_OS2THREADS=yes

+!HAVE_PTHREADS=yes

 !HAVE_W32THREADS=yes

-HAVE_ALIGNED_STACK=yes

-HAVE_ALSA_ASOUNDLIB_H=yes

+!HAVE_ALSA_ASOUNDLIB_H=yes

 !HAVE_ALTIVEC_H=yes

 HAVE_ARPA_INET_H=yes

 HAVE_ATTRIBUTE_MAY_ALIAS=yes

@@ -151,16 +148,14 @@

 !HAVE_FAST_64BIT=yes

 HAVE_FAST_CLZ=yes

 !HAVE_FAST_CMOV=yes

-HAVE_FCNTL=yes

+HAVE_FAST_UNALIGNED=yes

 HAVE_FORK=yes

 HAVE_GETADDRINFO=yes

 !HAVE_GETHRTIME=yes

 !HAVE_GETPROCESSMEMORYINFO=yes

 !HAVE_GETPROCESSTIMES=yes

 HAVE_GETRUSAGE=yes

-HAVE_GNU_AS=yes

 HAVE_STRUCT_RUSAGE_RU_MAXRSS=yes

-!HAVE_IBM_ASM=yes

 HAVE_INET_ATON=yes

 HAVE_INLINE_ASM=yes

 HAVE_ISATTY=yes

@@ -180,23 +175,20 @@

 !HAVE_MACHINE_IOCTL_BT848_H=yes

 !HAVE_MACHINE_IOCTL_METEOR_H=yes

 HAVE_MALLOC_H=yes

-!HAVE_MAPVIEWOFFILE=yes

 HAVE_MEMALIGN=yes

 HAVE_MKSTEMP=yes

-HAVE_MMAP=yes

 !HAVE_PLD=yes

 HAVE_POSIX_MEMALIGN=yes

 HAVE_ROUND=yes

 HAVE_ROUNDF=yes

-HAVE_SDL=yes

-HAVE_SDL_VIDEO_SIZE=yes

+!HAVE_SDL=yes

+!HAVE_SDL_VIDEO_SIZE=yes

 !HAVE_SETMODE=yes

 HAVE_SOCKLEN_T=yes

 !HAVE_SOUNDCARD_H=yes

 HAVE_POLL_H=yes

 HAVE_SETRLIMIT=yes

 HAVE_STRERROR_R=yes

-HAVE_STRTOK_R=yes

 HAVE_STRUCT_ADDRINFO=yes

 HAVE_STRUCT_IPV6_MREQ=yes

 HAVE_STRUCT_SOCKADDR_IN6=yes

@@ -212,14 +204,13 @@

 !HAVE_SYS_VIDEOIO_H=yes

 HAVE_TEN_OPERANDS=yes

 HAVE_TERMIOS_H=yes

-HAVE_THREADS=yes

+!HAVE_THREADS=yes

 HAVE_TRUNCF=yes

 !HAVE_VFP_ARGS=yes

 !HAVE_VIRTUALALLOC=yes

 !HAVE_WINSOCK2_H=yes

 !HAVE_XFORM_ASM=yes

-!HAVE_XMM_CLOBBERS=yes

-HAVE_YASM=yes

+!HAVE_YASM=yes

 CONFIG_BSFS=yes

 CONFIG_DECODERS=yes

 CONFIG_DEMUXERS=yes

@@ -233,49 +224,48 @@

 CONFIG_PROTOCOLS=yes

 CONFIG_AANDCT=yes

 CONFIG_AVCODEC=yes

-CONFIG_AVCORE=yes

 CONFIG_AVDEVICE=yes

-CONFIG_AVFILTER=yes

+!CONFIG_AVFILTER=yes

+!CONFIG_AVFILTER_LAVF=yes

 CONFIG_AVFORMAT=yes

 !CONFIG_AVISYNTH=yes

+!CONFIG_BEOS_NETSERVER=yes

 !CONFIG_BZLIB=yes

 CONFIG_DCT=yes

-CONFIG_DOC=yes

+!CONFIG_DOC=yes

 CONFIG_DWT=yes

 !CONFIG_DXVA2=yes

 CONFIG_FASTDIV=yes

 CONFIG_FFMPEG=yes

-CONFIG_FFPLAY=yes

+!CONFIG_FFPLAY=yes

 CONFIG_FFPROBE=yes

 CONFIG_FFSERVER=yes

 CONFIG_FFT=yes

-!CONFIG_FREI0R=yes

 CONFIG_GOLOMB=yes

-CONFIG_GPL=yes

+!CONFIG_GPL=yes

+!CONFIG_GPROF=yes

 !CONFIG_GRAY=yes

 CONFIG_H264DSP=yes

-CONFIG_H264PRED=yes

 !CONFIG_HARDCODED_TABLES=yes

-CONFIG_HUFFMAN=yes

 !CONFIG_LIBDC1394=yes

 !CONFIG_LIBDIRAC=yes

-CONFIG_LIBFAAC=yes

+!CONFIG_LIBFAAC=yes

+!CONFIG_LIBFAAD=yes

+!CONFIG_LIBFAADBIN=yes

 !CONFIG_LIBGSM=yes

-CONFIG_LIBMP3LAME=yes

+!CONFIG_LIBMP3LAME=yes

 !CONFIG_LIBNUT=yes

-CONFIG_LIBOPENCORE_AMRNB=yes

-CONFIG_LIBOPENCORE_AMRWB=yes

-!CONFIG_LIBOPENCV=yes

+!CONFIG_LIBOPENCORE_AMRNB=yes

+!CONFIG_LIBOPENCORE_AMRWB=yes

 !CONFIG_LIBOPENJPEG=yes

 !CONFIG_LIBRTMP=yes

 !CONFIG_LIBSCHROEDINGER=yes

 !CONFIG_LIBSPEEX=yes

-CONFIG_LIBTHEORA=yes

+!CONFIG_LIBTHEORA=yes

 !CONFIG_LIBVORBIS=yes

 !CONFIG_LIBVPX=yes

 !CONFIG_LIBX264=yes

-!CONFIG_LIBXAVS=yes

-CONFIG_LIBXVID=yes

+!CONFIG_LIBXVID=yes

 CONFIG_LPC=yes

 CONFIG_LSP=yes

 CONFIG_MDCT=yes

@@ -283,13 +273,13 @@

 !CONFIG_MLIB=yes

 CONFIG_MPEGAUDIO_HP=yes

 CONFIG_NETWORK=yes

-CONFIG_NONFREE=yes

+!CONFIG_NONFREE=yes

 !CONFIG_PIC=yes

 !CONFIG_POSTPROC=yes

+!CONFIG_POWERPC_PERF=yes

 CONFIG_RDFT=yes

-CONFIG_RTPDEC=yes

 !CONFIG_RUNTIME_CPUDETECT=yes

-CONFIG_SHARED=yes

+!CONFIG_SHARED=yes

 !CONFIG_SMALL=yes

 !CONFIG_SRAM=yes

 CONFIG_STATIC=yes

@@ -297,16 +287,15 @@

 CONFIG_SWSCALE_ALPHA=yes

 !CONFIG_VAAPI=yes

 !CONFIG_VDPAU=yes

-CONFIG_VERSION3=yes

-CONFIG_X11GRAB=yes

-CONFIG_ZLIB=yes

+!CONFIG_VERSION3=yes

+!CONFIG_X11GRAB=yes

+!CONFIG_ZLIB=yes

 CONFIG_AVUTIL=yes

-CONFIG_GPLV3=yes

+!CONFIG_GPLV3=yes

 !CONFIG_LGPLV3=yes

 CONFIG_AASC_DECODER=yes

 CONFIG_AMV_DECODER=yes

 CONFIG_ANM_DECODER=yes

-CONFIG_ANSI_DECODER=yes

 CONFIG_ASV1_DECODER=yes

 CONFIG_ASV2_DECODER=yes

 CONFIG_AURA_DECODER=yes

@@ -327,7 +316,7 @@

 CONFIG_DPX_DECODER=yes

 CONFIG_DSICINVIDEO_DECODER=yes

 CONFIG_DVVIDEO_DECODER=yes

-CONFIG_DXA_DECODER=yes

+!CONFIG_DXA_DECODER=yes

 CONFIG_EACMV_DECODER=yes

 CONFIG_EAMAD_DECODER=yes

 CONFIG_EATGQ_DECODER=yes

@@ -339,7 +328,7 @@

 CONFIG_ESCAPE124_DECODER=yes

 CONFIG_FFV1_DECODER=yes

 CONFIG_FFVHUFF_DECODER=yes

-CONFIG_FLASHSV_DECODER=yes

+!CONFIG_FLASHSV_DECODER=yes

 CONFIG_FLIC_DECODER=yes

 CONFIG_FLV_DECODER=yes

 CONFIG_FOURXM_DECODER=yes

@@ -389,14 +378,12 @@

 CONFIG_PCX_DECODER=yes

 CONFIG_PGM_DECODER=yes

 CONFIG_PGMYUV_DECODER=yes

-CONFIG_PICTOR_DECODER=yes

-CONFIG_PNG_DECODER=yes

+!CONFIG_PNG_DECODER=yes

 CONFIG_PPM_DECODER=yes

 CONFIG_PTX_DECODER=yes

 CONFIG_QDRAW_DECODER=yes

 CONFIG_QPEG_DECODER=yes

 CONFIG_QTRLE_DECODER=yes

-CONFIG_R10K_DECODER=yes

 CONFIG_R210_DECODER=yes

 CONFIG_RAWVIDEO_DECODER=yes

 CONFIG_RL2_DECODER=yes

@@ -422,7 +409,7 @@

 CONFIG_TMV_DECODER=yes

 CONFIG_TRUEMOTION1_DECODER=yes

 CONFIG_TRUEMOTION2_DECODER=yes

-CONFIG_TSCC_DECODER=yes

+!CONFIG_TSCC_DECODER=yes

 CONFIG_TXD_DECODER=yes

 CONFIG_ULTI_DECODER=yes

 CONFIG_V210_DECODER=yes

@@ -438,7 +425,6 @@

 CONFIG_VP6_DECODER=yes

 CONFIG_VP6A_DECODER=yes

 CONFIG_VP6F_DECODER=yes

-CONFIG_VP8_DECODER=yes

 CONFIG_VQA_DECODER=yes

 CONFIG_WMV1_DECODER=yes

 CONFIG_WMV2_DECODER=yes

@@ -448,15 +434,13 @@

 CONFIG_XAN_WC3_DECODER=yes

 CONFIG_XL_DECODER=yes

 CONFIG_YOP_DECODER=yes

-CONFIG_ZLIB_DECODER=yes

-CONFIG_ZMBV_DECODER=yes

+!CONFIG_ZLIB_DECODER=yes

+!CONFIG_ZMBV_DECODER=yes

 CONFIG_AAC_DECODER=yes

-CONFIG_AAC_LATM_DECODER=yes

 CONFIG_AC3_DECODER=yes

 CONFIG_ALAC_DECODER=yes

 CONFIG_ALS_DECODER=yes

 CONFIG_AMRNB_DECODER=yes

-CONFIG_AMRWB_DECODER=yes

 CONFIG_APE_DECODER=yes

 CONFIG_ATRAC1_DECODER=yes

 CONFIG_ATRAC3_DECODER=yes

@@ -467,22 +451,15 @@

 CONFIG_DSICINAUDIO_DECODER=yes

 CONFIG_EAC3_DECODER=yes

 CONFIG_FLAC_DECODER=yes

-CONFIG_GSM_DECODER=yes

-CONFIG_GSM_MS_DECODER=yes

 CONFIG_IMC_DECODER=yes

 CONFIG_MACE3_DECODER=yes

 CONFIG_MACE6_DECODER=yes

 CONFIG_MLP_DECODER=yes

 CONFIG_MP1_DECODER=yes

-CONFIG_MP1FLOAT_DECODER=yes

 CONFIG_MP2_DECODER=yes

-CONFIG_MP2FLOAT_DECODER=yes

 CONFIG_MP3_DECODER=yes

-CONFIG_MP3FLOAT_DECODER=yes

 CONFIG_MP3ADU_DECODER=yes

-CONFIG_MP3ADUFLOAT_DECODER=yes

 CONFIG_MP3ON4_DECODER=yes

-CONFIG_MP3ON4FLOAT_DECODER=yes

 CONFIG_MPC7_DECODER=yes

 CONFIG_MPC8_DECODER=yes

 CONFIG_NELLYMOSER_DECODER=yes

@@ -513,7 +490,6 @@

 CONFIG_PCM_F32LE_DECODER=yes

 CONFIG_PCM_F64BE_DECODER=yes

 CONFIG_PCM_F64LE_DECODER=yes

-CONFIG_PCM_LXF_DECODER=yes

 CONFIG_PCM_MULAW_DECODER=yes

 CONFIG_PCM_S8_DECODER=yes

 CONFIG_PCM_S16BE_DECODER=yes

@@ -545,7 +521,6 @@

 CONFIG_ADPCM_EA_R2_DECODER=yes

 CONFIG_ADPCM_EA_R3_DECODER=yes

 CONFIG_ADPCM_EA_XAS_DECODER=yes

-CONFIG_ADPCM_G722_DECODER=yes

 CONFIG_ADPCM_G726_DECODER=yes

 CONFIG_ADPCM_IMA_AMV_DECODER=yes

 CONFIG_ADPCM_IMA_DK3_DECODER=yes

@@ -565,23 +540,20 @@

 CONFIG_ADPCM_THP_DECODER=yes

 CONFIG_ADPCM_XA_DECODER=yes

 CONFIG_ADPCM_YAMAHA_DECODER=yes

-CONFIG_ASS_DECODER=yes

 CONFIG_DVBSUB_DECODER=yes

 CONFIG_DVDSUB_DECODER=yes

 CONFIG_PGSSUB_DECODER=yes

-CONFIG_SRT_DECODER=yes

 CONFIG_XSUB_DECODER=yes

 !CONFIG_LIBDIRAC_DECODER=yes

+!CONFIG_LIBFAAD_DECODER=yes

 !CONFIG_LIBGSM_DECODER=yes

 !CONFIG_LIBGSM_MS_DECODER=yes

-CONFIG_LIBOPENCORE_AMRNB_DECODER=yes

-CONFIG_LIBOPENCORE_AMRWB_DECODER=yes

+!CONFIG_LIBOPENCORE_AMRNB_DECODER=yes

+!CONFIG_LIBOPENCORE_AMRWB_DECODER=yes

 !CONFIG_LIBOPENJPEG_DECODER=yes

 !CONFIG_LIBSCHROEDINGER_DECODER=yes

 !CONFIG_LIBSPEEX_DECODER=yes

 !CONFIG_LIBVPX_DECODER=yes

-CONFIG_A64MULTI_ENCODER=yes

-CONFIG_A64MULTI5_ENCODER=yes

 CONFIG_ASV1_ENCODER=yes

 CONFIG_ASV2_ENCODER=yes

 CONFIG_BMP_ENCODER=yes

@@ -589,7 +561,7 @@

 CONFIG_DVVIDEO_ENCODER=yes

 CONFIG_FFV1_ENCODER=yes

 CONFIG_FFVHUFF_ENCODER=yes

-CONFIG_FLASHSV_ENCODER=yes

+!CONFIG_FLASHSV_ENCODER=yes

 CONFIG_FLV_ENCODER=yes

 CONFIG_GIF_ENCODER=yes

 CONFIG_H261_ENCODER=yes

@@ -610,7 +582,7 @@

 CONFIG_PCX_ENCODER=yes

 CONFIG_PGM_ENCODER=yes

 CONFIG_PGMYUV_ENCODER=yes

-CONFIG_PNG_ENCODER=yes

+!CONFIG_PNG_ENCODER=yes

 CONFIG_PPM_ENCODER=yes

 CONFIG_QTRLE_ENCODER=yes

 CONFIG_RAWVIDEO_ENCODER=yes

@@ -625,19 +597,16 @@

 CONFIG_V210_ENCODER=yes

 CONFIG_WMV1_ENCODER=yes

 CONFIG_WMV2_ENCODER=yes

-CONFIG_ZLIB_ENCODER=yes

-CONFIG_ZMBV_ENCODER=yes

+!CONFIG_ZLIB_ENCODER=yes

+!CONFIG_ZMBV_ENCODER=yes

 CONFIG_AAC_ENCODER=yes

 CONFIG_AC3_ENCODER=yes

-CONFIG_AC3_FIXED_ENCODER=yes

 CONFIG_ALAC_ENCODER=yes

 CONFIG_FLAC_ENCODER=yes

 CONFIG_MP2_ENCODER=yes

 CONFIG_NELLYMOSER_ENCODER=yes

-CONFIG_RA_144_ENCODER=yes

 CONFIG_SONIC_ENCODER=yes

 CONFIG_SONIC_LS_ENCODER=yes

-CONFIG_VORBIS_ENCODER=yes

 CONFIG_WMAV1_ENCODER=yes

 CONFIG_WMAV2_ENCODER=yes

 CONFIG_PCM_ALAW_ENCODER=yes

@@ -664,34 +633,30 @@

 CONFIG_PCM_ZORK_ENCODER=yes

 CONFIG_ROQ_DPCM_ENCODER=yes

 CONFIG_ADPCM_ADX_ENCODER=yes

-CONFIG_ADPCM_G722_ENCODER=yes

 CONFIG_ADPCM_G726_ENCODER=yes

 CONFIG_ADPCM_IMA_QT_ENCODER=yes

 CONFIG_ADPCM_IMA_WAV_ENCODER=yes

 CONFIG_ADPCM_MS_ENCODER=yes

 CONFIG_ADPCM_SWF_ENCODER=yes

 CONFIG_ADPCM_YAMAHA_ENCODER=yes

-CONFIG_ASS_ENCODER=yes

 CONFIG_DVBSUB_ENCODER=yes

 CONFIG_DVDSUB_ENCODER=yes

 CONFIG_XSUB_ENCODER=yes

 !CONFIG_LIBDIRAC_ENCODER=yes

-CONFIG_LIBFAAC_ENCODER=yes

+!CONFIG_LIBFAAC_ENCODER=yes

 !CONFIG_LIBGSM_ENCODER=yes

 !CONFIG_LIBGSM_MS_ENCODER=yes

-CONFIG_LIBMP3LAME_ENCODER=yes

-CONFIG_LIBOPENCORE_AMRNB_ENCODER=yes

+!CONFIG_LIBMP3LAME_ENCODER=yes

+!CONFIG_LIBOPENCORE_AMRNB_ENCODER=yes

 !CONFIG_LIBSCHROEDINGER_ENCODER=yes

-CONFIG_LIBTHEORA_ENCODER=yes

+!CONFIG_LIBTHEORA_ENCODER=yes

 !CONFIG_LIBVORBIS_ENCODER=yes

 !CONFIG_LIBVPX_ENCODER=yes

 !CONFIG_LIBX264_ENCODER=yes

-!CONFIG_LIBXAVS_ENCODER=yes

-CONFIG_LIBXVID_ENCODER=yes

+!CONFIG_LIBXVID_ENCODER=yes

 !CONFIG_H263_VAAPI_HWACCEL=yes

 !CONFIG_H264_DXVA2_HWACCEL=yes

 !CONFIG_H264_VAAPI_HWACCEL=yes

-!CONFIG_MPEG2_DXVA2_HWACCEL=yes

 !CONFIG_MPEG2_VAAPI_HWACCEL=yes

 !CONFIG_MPEG4_VAAPI_HWACCEL=yes

 !CONFIG_VC1_DXVA2_HWACCEL=yes

@@ -699,7 +664,6 @@

 !CONFIG_WMV3_DXVA2_HWACCEL=yes

 !CONFIG_WMV3_VAAPI_HWACCEL=yes

 CONFIG_AAC_PARSER=yes

-CONFIG_AAC_LATM_PARSER=yes

 CONFIG_AC3_PARSER=yes

 CONFIG_CAVSVIDEO_PARSER=yes

 CONFIG_DCA_PARSER=yes

@@ -707,7 +671,6 @@

 CONFIG_DNXHD_PARSER=yes

 CONFIG_DVBSUB_PARSER=yes

 CONFIG_DVDSUB_PARSER=yes

-CONFIG_FLAC_PARSER=yes

 CONFIG_H261_PARSER=yes

 CONFIG_H263_PARSER=yes

 CONFIG_H264_PARSER=yes

@@ -719,13 +682,10 @@

 CONFIG_PNM_PARSER=yes

 CONFIG_VC1_PARSER=yes

 CONFIG_VP3_PARSER=yes

-CONFIG_VP8_PARSER=yes

 CONFIG_AAC_ADTSTOASC_BSF=yes

-CONFIG_CHOMP_BSF=yes

 CONFIG_DUMP_EXTRADATA_BSF=yes

 CONFIG_H264_MP4TOANNEXB_BSF=yes

 CONFIG_IMX_DUMP_HEADER_BSF=yes

-CONFIG_MJPEG2JPEG_BSF=yes

 CONFIG_MJPEGA_DUMP_HEADER_BSF=yes

 CONFIG_MP3_HEADER_COMPRESS_BSF=yes

 CONFIG_MP3_HEADER_DECOMPRESS_BSF=yes

@@ -741,7 +701,6 @@

 CONFIG_ANM_DEMUXER=yes

 CONFIG_APC_DEMUXER=yes

 CONFIG_APE_DEMUXER=yes

-CONFIG_APPLEHTTP_DEMUXER=yes

 CONFIG_ASF_DEMUXER=yes

 CONFIG_ASS_DEMUXER=yes

 CONFIG_AU_DEMUXER=yes

@@ -766,13 +725,11 @@

 CONFIG_EA_CDATA_DEMUXER=yes

 CONFIG_EAC3_DEMUXER=yes

 CONFIG_FFM_DEMUXER=yes

-CONFIG_FFMETADATA_DEMUXER=yes

 CONFIG_FILMSTRIP_DEMUXER=yes

 CONFIG_FLAC_DEMUXER=yes

 CONFIG_FLIC_DEMUXER=yes

 CONFIG_FLV_DEMUXER=yes

 CONFIG_FOURXM_DEMUXER=yes

-CONFIG_G722_DEMUXER=yes

 CONFIG_GSM_DEMUXER=yes

 CONFIG_GXF_DEMUXER=yes

 CONFIG_H261_DEMUXER=yes

@@ -786,9 +743,7 @@

 CONFIG_IPMOVIE_DEMUXER=yes

 CONFIG_ISS_DEMUXER=yes

 CONFIG_IV8_DEMUXER=yes

-CONFIG_IVF_DEMUXER=yes

 CONFIG_LMLM4_DEMUXER=yes

-CONFIG_LXF_DEMUXER=yes

 CONFIG_M4V_DEMUXER=yes

 CONFIG_MATROSKA_DEMUXER=yes

 CONFIG_MJPEG_DEMUXER=yes

@@ -807,7 +762,6 @@

 CONFIG_MTV_DEMUXER=yes

 CONFIG_MVI_DEMUXER=yes

 CONFIG_MXF_DEMUXER=yes

-CONFIG_MXG_DEMUXER=yes

 CONFIG_NC_DEMUXER=yes

 CONFIG_NSV_DEMUXER=yes

 CONFIG_NUT_DEMUXER=yes

@@ -842,10 +796,7 @@

 CONFIG_RM_DEMUXER=yes

 CONFIG_ROQ_DEMUXER=yes

 CONFIG_RPL_DEMUXER=yes

-CONFIG_RSO_DEMUXER=yes

-CONFIG_RTP_DEMUXER=yes

 CONFIG_RTSP_DEMUXER=yes

-CONFIG_SAP_DEMUXER=yes

 CONFIG_SDP_DEMUXER=yes

 CONFIG_SEGAFILM_DEMUXER=yes

 CONFIG_SHORTEN_DEMUXER=yes

@@ -853,8 +804,6 @@

 CONFIG_SMACKER_DEMUXER=yes

 CONFIG_SOL_DEMUXER=yes

 CONFIG_SOX_DEMUXER=yes

-CONFIG_SPDIF_DEMUXER=yes

-CONFIG_SRT_DEMUXER=yes

 CONFIG_STR_DEMUXER=yes

 CONFIG_SWF_DEMUXER=yes

 CONFIG_THP_DEMUXER=yes

@@ -863,7 +812,6 @@

 CONFIG_TRUEHD_DEMUXER=yes

 CONFIG_TTA_DEMUXER=yes

 CONFIG_TXD_DEMUXER=yes

-CONFIG_TTY_DEMUXER=yes

 CONFIG_VC1_DEMUXER=yes

 CONFIG_VC1T_DEMUXER=yes

 CONFIG_VMD_DEMUXER=yes

@@ -874,13 +822,11 @@

 CONFIG_WC3_DEMUXER=yes

 CONFIG_WSAUD_DEMUXER=yes

 CONFIG_WSVQA_DEMUXER=yes

-CONFIG_WTV_DEMUXER=yes

 CONFIG_WV_DEMUXER=yes

 CONFIG_XA_DEMUXER=yes

 CONFIG_YOP_DEMUXER=yes

 CONFIG_YUV4MPEGPIPE_DEMUXER=yes

 !CONFIG_LIBNUT_DEMUXER=yes

-CONFIG_A64_MUXER=yes

 CONFIG_AC3_MUXER=yes

 CONFIG_ADTS_MUXER=yes

 CONFIG_AIFF_MUXER=yes

@@ -891,7 +837,6 @@

 CONFIG_AU_MUXER=yes

 CONFIG_AVI_MUXER=yes

 CONFIG_AVM2_MUXER=yes

-CONFIG_CAVSVIDEO_MUXER=yes

 CONFIG_CRC_MUXER=yes

 CONFIG_DAUD_MUXER=yes

 CONFIG_DIRAC_MUXER=yes

@@ -900,13 +845,10 @@

 CONFIG_DV_MUXER=yes

 CONFIG_EAC3_MUXER=yes

 CONFIG_FFM_MUXER=yes

-CONFIG_FFMETADATA_MUXER=yes

 CONFIG_FILMSTRIP_MUXER=yes

 CONFIG_FLAC_MUXER=yes

 CONFIG_FLV_MUXER=yes

 CONFIG_FRAMECRC_MUXER=yes

-CONFIG_FRAMEMD5_MUXER=yes

-CONFIG_G722_MUXER=yes

 CONFIG_GIF_MUXER=yes

 CONFIG_GXF_MUXER=yes

 CONFIG_H261_MUXER=yes

@@ -916,7 +858,6 @@

 CONFIG_IMAGE2PIPE_MUXER=yes

 CONFIG_IPOD_MUXER=yes

 CONFIG_M4V_MUXER=yes

-CONFIG_MD5_MUXER=yes

 CONFIG_MATROSKA_MUXER=yes

 CONFIG_MATROSKA_AUDIO_MUXER=yes

 CONFIG_MJPEG_MUXER=yes

@@ -964,13 +905,10 @@

 CONFIG_RAWVIDEO_MUXER=yes

 CONFIG_RM_MUXER=yes

 CONFIG_ROQ_MUXER=yes

-CONFIG_RSO_MUXER=yes

 CONFIG_RTP_MUXER=yes

 CONFIG_RTSP_MUXER=yes

-CONFIG_SAP_MUXER=yes

 CONFIG_SOX_MUXER=yes

 CONFIG_SPDIF_MUXER=yes

-CONFIG_SRT_MUXER=yes

 CONFIG_SWF_MUXER=yes

 CONFIG_TG2_MUXER=yes

 CONFIG_TGP_MUXER=yes

@@ -981,48 +919,21 @@

 CONFIG_WEBM_MUXER=yes

 CONFIG_YUV4MPEGPIPE_MUXER=yes

 !CONFIG_LIBNUT_MUXER=yes

-CONFIG_ANULL_FILTER=yes

-CONFIG_ANULLSRC_FILTER=yes

-CONFIG_ANULLSINK_FILTER=yes

-CONFIG_BLACKFRAME_FILTER=yes

-CONFIG_COPY_FILTER=yes

+CONFIG_ASPECT_FILTER=yes

 CONFIG_CROP_FILTER=yes

-CONFIG_CROPDETECT_FILTER=yes

-CONFIG_DRAWBOX_FILTER=yes

-CONFIG_FIFO_FILTER=yes

 CONFIG_FORMAT_FILTER=yes

-!CONFIG_FREI0R_FILTER=yes

-CONFIG_GRADFUN_FILTER=yes

-CONFIG_HFLIP_FILTER=yes

-CONFIG_HQDN3D_FILTER=yes

 CONFIG_NOFORMAT_FILTER=yes

 CONFIG_NULL_FILTER=yes

-!CONFIG_OCV_FILTER=yes

-CONFIG_OVERLAY_FILTER=yes

-CONFIG_PAD_FILTER=yes

-CONFIG_PIXDESCTEST_FILTER=yes

+CONFIG_PIXELASPECT_FILTER=yes

 CONFIG_SCALE_FILTER=yes

-CONFIG_SETDAR_FILTER=yes

-CONFIG_SETPTS_FILTER=yes

-CONFIG_SETSAR_FILTER=yes

-CONFIG_SETTB_FILTER=yes

 CONFIG_SLICIFY_FILTER=yes

-CONFIG_TRANSPOSE_FILTER=yes

 CONFIG_UNSHARP_FILTER=yes

 CONFIG_VFLIP_FILTER=yes

-CONFIG_YADIF_FILTER=yes

-CONFIG_BUFFER_FILTER=yes

-CONFIG_COLOR_FILTER=yes

-!CONFIG_FREI0R_SRC_FILTER=yes

 CONFIG_NULLSRC_FILTER=yes

 CONFIG_NULLSINK_FILTER=yes

-CONFIG_CONCAT_PROTOCOL=yes

 CONFIG_FILE_PROTOCOL=yes

 CONFIG_GOPHER_PROTOCOL=yes

 CONFIG_HTTP_PROTOCOL=yes

-CONFIG_MMSH_PROTOCOL=yes

-CONFIG_MMST_PROTOCOL=yes

-CONFIG_MD5_PROTOCOL=yes

 CONFIG_PIPE_PROTOCOL=yes

 CONFIG_RTMP_PROTOCOL=yes

 CONFIG_RTMPT_PROTOCOL=yes

@@ -1032,7 +943,9 @@

 CONFIG_RTP_PROTOCOL=yes

 CONFIG_TCP_PROTOCOL=yes

 CONFIG_UDP_PROTOCOL=yes

-CONFIG_ALSA_INDEV=yes

+CONFIG_CONCAT_PROTOCOL=yes

+!CONFIG_ALSA_INDEV=yes

+!CONFIG_AUDIO_BEOS_INDEV=yes

 !CONFIG_BKTR_INDEV=yes

 CONFIG_DV1394_INDEV=yes

 !CONFIG_JACK_INDEV=yes

@@ -1042,11 +955,7 @@

 !CONFIG_VFWCAP_INDEV=yes

 !CONFIG_X11_GRAB_DEVICE_INDEV=yes

 !CONFIG_LIBDC1394_INDEV=yes

-CONFIG_ALSA_OUTDEV=yes

+!CONFIG_ALSA_OUTDEV=yes

+!CONFIG_AUDIO_BEOS_OUTDEV=yes

 CONFIG_OSS_OUTDEV=yes

-ACODEC_TESTS=ac3_fixed adpcm_ima_qt adpcm_ima_wav adpcm_ms adpcm_swf adpcm_yam alac flac g726 mp2 pcm wmav1 wmav2 

-VCODEC_TESTS=asv1 asv2 dnxhd_1080i dnxhd_720p dnxhd_720p_rd dv dv50 error ffv1 flashsv flv h261 h263 h263p huffyuv jpegls ljpeg mjpeg mpeg mpeg1b mpeg2 mpeg2thread mpeg4 mpeg4adv mpeg4nr mpeg4thread msmpeg4 msmpeg4v2 qtrle rc rgb roq rv10 rv20 snow snowll svq1 wmv1 wmv2 yuv 

-LAVF_TESTS=aiff alaw asf au avi bmp dv_fmt ffm flv_fmt gif gxf jpg mkv mmf mov mpg mulaw mxf nut ogg pbmpipe pcx pgm pgmpipe pixfmt png ppm ppmpipe rm sgi swf tga tiff ts voc wav yuv4mpeg 

-LAVFI_TESTS=crop crop_scale crop_scale_vflip crop_vflip null pixdesc_le pixfmts_copy_le pixfmts_crop_le pixfmts_hflip_le pixfmts_null_le pixfmts_pad_le pixfmts_scale_le pixfmts_vflip_le scale200 scale500 vflip vflip_crop vflip_vflip 

-SEEK_TESTS=seek_ac3_rm seek_adpcm_ima_wav seek_adpcm_ms_wav seek_adpcm_qt_aiff seek_adpcm_swf_flv seek_adpcm_yam_wav seek_alac_m4a seek_asv1_avi seek_asv2_avi seek_dnxhd_1080i_mov seek_dnxhd_720p_dnxhd seek_dnxhd_720p_rd_dnxhd seek_dv411_dv seek_dv50_dv seek_dv_dv seek_error_mpeg4_adv_avi seek_ffv1_avi seek_flac_flac seek_flashsv_flv seek_flv_flv seek_g726_wav seek_h261_avi seek_h263_avi seek_h263p_avi seek_huffyuv_avi seek_image_bmp seek_image_jpg seek_image_pcx seek_image_pgm seek_image_ppm seek_image_sgi seek_image_tga seek_image_tiff seek_jpegls_avi seek_lavf_aif seek_lavf_al seek_lavf_asf seek_lavf_au seek_lavf_avi seek_lavf_dv seek_lavf_ffm seek_lavf_flv seek_lavf_gif seek_lavf_gxf seek_lavf_mkv seek_lavf_mmf seek_lavf_mov seek_lavf_mpg seek_lavf_mxf seek_lavf_mxf_d10 seek_lavf_nut seek_lavf_ogg seek_lavf_rm seek_lavf_swf seek_lavf_ts seek_lavf_ul seek_lavf_voc seek_lavf_wav seek_lavf_y4m seek_ljpeg_avi seek_mjpeg_avi seek_mp2_mp2 seek_mpeg1_mpg seek_mpeg1b_mpg seek_mpeg2_422_mpg seek_mpeg2_mpg seek_mpeg2i_mpg seek_mpeg2ivlc_qprd_mpg seek_mpeg2reuse_mpg seek_mpeg2thread_mpg seek_mpeg2threadivlc_mpg seek_mpeg4_adap_avi seek_mpeg4_adv_avi seek_mpeg4_nr_avi seek_mpeg4_qprd_avi seek_mpeg4_rc_avi seek_mpeg4_thread_avi seek_msmpeg4_avi seek_msmpeg4v2_avi seek_odivx_mp4 seek_pbmpipe_pbm seek_pcm_alaw_wav seek_pcm_f32be_au seek_pcm_f32le_wav seek_pcm_f64be_au seek_pcm_f64le_wav seek_pcm_mulaw_wav seek_pcm_s16be_mkv seek_pcm_s16be_mov seek_pcm_s16le_mkv seek_pcm_s16le_wav seek_pcm_s24be_mov seek_pcm_s24daud_302 seek_pcm_s24le_wav seek_pcm_s32be_mov seek_pcm_s32le_wav seek_pcm_s8_mov seek_pcm_u8_wav seek_pcm_zork_wav seek_pgmpipe_pgm seek_ppmpipe_ppm seek_rgb_avi seek_roqav_roq seek_rv10_rm seek_rv20_rm seek_snow53_avi seek_snow_avi seek_svq1_mov seek_wmav1_asf seek_wmav2_asf seek_wmv1_avi seek_wmv2_avi seek_yuv_avi 

 endif # FFMPEG_CONFIG_MAK

diff -u ffmpeg/configure ffmpeg-0.6.1/configure

--- ffmpeg/configure 2011-01-08 09:07:51.366858305 -0800

+++ ffmpeg-0.6.1/configure 2010-06-15 12:44:30.000000000 -0700

@@ -61,7 +61,7 @@

 

 Standard options:

   --help                   print this message

-  --logfile=FILE           log tests and output to FILE [config.log]

+  --logfile=FILE           log tests and output to FILE [config.err]

   --disable-logging        do not log configure debug information

   --prefix=PREFIX          install in PREFIX [$prefix]

   --bindir=DIR             install binaries in DIR [PREFIX/bin]

@@ -86,12 +86,14 @@

   --disable-ffserver       disable ffserver build

   --disable-avdevice       disable libavdevice build

   --disable-avcodec        disable libavcodec build

-  --disable-avcore         disable libavcore build

   --disable-avformat       disable libavformat build

   --disable-swscale        disable libswscale build

   --enable-postproc        enable GPLed postprocessing support [no]

-  --disable-avfilter       disable video filter support [no]

-  --disable-pthreads       disable pthreads [auto]

+  --enable-avfilter        video filter support [no]

+  --enable-avfilter-lavf   video filters dependent on avformat [no]

+  --enable-beosthreads     use BeOS threads [no]

+  --enable-os2threads      use OS/2 threads [no]

+  --enable-pthreads        use pthreads [no]

   --enable-w32threads      use Win32 threads [no]

   --enable-x11grab         enable X11 grabbing [no]

   --disable-network        disable network support [no]

@@ -104,7 +106,6 @@

   --disable-dct            disable DCT code

   --disable-fft            disable FFT code

   --disable-golomb         disable Golomb code

-  --disable-huffman        disable Huffman code

   --disable-lpc            disable LPC code

   --disable-mdct           disable MDCT code

   --disable-rdft           disable RDFT code

@@ -114,6 +115,7 @@

   --enable-runtime-cpudetect detect cpu capabilities at runtime (bigger binary)

   --enable-hardcoded-tables use hardcoded tables instead of runtime generation

   --enable-memalign-hack   emulate memalign, interferes with memory debuggers

+  --enable-beos-netserver  enable BeOS netserver

   --disable-everything     disable all components listed below

   --disable-encoder=NAME   disable encoder NAME

   --enable-encoder=NAME    enable encoder NAME

@@ -162,14 +164,14 @@

 External library support:

   --enable-avisynth        enable reading of AVISynth script files [no]

   --enable-bzlib           enable bzlib [autodetect]

-  --enable-frei0r          enable frei0r video filtering

   --enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no]

   --enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no]

-  --enable-libopencv       enable video filtering via libopencv [no]

   --enable-libdc1394       enable IIDC-1394 grabbing using libdc1394

                            and libraw1394 [no]

   --enable-libdirac        enable Dirac support via libdirac [no]

   --enable-libfaac         enable FAAC support via libfaac [no]

+  --enable-libfaad         enable FAAD support via libfaad [no]

+  --enable-libfaadbin      open libfaad.so.0 at runtime [no]

   --enable-libgsm          enable GSM support via libgsm [no]

   --enable-libmp3lame      enable MP3 encoding via libmp3lame [no]

   --enable-libnut          enable NUT (de)muxing via libnut,

@@ -183,7 +185,6 @@

                            native implementation exists [no]

   --enable-libvpx          enable VP8 support via libvpx [no]

   --enable-libx264         enable H.264 encoding via x264 [no]

-  --enable-libxavs         enable AVS encoding via xavs [no]

   --enable-libxvid         enable Xvid encoding via xvidcore,

                            native MPEG-4/Xvid encoder exists [no]

   --enable-mlib            enable Sun medialib [no]

@@ -215,6 +216,8 @@

   --arch=ARCH              select architecture [$arch]

   --cpu=CPU                select the minimum required CPU (affects

                            instruction selection, may crash on older CPUs)

+  --enable-powerpc-perf    enable performance report on PPC

+                           (requires enabling PMC)

   --disable-asm            disable all assembler optimizations

   --disable-altivec        disable AltiVec optimizations

   --disable-amd3dnow       disable 3DNow! optimizations

@@ -235,11 +238,11 @@

   --enable-pic             build position-independent code

   --malloc-prefix=PFX      prefix malloc and related names with PFX

   --enable-sram            allow use of on-chip SRAM

-  --disable-symver         disable symbol versioning

 

 Developer options (useful when working on FFmpeg itself):

   --disable-debug          disable debugging symbols

   --enable-debug=LEVEL     set the debug level [$debuglevel]

+  --enable-gprof           enable profiling with gprof [$gprof]

   --disable-optimizations  disable compiler optimizations

   --enable-extra-warnings  enable more compiler warnings

   --disable-stripping      disable stripping of executables and shared libraries

@@ -267,11 +270,6 @@

     echo "$@"

 }

 

-warn(){

-    log "WARNING: $*"

-    WARNINGS="${WARNINGS}WARNING: $*/n"

-}

-

 die(){

     echolog "$@"

     cat <<EOF

@@ -309,7 +307,7 @@

 

 sh_quote(){

     v=$(echo "$1" | sed "s/'/'''/g")

-    test "x$v" = "x${v#*[!A-Za-z0-9_/.+-]}" || v="'$v'"

+    test "$v" = "${v#*[ |&;<>()$/`///"/'*?/[/]#~=%]}" || v="'$v'"

     echo "$v"

 }

 

@@ -498,51 +496,64 @@

     done

 }

 

-print_config_h(){

-    enabled $1 && v=1 || v=0

-    echo "#define $2 $v"

+print_config(){

+    pfx=$1

+    header=$2

+    makefile=$3

+    shift 3

+    for cfg; do

+        ucname="$(toupper $cfg)"

+        if enabled $cfg; then

+            echo "#define ${pfx}${ucname} 1" >> $header

+            echo "${pfx}${ucname}=yes" >> $makefile

+        else

+            echo "#define ${pfx}${ucname} 0" >> $header

+            echo "!${pfx}${ucname}=yes" >> $makefile

+        fi

+    done

 }

 

-print_config_mak(){

-    enabled $1 && v= || v=!

-    echo "$v$2=yes"

+flags_saved(){

+    (: ${SAVE_CFLAGS?}) 2> /dev/null

 }

 

-print_config_asm(){

-    enabled $1 && echo "%define $2"

+save_flags(){

+    flags_saved && return

+    SAVE_CFLAGS="$CFLAGS"

+    SAVE_LDFLAGS="$LDFLAGS"

+    SAVE_extralibs="$extralibs"

 }

 

-print_config(){

-    pfx=$1

-    files=$2

-    shift 2

-    for cfg; do

-        ucname="$(toupper $cfg)"

-        for f in $files; do

-            "print_config_${f##*.}" $cfg ${pfx}${ucname} >>$f

-        done

-    done

+restore_flags(){

+    flags_saved || return

+    CFLAGS="$SAVE_CFLAGS"

+    LDFLAGS="$SAVE_LDFLAGS"

+    extralibs="$SAVE_extralibs"

+    unset SAVE_CFLAGS

+    unset SAVE_LDFLAGS

+    unset SAVE_extralibs

 }

 

-print_enabled(){

-    test "$1" = -n && end=" " && shift || end="/n"

-    suf=$1

-    shift

-    for v; do

-        enabled $v && printf "%s$end" ${v%$suf};

-    done

+temp_cflags(){

+    save_flags

+    CFLAGS="$CFLAGS $*"

 }

 

-append(){

-    var=$1

-    shift

-    eval "$var=/"/$$var $*/""

+temp_ldflags(){

+    save_flags

+    LDFLAGS="$LDFLAGS $*"

+}

+

+temp_extralibs(){

+    save_flags

+    extralibs="$extralibs $*"

 }

 

-prepend(){

+append(){

     var=$1

     shift

-    eval "$var=/"$* /$$var/""

+    flags_saved && eval "SAVE_$var=/"/$SAVE_$var $*/""

+    eval "$var=/"/$$var $*/""

 }

 

 add_cppflags(){

@@ -562,7 +573,7 @@

 }

 

 add_extralibs(){

-    prepend extralibs "$@"

+    append extralibs "$@"

 }

 

 check_cmd(){

@@ -720,7 +731,11 @@

     header="$1"

     func="$2"

     shift 2

-    check_header $header && check_func $func "$@" && add_extralibs "$@"

+    temp_extralibs "$@"

+    check_header $header && check_func $func && add_extralibs "$@"

+    err=$?

+    restore_flags

+    return $err

 }

 

 check_lib2(){

@@ -812,6 +827,23 @@

     check_lib2 "$headers" $func "$@" || die "ERROR: $name not found"

 }

 

+check_foo_config(){

+    cfg=$1

+    pkg=$2

+    header=$3

+    func=$4

+    shift 4

+    disable $cfg

+    check_cmd ${pkg}-config --version

+    err=$?

+    if test "$err" = 0; then

+        temp_cflags $(${pkg}-config --cflags)

+        temp_extralibs $(${pkg}-config --libs)

+        check_lib "$@" $header $func && enable $cfg

+    fi

+    return $err

+}

+

 check_host_cc(){

     log check_host_cc "$@"

     cat > $TMPC

@@ -859,11 +891,12 @@

     $COMPONENT_LIST

     aandct

     avcodec

-    avcore

     avdevice

     avfilter

+    avfilter_lavf

     avformat

     avisynth

+    beos_netserver

     bzlib

     dct

     doc

@@ -875,23 +908,22 @@

     ffprobe

     ffserver

     fft

-    frei0r

     golomb

     gpl

+    gprof

     gray

     h264dsp

-    h264pred

     hardcoded_tables

-    huffman

     libdc1394

     libdirac

     libfaac

+    libfaad

+    libfaadbin

     libgsm

     libmp3lame

     libnut

     libopencore_amrnb

     libopencore_amrwb

-    libopencv

     libopenjpeg

     librtmp

     libschroedinger

@@ -900,7 +932,6 @@

     libvorbis

     libvpx

     libx264

-    libxavs

     libxvid

     lpc

     lsp

@@ -912,8 +943,8 @@

     nonfree

     pic

     postproc

+    powerpc_perf

     rdft

-    rtpdec

     runtime_cpudetect

     shared

     small

@@ -929,6 +960,8 @@

 "

 

 THREADS_LIST='

+    beosthreads

+    os2threads

     pthreads

     w32threads

 '

@@ -978,14 +1011,12 @@

 

 HAVE_LIST_PUB='

     bigendian

-    fast_unaligned

 '

 

 HAVE_LIST="

     $ARCH_EXT_LIST

     $HAVE_LIST_PUB

     $THREADS_LIST

-    aligned_stack

     alsa_asoundlib_h

     altivec_h

     arpa_inet_h

@@ -1011,16 +1042,14 @@

     fast_64bit

     fast_clz

     fast_cmov

-    fcntl

+    fast_unaligned

     fork

     getaddrinfo

     gethrtime

     GetProcessMemoryInfo

     GetProcessTimes

     getrusage

-    gnu_as

     struct_rusage_ru_maxrss

-    ibm_asm

     inet_aton

     inline_asm

     isatty

@@ -1040,10 +1069,8 @@

     machine_ioctl_bt848_h

     machine_ioctl_meteor_h

     malloc_h

-    MapViewOfFile

     memalign

     mkstemp

-    mmap

     pld

     posix_memalign

     round

@@ -1056,7 +1083,6 @@

     poll_h

     setrlimit

     strerror_r

-    strtok_r

     struct_addrinfo

     struct_ipv6_mreq

     struct_sockaddr_in6

@@ -1078,7 +1104,6 @@

     VirtualAlloc

     winsock2_h

     xform_asm

-    xmm_clobbers

     yasm

 "

 

@@ -1100,7 +1125,6 @@

     logging

     optimizations

     stripping

-    symver

     yasm

 "

 

@@ -1174,7 +1198,6 @@

 sse_deps="mmx"

 ssse3_deps="sse"

 

-aligned_stack_if_any="ppc x86"

 fast_64bit_if_any="alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64"

 fast_clz_if_any="alpha armv5te avr32 mips ppc x86"

 fast_unaligned_if_any="armv6 ppc x86"

@@ -1185,19 +1208,15 @@

 symver_if_any="symver_asm_label symver_gnu_asm"

 

 # subsystems

-dct_select="rdft"

 mdct_select="fft"

 rdft_select="fft"

 

 # decoders / encoders / hardware accelerators

-aac_decoder_select="mdct rdft"

+aac_decoder_select="mdct rdft aac_parser"

 aac_encoder_select="mdct"

-aac_latm_decoder_select="aac_decoder aac_latm_parser"

 ac3_decoder_select="mdct ac3_parser"

-ac3_encoder_select="mdct"

 alac_encoder_select="lpc"

 amrnb_decoder_select="lsp"

-amrwb_decoder_select="lsp"

 atrac1_decoder_select="mdct"

 atrac3_decoder_select="mdct"

 binkaudio_dct_decoder_select="mdct rdft dct"

@@ -1219,14 +1238,13 @@

 flashsv_encoder_select="zlib"

 flv_decoder_select="h263_decoder"

 flv_encoder_select="h263_encoder"

-fraps_decoder_select="huffman"

 h261_encoder_select="aandct"

 h263_decoder_select="h263_parser"

 h263_encoder_select="aandct"

 h263_vaapi_hwaccel_select="vaapi h263_decoder"

 h263i_decoder_select="h263_decoder"

 h263p_encoder_select="h263_encoder"

-h264_decoder_select="golomb h264dsp h264pred"

+h264_decoder_select="golomb h264dsp"

 h264_dxva2_hwaccel_deps="dxva2api_h"

 h264_dxva2_hwaccel_select="dxva2 h264_decoder"

 h264_vaapi_hwaccel_select="vaapi"

@@ -1238,19 +1256,12 @@

 loco_decoder_select="golomb"

 mjpeg_encoder_select="aandct"

 mlp_decoder_select="mlp_parser"

-mp1float_decoder_select="dct"

-mp2float_decoder_select="dct"

-mp3adufloat_decoder_select="dct"

-mp3float_decoder_select="dct"

-mp3on4float_decoder_select="dct"

 mpeg1video_encoder_select="aandct"

 mpeg2video_encoder_select="aandct"

 mpeg4_decoder_select="h263_decoder mpeg4video_parser"

 mpeg4_encoder_select="h263_encoder"

 mpeg_vdpau_decoder_select="vdpau mpegvideo_decoder"

 mpeg1_vdpau_decoder_select="vdpau mpeg1video_decoder"

-mpeg2_dxva2_hwaccel_deps="dxva2api_h"

-mpeg2_dxva2_hwaccel_select="dxva2 mpeg2video_decoder"

 mpeg2_vaapi_hwaccel_select="vaapi mpeg2video_decoder"

 mpeg4_vaapi_hwaccel_select="vaapi mpeg4_decoder"

 mpeg4_vdpau_decoder_select="vdpau mpeg4_decoder"

@@ -1268,13 +1279,12 @@

 png_encoder_select="zlib"

 qcelp_decoder_select="lsp"

 qdm2_decoder_select="mdct rdft"

-ra_144_encoder_select="lpc"

 rv10_decoder_select="h263_decoder"

 rv10_encoder_select="h263_encoder"

 rv20_decoder_select="h263_decoder"

 rv20_encoder_select="h263_encoder"

-rv30_decoder_select="golomb h264pred"

-rv40_decoder_select="golomb h264pred"

+rv30_decoder_select="golomb h264dsp"

+rv40_decoder_select="golomb h264dsp"

 shorten_decoder_select="golomb"

 sipr_decoder_select="lsp"

 snow_decoder_select="dwt"

@@ -1283,7 +1293,7 @@

 sonic_encoder_select="golomb"

 sonic_ls_encoder_select="golomb"

 svq1_encoder_select="aandct"

-svq3_decoder_select="golomb h264dsp h264pred"

+svq3_decoder_select="golomb h264dsp"

 svq3_decoder_suggest="zlib"

 theora_decoder_select="vp3_decoder"

 tiff_decoder_suggest="zlib"

@@ -1298,16 +1308,14 @@

 vc1_vdpau_decoder_select="vdpau vc1_decoder"

 vorbis_decoder_select="mdct"

 vorbis_encoder_select="mdct"

-vp6_decoder_select="huffman"

 vp6a_decoder_select="vp6_decoder"

 vp6f_decoder_select="vp6_decoder"

-vp8_decoder_select="h264pred"

 wmapro_decoder_select="mdct"

 wmav1_decoder_select="mdct"

 wmav1_encoder_select="mdct"

 wmav2_decoder_select="mdct"

 wmav2_encoder_select="mdct"

-wmavoice_decoder_select="lsp rdft dct mdct"

+wmavoice_decoder_select="lsp rdft dct"

 wmv1_decoder_select="h263_decoder"

 wmv1_encoder_select="h263_encoder"

 wmv2_decoder_select="h263_decoder"

@@ -1325,12 +1333,17 @@

 vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"

 

 # parsers

-h264_parser_select="golomb h264dsp h264pred"

+h264_parser_select="golomb h264dsp"

+

+# bitstream_filters

+aac_adtstoasc_bsf_select="aac_parser"

 

 # external libraries

 libdirac_decoder_deps="libdirac !libschroedinger"

 libdirac_encoder_deps="libdirac"

 libfaac_encoder_deps="libfaac"

+libfaad_decoder_deps="libfaad"

+libfaadbin_extralibs='$ldl'

 libgsm_decoder_deps="libgsm"

 libgsm_encoder_deps="libgsm"

 libgsm_ms_decoder_deps="libgsm"

@@ -1348,7 +1361,6 @@

 libvpx_decoder_deps="libvpx"

 libvpx_encoder_deps="libvpx"

 libx264_encoder_deps="libx264"

-libxavs_encoder_deps="libxavs"

 libxvid_encoder_deps="libxvid"

 

 # demuxers / muxers

@@ -1357,7 +1369,6 @@

 avisynth_demuxer_deps="avisynth"

 dirac_demuxer_deps="dirac_parser"

 eac3_demuxer_select="ac3_parser"

-flac_demuxer_deps="flac_parser"

 ipod_muxer_select="mov_muxer"

 libnut_demuxer_deps="libnut"

 libnut_muxer_deps="libnut"

@@ -1370,13 +1381,11 @@

 mxf_d10_muxer_select="mxf_muxer"

 ogg_demuxer_select="golomb"

 psp_muxer_select="mov_muxer"

-rtp_demuxer_select="sdp_demuxer"

-rtpdec_select="asf_demuxer rm_demuxer rtp_protocol mpegts_demuxer mov_demuxer"

-rtsp_demuxer_select="http_protocol rtpdec"

-rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol"

-sap_demuxer_select="sdp_demuxer"

-sap_muxer_select="rtp_muxer rtp_protocol"

-sdp_demuxer_select="rtpdec"

+rtsp_demuxer_deps="sdp_demuxer"

+rtsp_muxer_deps="sdp_demuxer"

+rtsp_muxer_select="rtp_muxer"

+sdp_demuxer_deps="rtp_protocol mpegts_demuxer"

+sdp_demuxer_select="asf_demuxer rm_demuxer"

 spdif_muxer_select="aac_parser"

 tg2_muxer_select="mov_muxer"

 tgp_muxer_select="mov_muxer"

@@ -1384,16 +1393,23 @@

 

 # indevs / outdevs

 alsa_indev_deps="alsa_asoundlib_h snd_pcm_htimestamp"

+alsa_indev_extralibs="-lasound"

 alsa_outdev_deps="alsa_asoundlib_h"

+alsa_outdev_extralibs="-lasound"

+audio_beos_indev_deps="audio_beos"

+audio_beos_indev_extralibs="-lmedia -lbe"

+audio_beos_outdev_deps="audio_beos"

+audio_beos_outdev_extralibs="-lmedia -lbe"

 bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h"

 dv1394_indev_deps="dv1394 dv_demuxer"

 jack_indev_deps="jack_jack_h"

+jack_indev_extralibs="-ljack"

 libdc1394_indev_deps="libdc1394"

 oss_indev_deps_any="soundcard_h sys_soundcard_h"

 oss_outdev_deps_any="soundcard_h sys_soundcard_h"

 v4l_indev_deps="linux_videodev_h"

 v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h"

-vfwcap_indev_deps="capCreateCaptureWindow vfwcap_defines"

+vfwcap_indev_deps="capCreateCaptureWindow"

 vfwcap_indev_extralibs="-lavicap32"

 x11_grab_device_indev_deps="x11grab XShmCreateImage"

 x11_grab_device_indev_extralibs="-lX11 -lXext -lXfixes"

@@ -1402,22 +1418,14 @@

 gopher_protocol_deps="network"

 http_protocol_deps="network"

 http_protocol_select="tcp_protocol"

-mmsh_protocol_select="http_protocol"

-mmst_protocol_deps="network"

-rtmp_protocol_select="tcp_protocol"

-rtp_protocol_select="udp_protocol"

+rtmp_protocol_deps="tcp_protocol"

+rtp_protocol_deps="udp_protocol"

 tcp_protocol_deps="network"

 udp_protocol_deps="network"

 

 # filters

-blackframe_filter_deps="gpl"

-cropdetect_filter_deps="gpl"

-frei0r_filter_deps="frei0r dlopen strtok_r"

-frei0r_src_filter_deps="frei0r dlopen strtok_r"

-hqdn3d_filter_deps="gpl"

-scale_filter_deps="swscale"

-ocv_filter_deps="libopencv"

-yadif_filter_deps="gpl"

+movie_filter_deps="avfilter_lavf"

+avfilter_lavf_deps="avformat"

 

 # libraries

 avdevice_deps="avcodec avformat"

@@ -1425,7 +1433,6 @@

 

 # programs

 ffmpeg_deps="avcodec avformat swscale"

-ffmpeg_select="buffer_filter"

 ffplay_deps="avcodec avformat swscale sdl"

 ffplay_select="rdft"

 ffprobe_deps="avcodec avformat"

@@ -1434,113 +1441,9 @@

 

 doc_deps="texi2html"

 

-# tests

-

-test_deps(){

-    suf1=$1

-    suf2=$2

-    shift 2

-    for v; do

-        dep=${v%=*}

-        tests=${v#*=}

-        for name in ${tests}; do

-            eval ${name}_test_deps="'${dep}$suf1 ${dep}$suf2'"

-        done

-    done

-}

-

-set_ne_test_deps(){

-    eval ${1}_be_test_deps="bigendian"

-    eval ${1}_le_test_deps="!bigendian"

-}

-

-test_deps _encoder _decoder                                             /

-    adpcm_g726=g726                                                     /

-    adpcm_ima_qt                                                        /

-    adpcm_ima_wav                                                       /

-    adpcm_ms                                                            /

-    adpcm_swf                                                           /

-    adpcm_yamaha=adpcm_yam                                              /

-    alac                                                                /

-    asv1                                                                /

-    asv2                                                                /

-    bmp                                                                 /

-    dnxhd="dnxhd_1080i dnxhd_720p dnxhd_720p_rd"                        /

-    dvvideo="dv dv50"                                                   /

-    ffv1                                                                /

-    flac                                                                /

-    flashsv                                                             /

-    flv                                                                 /

-    gif                                                                 /

-    h261                                                                /

-    h263="h263 h263p"                                                   /

-    huffyuv                                                             /

-    jpegls                                                              /

-    mjpeg="jpg mjpeg ljpeg"                                             /

-    mp2                                                                 /

-    mpeg1video="mpeg mpeg1b"                                            /

-    mpeg2video="mpeg2 mpeg2thread"                                      /

-    mpeg4="mpeg4 mpeg4adv mpeg4nr mpeg4thread error rc"                 /

-    msmpeg4v3=msmpeg4                                                   /

-    msmpeg4v2                                                           /

-    pbm=pbmpipe                                                         /

-    pcx                                                                 /

-    pgm="pgm pgmpipe"                                                   /

-    ppm="ppm ppmpipe"                                                   /

-    rawvideo="rgb yuv"                                                  /

-    roq                                                                 /

-    rv10                                                                /

-    rv20                                                                /

-    sgi                                                                 /

-    snow="snow snowll"                                                  /

-    svq1                                                                /

-    targa=tga                                                           /

-    tiff                                                                /

-    wmav1                                                               /

-    wmav2                                                               /

-    wmv1                                                                /

-    wmv2                                                                /

-

-test_deps _muxer _demuxer                                               /

-    aiff                                                                /

-    pcm_alaw=alaw                                                       /

-    asf                                                                 /

-    au                                                                  /

-    avi                                                                 /

-    dv=dv_fmt                                                           /

-    ffm                                                                 /

-    flv=flv_fmt                                                         /

-    gxf                                                                 /

-    matroska=mkv                                                        /

-    mmf                                                                 /

-    mov                                                                 /

-    pcm_mulaw=mulaw                                                     /

-    mxf                                                                 /

-    nut                                                                 /

-    ogg                                                                 /

-    rawvideo=pixfmt                                                     /

-    rm                                                                  /

-    swf                                                                 /

-    mpegts=ts                                                           /

-    voc                                                                 /

-    wav                                                                 /

-    yuv4mpegpipe=yuv4mpeg                                               /

-

-ac3_fixed_test_deps="ac3_fixed_encoder ac3_decoder rm_muxer rm_demuxer"

-mpg_test_deps="mpeg1system_muxer mpegps_demuxer"

-

-set_ne_test_deps pixdesc

-set_ne_test_deps pixfmts_copy

-set_ne_test_deps pixfmts_crop

-set_ne_test_deps pixfmts_hflip

-set_ne_test_deps pixfmts_null

-set_ne_test_deps pixfmts_pad

-set_ne_test_deps pixfmts_scale

-set_ne_test_deps pixfmts_vflip

-

 # default parameters

 

-logfile="config.log"

+logfile="config.err"

 

 # installation paths

 prefix_default="/usr/local"

@@ -1562,7 +1465,6 @@

 ranlib="ranlib"

 strip_default="strip"

 yasmexe="yasm"

-nogas=":"

 

 nm_opts='-g'

 

@@ -1576,9 +1478,7 @@

 

 # configurable options

 enable avcodec

-enable avcore

 enable avdevice

-enable avfilter

 enable avformat

 enable avutil

 enable asm

@@ -1619,8 +1519,8 @@

 

 target_path='$(CURDIR)'

 

-# since the object filename is not given with the -MM flag, the compiler

-# is only able to print the basename, and we must add the path ourselves

+# gcc stupidly only outputs the basename of targets with -MM, but we need the

+# full relative path for objects in subdirectories for non-recursive Make.

 DEPEND_CMD='$(DEPCC) $(DEPFLAGS) $< | sed -e "/^/#.*/d" -e "s,^[[:space:]]*$(*F)//.o,$(@D)/$(*F).o," > $(@:.o=.d)'

 DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -MM'

 

@@ -1664,25 +1564,13 @@

 PROTOCOL_LIST=$(find_things protocol PROTOCOL libavformat/allformats.c)

 FILTER_LIST=$(find_things   filter   FILTER   libavfilter/allfilters.c)

 

-find_tests(){

-    map "echo ${2}/${v}_test" $(ls "$source_path"/tests/ref/$1 | grep -v '[^-a-z0-9_]')

-}

-

-ACODEC_TESTS=$(find_tests acodec)

-VCODEC_TESTS=$(find_tests vsynth1)

-LAVF_TESTS=$(find_tests lavf)

-LAVFI_TESTS=$(find_tests lavfi)

-SEEK_TESTS=$(find_tests seek seek_)

-

-pcm_test_deps=$(map 'echo ${v%_*}_decoder $v' $(filter pcm_* $ENCODER_LIST))

-

 for n in $COMPONENT_LIST; do

     v=$(toupper ${n%s})_LIST

     eval enable /$$v

     eval ${n}_if_any="/$$v"

 done

 

-enable $ARCH_EXT_LIST $ACODEC_TESTS $VCODEC_TESTS $LAVF_TESTS $LAVFI_TESTS $SEEK_TESTS

+enable $ARCH_EXT_LIST

 

 die_unknown(){

     echo "Unknown option /"$1/"."

@@ -1709,7 +1597,7 @@

     --enable-debug=*) debuglevel="$optval"

     ;;

     --disable-everything)

-    map 'eval unset /${$(toupper ${v%s})_LIST}' $COMPONENT_LIST

+    map 'eval disable /${$(toupper ${v%s})_LIST}' $COMPONENT_LIST

     ;;

     --enable-*=*|--disable-*=*)

     eval $(echo "${opt%%=*}" | sed 's/--/action=/;s/-/ thing=/')

@@ -1818,7 +1706,6 @@

 tmpfile TMPS  .S

 tmpfile TMPV  .ver

 tmpfile TMPSH .sh

-tmpfile TMPASM .asm

 

 unset -f mktemp

 

@@ -1839,20 +1726,9 @@

 filter_cppflags=echo

 filter_asflags=echo

 

-if   $cc -v 2>&1 | grep -q '^gcc.*LLVM'; then

-    cc_type=llvm_gcc

-    cc_version=__VERSION__

-    gcc_extra_ver=$(expr "$($cc --version | head -n1)" : '.*/((.*)/)')

-    cc_ident="llvm-gcc $($cc -dumpversion) $gcc_extra_ver"

-    CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

-    AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

-    speed_cflags='-O3'

-    size_cflags='-Os'

-elif $cc -v 2>&1 | grep -qi ^gcc; then

+if   $cc -v 2>&1 | grep -qi ^gcc; then

     cc_type=gcc

     cc_version=__VERSION__

-    gcc_extra_ver=$(expr "$($cc --version | head -n1)" : '.*/((.*)/)')

-    cc_ident="gcc $($cc -dumpversion) $gcc_extra_ver"

     if ! $cc -dumpversion | grep -q '^2/.'; then

         CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

         AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

@@ -1862,8 +1738,6 @@

 elif $cc --version 2>/dev/null | grep -q Intel; then

     cc_type=icc

     cc_version="AV_STRINGIFY(__INTEL_COMPILER)"

-    cc_ident=$($cc --version | head -n1)

-    icc_version=$($cc -dumpversion)

     CC_DEPFLAGS='-MMD'

     AS_DEPFLAGS='-MMD'

     speed_cflags='-O3'

@@ -1872,13 +1746,11 @@

 elif $cc -v 2>&1 | grep -q xlc; then

     cc_type=xlc

     cc_version="AV_STRINGIFY(__IBMC__)"

-    cc_ident=$($cc -qversion 2>/dev/null | head -n1)

     speed_cflags='-O5'

     size_cflags='-O5 -qcompact'

 elif $cc -V 2>/dev/null | grep -q Compaq; then

     cc_type=ccc

     cc_version="AV_STRINGIFY(__DECC_VER)"

-    cc_ident=$($cc -V | head -n1 | cut -d' ' -f1-3)

     DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -M'

     debuglevel=3

     add_ldflags -Wl,-z,now # calls to libots crash without this

@@ -1888,14 +1760,12 @@

     test -d "$sysroot" || die "No valid sysroot specified."

     cc_type=armcc

     cc_version="AV_STRINGIFY(__ARMCC_VERSION)"

-    cc_ident=$($cc --vsn | head -n1)

     armcc_conf="$PWD/armcc.conf"

     $cc --arm_linux_configure                 /

         --arm_linux_config_file="$armcc_conf" /

         --configure_sysroot="$sysroot"        /

         --configure_cpp_headers="$sysinclude" >>$logfile 2>&1 ||

         die "Error creating armcc configuration file."

-    $cc --vsn | grep -q RVCT && armcc_opt=rvct || armcc_opt=armcc

     cc="$cc --arm_linux_config_file=$armcc_conf --translate_gcc"

     as_default="${cross_prefix}gcc"

     CC_DEPFLAGS='-MMD'

@@ -1905,7 +1775,6 @@

 elif $cc -version 2>/dev/null | grep -q TMS470; then

     cc_type=tms470

     cc_version="AV_STRINGIFY(__TI_COMPILER_VERSION__)"

-    cc_ident=$($cc -version | head -n1 | tr -s ' ')

     cc="$cc --gcc --abi=eabi -eo=.o -mc -me"

     CC_O='-fr=$(@D)'

     as_default="${cross_prefix}gcc"

@@ -1944,9 +1813,7 @@

     }

 elif $cc -v 2>&1 | grep -q clang; then

     cc_type=clang

-    $cc -dM -E $TMPC | grep -q __clang_version__ &&

-        cc_version=__clang_version__ || cc_version=__VERSION__

-    cc_ident=$($cc --version | head -n1)

+    cc_version=__VERSION__

     CC_DEPFLAGS='-MMD'

     AS_DEPFLAGS='-MMD'

     speed_cflags='-O3'

@@ -1954,7 +1821,6 @@

 elif $cc -V 2>&1 | grep -q Sun; then

     cc_type=suncc

     cc_version="AV_STRINGIFY(__SUNPRO_C)"

-    cc_ident=$($cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)

     DEPEND_CMD='$(DEPCC) $(DEPFLAGS) $< | sed -e "1s,^.*: ,$@: ," -e "/$$!s,/$$, ///," -e "1!s,^.*: , ," > $(@:.o=.d)'

     DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -xM1'

     speed_cflags='-O5'

@@ -1966,9 +1832,9 @@

                 -march=*|-mcpu=*)

                     case "${flag#*=}" in

                         native)                   echo -xtarget=native       ;;

-                        v9|niagara)               echo -xarch=sparc          ;;

+                        v9)                       echo -xarch=sparc          ;;

                         ultrasparc)               echo -xarch=sparcvis       ;;

-                        ultrasparc3|niagara2)     echo -xarch=sparcvis2      ;;

+                        ultrasparc3|niagara*)     echo -xarch=sparcvis2      ;;

                         i586|pentium)             echo -xchip=pentium        ;;

                         i686|pentiumpro|pentium2) echo -xtarget=pentium_pro  ;;

                         pentium3*|c3-2)           echo -xtarget=pentium3     ;;

@@ -1993,26 +1859,9 @@

             esac

         done

     }

-elif $cc -v 2>&1 | grep -q 'PathScale/|Path64'; then

-    cc_type=pathscale

-    cc_version=__PATHSCALE__

-    cc_ident=$($cc -v 2>&1 | head -n1 | tr -d :)

-    CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

-    AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

-    speed_cflags='-O2'

-    size_cflags='-Os'

-elif $cc -v 2>&1 | grep -q Open64; then

-    cc_type=open64

-    cc_version=__OPEN64__

-    cc_ident=$($cc -v 2>&1 | head -n1 | tr -d :)

-    CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

-    AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'

-    speed_cflags='-O2'

-    size_cflags='-Os'

 fi

 

-test -n "$cc_type" && enable $cc_type ||

-    warn "Unknown C compiler $cc, unable to select optimal CFLAGS"

+test -n "$cc_type" && enable $cc_type || echolog "Unknown C compiler $cc"

 

 : ${as_default:=$cc}

 : ${dep_cc_default:=$cc}

@@ -2027,7 +1876,7 @@

 

 if test -n "$sysroot"; then

     case "$cc_type" in

-        gcc|llvm_gcc)

+        gcc)

             add_cppflags --sysroot="$sysroot"

             add_ldflags --sysroot="$sysroot"

         ;;

@@ -2046,7 +1895,7 @@

     enabled cross_compile && die "--cpu=host makes no sense when cross-compiling."

 

     case "$cc_type" in

-        gcc|llvm_gcc)

+        gcc)

             check_native(){

                 $cc $1=native -v -c -o $TMPO $TMPC >$TMPE 2>&1 || return

                 sed -n "/$1=/{

@@ -2103,7 +1952,7 @@

     ;;

 esac

 

-is_in $arch $ARCH_LIST || warn "unknown architecture $arch"

+is_in $arch $ARCH_LIST || echo "WARNING: unknown arch $arch"

 enable $arch

 

 # Add processor-specific flags

@@ -2164,7 +2013,7 @@

             disable cmov

         ;;

         # targets that do support conditional mov (cmov)

-        i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64|k8|opteron|athlon-fx|core2|amdfam10|barcelona|atom)

+        i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64|k8|opteron|athlon-fx|core2|amdfam10)

             cpuflags="-march=$cpu"

             enable cmov

             enable fast_cmov

@@ -2180,10 +2029,6 @@

 elif enabled sparc; then

 

     case $cpu in

-        niagara)

-            cpuflags="-mcpu=$cpu"

-            disable vis

-        ;;

         sparc64)

             cpuflags="-mcpu=v9"

         ;;

@@ -2194,18 +2039,9 @@

     case $cpu in

         armv*)

             cpuflags="-march=$cpu"

-            subarch=$(echo $cpu | sed 's/[^a-z0-9]//g')

         ;;

         *)

             cpuflags="-mcpu=$cpu"

-            case $cpu in

-                cortex-a*)                               subarch=armv7a  ;;

-                cortex-r*)                               subarch=armv7r  ;;

-                cortex-m*)                               subarch=armv7m  ;;

-                arm11*)                                  subarch=armv6   ;;

-                arm[79]*e*|arm9[24]6*|arm96*|arm102[26]) subarch=armv5te ;;

-                armv4*|arm7*|arm9[24]*)                  subarch=armv4   ;;

-            esac

         ;;

     esac

 

@@ -2291,10 +2127,30 @@

 

 # OS specific

 case $target_os in

-    haiku)

-        prefix_default="/boot/common"

-        network_extralibs="-lnetwork"

-        ;;

+    beos|haiku|zeta)

+        prefix_default="$HOME/config"

+        # 3 gcc releases known for BeOS, each with ugly bugs

+        gcc_version="$($cc -v 2>&1 | grep version | cut -d ' ' -f3-)"

+        case "$gcc_version" in

+          2.9-beos-991026*|2.9-beos-000224*) echo "R5/GG gcc"

+            disable mmx

+            ;;

+          *20010315*) echo "BeBits gcc"

+            add_cflags -fno-expensive-optimizations

+            ;;

+        esac

+        SHFLAGS=-nostart

+        # enable BeOS things

+        enable audio_beos

+        # no need for libm, but the inet stuff

+        # Check for BONE

+        # XXX: actually should check for NOT net_server

+        if echo $BEINCLUDES | grep -q 'headers/be/bone'; then

+            network_extralibs="-lbind -lsocket"

+        else

+            enable beos_netserver

+            network_extralibs="-lnet"

+        fi ;;

     sunos)

         FFSERVERLDFLAGS=""

         SHFLAGS='-shared -Wl,-h,$$(@F)'

@@ -2324,16 +2180,14 @@

         enable malloc_aligned

         ;;

     bsd/os)

-        add_extralibs -lpoll -lgnugetopt

+        osextralibs="-lpoll -lgnugetopt"

         strip="strip -d"

         ;;

     darwin)

         enable malloc_aligned

-        gas="gas-preprocessor.pl $cc"

-        enabled ppc && add_asflags -force_cpusubtype_ALL

         SHFLAGS='-dynamiclib -Wl,-single_module -Wl,-install_name,$(SHLIBDIR)/$(SLIBNAME),-current_version,$(LIBVERSION),-compatibility_version,$(LIBMAJOR) -Wl,-read_only_relocs,suppress'

-        strip="${strip} -x"

-        add_ldflags -Wl,-dynamic,-search_paths_first

+        strip="strip -x"

+        FFLDFLAGS="-Wl,-dynamic,-search_paths_first"

         SLIBSUF=".dylib"

         SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME).$(LIBVERSION)$(SLIBSUF)'

         SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME).$(LIBMAJOR)$(SLIBSUF)'

@@ -2372,9 +2226,13 @@

         objformat="win32"

         enable dos_paths

         check_cflags -fno-common

-        check_cpp_condition _mingw.h "defined (__MINGW64_VERSION_MAJOR) || (__MINGW32_MAJOR_VERSION > 3) /

-                                      || (__MINGW32_MAJOR_VERSION == 3 && __MINGW32_MINOR_VERSION >= 15)" ||

+        if ! enabled x86_64; then

+            check_cpp_condition _mingw.h "(__MINGW32_MAJOR_VERSION > 3) || (__MINGW32_MAJOR_VERSION == 3 && __MINGW32_MINOR_VERSION >= 15)" ||

                 die "ERROR: MinGW runtime version must be >= 3.15."

+            enabled_any avisynth vfwcap_indev &&

+                { check_cpp_condition w32api.h "(__W32API_MAJOR_VERSION > 3) || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION >= 13)" ||

+                  die "ERROR: avisynth and vfwcap_indev require w32api version 3.13 or later."; }

+        fi

         ;;

     cygwin*)

         target_os=cygwin

@@ -2405,7 +2263,7 @@

     os/2*)

         strip="lxlite"

         ln_s="cp -f"

-        add_ldflags -Zomf -Zbin-files -Zargs-wild -Zmap

+        FFLDFLAGS="-Zomf -Zbin-files -Zargs-wild -Zmap"

         SHFLAGS='$(SUBDIR)$(NAME).def -Zdll -Zomf'

         FFSERVERLDFLAGS=""

         LIBSUF="_s.a"

@@ -2436,12 +2294,15 @@

         ;;

 esac

 

-echo "config:$arch:$subarch:$cpu:$target_os:$cc_ident:$FFMPEG_CONFIGURATION" >config.fate

-

 check_cpp_condition stdlib.h "defined(__PIC__) || defined(__pic__) || defined(PIC)" && enable pic

 

 set_default $PATHS_LIST

 

+add_extralibs $osextralibs

+

+# Combine FFLDFLAGS and the LDFLAGS environment variable.

+LDFLAGS="$FFLDFLAGS $LDFLAGS"

+

 # we need to build at least one lib type

 if ! enabled_any static shared; then

     cat <<EOF

@@ -2455,12 +2316,28 @@

 

 disabled static && LIBNAME=""

 

+if enabled_any libfaad libfaadbin ; then

+    if check_header faad.h; then

+        check_cc <<EOF

+#include <faad.h>

+#ifndef FAAD2_VERSION

+ok faad1

+#endif

+int main(void) { return 0; }

+EOF

+        test $? = 0 && enable libfaad2

+    else

+        die "FAAD test failed."

+    fi

+fi

+

+

 die_license_disabled() {

     enabled $1 || { enabled $2 && die "$2 is $1 and --enable-$1 is not specified."; }

 }

 

+die_license_disabled gpl libfaad2

 die_license_disabled gpl libx264

-die_license_disabled gpl libxavs

 die_license_disabled gpl libxvid

 die_license_disabled gpl postproc

 die_license_disabled gpl x11grab

@@ -2522,7 +2399,6 @@

 elif enabled arm; then

 

     check_cflags -marm

-    nogas=die

 

     check_ld <<EOF && enable vfp_args

 __asm__ (".eabi_attribute 28, 1");

@@ -2550,14 +2426,12 @@

 

     enable local_aligned_8 local_aligned_16

 

-    check_asm dcbzl     '"dcbzl 0, %0" :: "r"(0)'

-    check_asm ibm_asm   '"add 0, 0, 0"'

+    check_asm dcbzl     '"dcbzl 0, 1"'

     check_asm ppc4xx    '"maclhw r10, r11, r12"'

     check_asm xform_asm '"lwzx %1, %y0" :: "Z"(*(int*)0), "r"(0)'

 

     # AltiVec flags: The FSF version of GCC differs from the Apple version

     if enabled altivec; then

-        nogas=warn

         check_cflags -maltivec -mabi=altivec &&

         { check_header altivec.h && inc_altivec_h="#include <altivec.h>" ; } ||

         check_cflags -faltivec

@@ -2604,9 +2478,6 @@

     check_asm ebx_available '""::"b"(0)' &&

         check_asm ebx_available '"":::"%ebx"'

 

-    # check whether xmm clobbers are supported

-    check_asm xmm_clobbers '"":::"%xmm0"'

-

     # check whether more than 10 operands are supported

     check_cc <<EOF && enable ten_operands

 int main(void) {

@@ -2625,26 +2496,14 @@

 

     check_asm bswap '"bswap %%eax" ::: "%eax"'

 

-    if ! disabled_any asm mmx yasm; then

-        if check_cmd $yasmexe --version; then

-            enabled x86_64 && yasm_extra="-m amd64"

-            yasm_debug="-g dwarf2"

-        elif check_cmd nasm -v; then

-            yasmexe=nasm

-            yasm_debug="-g -F dwarf"

-            enabled x86_64 && test "$objformat" = elf && objformat=elf64

-        fi

-

-        YASMFLAGS="-f $objformat $yasm_extra"

-        enabled pic               && append YASMFLAGS "-DPIC"

-        test -n "$extern_prefix"  && append YASMFLAGS "-DPREFIX"

-        case "$objformat" in

-            elf*) enabled debug && append YASMFLAGS $yasm_debug ;;

-        esac

-

-        check_yasm "pabsw xmm0, xmm0" && enable yasm ||

-            die "yasm not found, use --disable-yasm for a crippled build"

-    fi

+    YASMFLAGS="-f $objformat -DARCH_$(toupper $subarch)"

+    enabled     x86_64        && append YASMFLAGS "-m amd64"

+    enabled     pic           && append YASMFLAGS "-DPIC"

+    test -n "$extern_prefix"  && append YASMFLAGS "-DPREFIX"

+    case "$objformat" in

+        elf) enabled debug && append YASMFLAGS "-g dwarf2" ;;

+    esac

+    disabled yasm || { check_yasm "pabsw xmm0, xmm0" && enable yasm; }

 

     case "$cpu" in

         athlon*|opteron*|k8*|pentium|pentium-mmx|prescott|nocona|atom|geode)

@@ -2654,12 +2513,6 @@

 

 fi

 

-if enabled asm; then

-    as=${gas:=$as}

-    check_asm gnu_as '".macro m n/n//n:.int 0/n.endm/nm x"' ||

-        $nogas "GNU assembler not found, install gas-preprocessor"

-fi

-

 if check_func dlopen; then

     ldl=

 elif check_func dlopen -ldl; then

@@ -2669,7 +2522,6 @@

 # Solaris has nanosleep in -lrt, OpenSolaris no longer needs that

 check_func nanosleep || { check_func nanosleep -lrt && add_extralibs -lrt; }

 

-check_func  fcntl

 check_func  fork

 check_func  getaddrinfo $network_extralibs

 check_func  gethrtime

@@ -2679,16 +2531,13 @@

 check_func  isatty

 check_func  ${malloc_prefix}memalign            && enable memalign

 check_func  mkstemp

-check_func  mmap

 check_func  ${malloc_prefix}posix_memalign      && enable posix_memalign

 check_func  setrlimit

 check_func  strerror_r

-check_func  strtok_r

 check_func_headers io.h setmode

 check_func_headers lzo/lzo1x.h lzo1x_999_compress

 check_lib2 "windows.h psapi.h" GetProcessMemoryInfo -lpsapi

 check_func_headers windows.h GetProcessTimes

-check_func_headers windows.h MapViewOfFile

 check_func_headers windows.h VirtualAlloc

 

 check_header conio.h

@@ -2716,8 +2565,7 @@

 

 # check for some common methods of building with pthread support

 # do this before the optional library checks as some of them require pthreads

-if ! disabled pthreads && ! enabled w32threads; then

-    enable pthreads

+if enabled pthreads; then

     if check_func pthread_create; then

         :

     elif check_func pthread_create -pthread; then

@@ -2729,7 +2577,7 @@

     elif check_func pthread_create -lpthreadGC2; then

         add_extralibs -lpthreadGC2

     elif ! check_lib pthread.h pthread_create -lpthread; then

-        disable pthreads

+        die "ERROR: can't find pthreads library"

     fi

 fi

 

@@ -2742,7 +2590,7 @@

 done

 

 check_lib math.h sin -lm

-disabled vaapi || check_lib va/va.h vaInitialize -lva

+check_lib va/va.h vaInitialize -lva

 

 check_mathfunc exp2

 check_mathfunc exp2f

@@ -2758,35 +2606,28 @@

 

 # these are off by default, so fail if requested and not available

 enabled avisynth   && require2 vfw32 "windows.h vfw.h" AVIFileInit -lavifil32

-enabled frei0r     && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }

 enabled libdirac   && add_cflags $(pkg-config --cflags dirac) &&

                       require  libdirac libdirac_decoder/dirac_parser.h dirac_decoder_init $(pkg-config --libs dirac) &&

                       require  libdirac libdirac_encoder/dirac_encoder.h dirac_encoder_init $(pkg-config --libs dirac)

 enabled libfaac    && require2 libfaac "stdint.h faac.h" faacEncGetVersion -lfaac

+enabled libfaad    && require2 libfaad faad.h faacDecOpen -lfaad

 enabled libgsm     && require  libgsm gsm/gsm.h gsm_create -lgsm

-enabled libmp3lame && require  "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame

+enabled libmp3lame && require  libmp3lame lame/lame.h lame_init -lmp3lame -lm

 enabled libnut     && require  libnut libnut.h nut_demuxer_init -lnut

-enabled libopencore_amrnb  && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb

-enabled libopencore_amrwb  && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb

-enabled libopencv  && { check_lib opencv/cv.h cvCreateImageHeader $(pkg-config --libs opencv) ||

-                        die "ERROR: libopencv not found"; }

+enabled libopencore_amrnb  && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb -lm

+enabled libopencore_amrwb  && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb -lm

 enabled libopenjpeg && require libopenjpeg openjpeg.h opj_version -lopenjpeg

-enabled librtmp    && { check_lib librtmp/rtmp.h RTMP_Socket $(pkg-config --libs librtmp) ||

-                        die "ERROR: librtmp not found or RTMP_Socket() missing, librtmp version must be >= 2.2.f"; }

+enabled librtmp    && require  librtmp librtmp/rtmp.h RTMP_Init $(pkg-config --libs librtmp)

 enabled libschroedinger && add_cflags $(pkg-config --cflags schroedinger-1.0) &&

                            require libschroedinger schroedinger/schro.h schro_init $(pkg-config --libs schroedinger-1.0)

 enabled libspeex   && require  libspeex speex/speex.h speex_decoder_init -lspeex

 enabled libtheora  && require  libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg

 enabled libvorbis  && require  libvorbis vorbis/vorbisenc.h vorbis_info_init -lvorbisenc -lvorbis -logg

-enabled libvpx     && {

-    enabled libvpx_decoder && { check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||

-                                die "ERROR: libvpx decoder version must be >=0.9.1"; }

-    enabled libvpx_encoder && { check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_enc_init_ver -lvpx ||

-                                die "ERROR: libvpx encoder version must be >=0.9.1"; } }

-enabled libx264    && require  libx264 x264.h x264_encoder_encode -lx264 &&

-                      { check_cpp_condition x264.h "X264_BUILD >= 99" ||

-                        die "ERROR: libx264 version must be >= 0.99."; }

-enabled libxavs    && require  libxavs xavs.h xavs_encoder_encode -lxavs

+enabled libvpx     && require2 libvpx "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_dec_init_ver" -lvpx &&

+                      require2 libvpx "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver" -lvpx

+enabled libx264    && require  libx264 x264.h x264_encoder_encode -lx264 -lm &&

+                      { check_cpp_condition x264.h "X264_BUILD >= 83" ||

+                        die "ERROR: libx264 version must be >= 0.83."; }

 enabled libxvid    && require  libxvid xvid.h xvid_global -lxvidcore

 enabled mlib       && require  mediaLib mlib_types.h mlib_VectorSub_S16_U8_Mod -lmlib

 

@@ -2814,7 +2655,7 @@

 if enabled network; then

     check_type "sys/types.h sys/socket.h" socklen_t

     check_type netdb.h "struct addrinfo"

-    check_type netinet/in.h "struct ipv6_mreq" -D_DARWIN_C_SOURCE

+    check_type netinet/in.h "struct ipv6_mreq"

     check_type netinet/in.h "struct sockaddr_in6"

     check_type "sys/types.h sys/socket.h" "struct sockaddr_storage"

     check_struct "sys/types.h sys/socket.h" "struct sockaddr" sa_len

@@ -2842,9 +2683,6 @@

 check_header sys/videoio.h

 

 check_func_headers "windows.h vfw.h" capCreateCaptureWindow "$vfwcap_indev_extralibs"

-# check that WM_CAP_DRIVER_CONNECT is defined to the proper value

-# w32api 3.12 had it defined wrong

-check_cpp_condition vfw.h "WM_CAP_DRIVER_CONNECT > WM_USER" && enable vfwcap_defines

 

 # check for ioctl_meteor.h, ioctl_bt848.h and alternatives

 { check_header dev/bktr/ioctl_meteor.h &&

@@ -2882,7 +2720,6 @@

 # add some useful compiler flags if supported

 check_cflags -Wdeclaration-after-statement

 check_cflags -Wall

-check_cflags -Wno-parentheses

 check_cflags -Wno-switch

 check_cflags -Wdisabled-optimization

 check_cflags -Wpointer-arith

@@ -2898,7 +2735,7 @@

 # add some linker flags

 check_ldflags -Wl,--warn-common

 check_ldflags -Wl,--as-needed

-check_ldflags '-Wl,-rpath-link,/$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,/$(BUILD_ROOT)/libswscale -Wl,-rpath-link,/$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,/$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,/$(BUILD_ROOT)/libavformat -Wl,-rpath-link,/$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,/$(BUILD_ROOT)/libavcore -Wl,-rpath-link,/$(BUILD_ROOT)/libavutil'

+check_ldflags '-Wl,-rpath-link,/$(BUILD_ROOT)/libpostproc -Wl,-rpath-link,/$(BUILD_ROOT)/libswscale -Wl,-rpath-link,/$(BUILD_ROOT)/libavfilter -Wl,-rpath-link,/$(BUILD_ROOT)/libavdevice -Wl,-rpath-link,/$(BUILD_ROOT)/libavformat -Wl,-rpath-link,/$(BUILD_ROOT)/libavcodec -Wl,-rpath-link,/$(BUILD_ROOT)/libavutil'

 check_ldflags -Wl,-Bsymbolic

 

 echo "X{};" > $TMPV

@@ -2931,9 +2768,8 @@

     # -wd: Disable following warnings

     # 144, 167, 556: -Wno-pointer-sign

     # 10006: ignoring unknown option -fno-signed-zeros

-    # 10148: ignoring unknown option -Wno-parentheses

     # 10156: ignoring option '-W'; no argument required

-    check_cflags -wd144,167,556,10006,10148,10156

+    check_cflags -wd144,167,556,10006,10156

     # 11030: Warning unknown option --as-needed

     # 10156: ignoring option '-export'; no argument required

     check_ldflags -wd10156,11030

@@ -2941,11 +2777,6 @@

     check_ldflags -march=$cpu

     # icc 11.0 and 11.1 work with ebp_available, but don't pass the test

     enable ebp_available

-    if enabled x86_32; then

-        test ${icc_version%%.*} -ge 11 && /

-            check_cflags -falign-stack=maintain-16-byte || /

-            disable aligned_stack

-    fi

 elif enabled ccc; then

     # disable some annoying warnings

     add_cflags -msg_disable cvtu32to64

@@ -2956,21 +2787,26 @@

     add_cflags -msg_disable unreachcode

 elif enabled gcc; then

     check_cflags -fno-tree-vectorize

-    check_cflags -Werror=implicit-function-declaration

+    check_cflags -Werror=implicit

     check_cflags -Werror=missing-prototypes

-elif enabled llvm_gcc; then

-    check_cflags -mllvm -stack-alignment=16

 elif enabled clang; then

-    check_cflags -mllvm -stack-alignment=16

     check_cflags -Qunused-arguments

 elif enabled armcc; then

     # 2523: use of inline assembler is deprecated

-    add_cflags -W${armcc_opt},--diag_suppress=2523

-    add_cflags -W${armcc_opt},--diag_suppress=1207

+    add_cflags -Wrvct,--diag_suppress=2523

+    add_cflags -Wrvct,--diag_suppress=1207

 elif enabled tms470; then

     add_cflags -pds=824 -pds=837

 fi

 

+if enabled gprof; then

+    add_cflags  -p

+    add_ldflags -p

+fi

+

+# Find out if the .align argument is a power of two or not.

+check_asm asmalign_pot '".align 3"'

+

 enabled_any $THREADS_LIST      && enable threads

 

 check_deps $CONFIG_LIST       /

@@ -2987,17 +2823,13 @@

            $INDEV_LIST        /

            $OUTDEV_LIST       /

            $PROTOCOL_LIST     /

-           $ACODEC_TESTS      /

-           $VCODEC_TESTS      /

-           $LAVF_TESTS        /

-           $LAVFI_TESTS       /

-           $SEEK_TESTS        /

 

 enabled asm || { arch=c; disable $ARCH_LIST $ARCH_EXT_LIST; }

 

 echo "install prefix            $prefix"

 echo "source path               $source_path"

 echo "C compiler                $cc"

+echo ".align is power-of-two    $asmalign_pot"

 echo "ARCH                      $arch ($cpu)"

 if test "$build_suffix" != ""; then

     echo "build suffix              $build_suffix"

@@ -3036,10 +2868,12 @@

     echo "AltiVec enabled           ${altivec-no}"

     echo "PPC 4xx optimizations     ${ppc4xx-no}"

     echo "dcbzl available           ${dcbzl-no}"

+    echo "performance report        ${powerpc_perf-no}"

 fi

 if enabled sparc; then

     echo "VIS enabled               ${vis-no}"

 fi

+echo "gprof enabled             ${gprof-no}"

 echo "debug symbols             ${debug-no}"

 echo "strip symbols             ${stripping-no}"

 echo "optimizations             ${optimizations-no}"

@@ -3047,21 +2881,22 @@

 echo "shared                    ${shared-no}"

 echo "postprocessing support    ${postproc-no}"

 echo "new filter support        ${avfilter-no}"

+echo "filters using lavformat   ${avfilter_lavf-no}"

 echo "network support           ${network-no}"

 echo "threading support         ${thread_type-no}"

 echo "SDL support               ${sdl-no}"

 echo "Sun medialib support      ${mlib-no}"

 echo "AVISynth enabled          ${avisynth-no}"

-echo "frei0r enabled            ${frei0r-no}"

 echo "libdc1394 support         ${libdc1394-no}"

 echo "libdirac enabled          ${libdirac-no}"

 echo "libfaac enabled           ${libfaac-no}"

+echo "libfaad enabled           ${libfaad-no}"

+echo "libfaad dlopened          ${libfaadbin-no}"

 echo "libgsm enabled            ${libgsm-no}"

 echo "libmp3lame enabled        ${libmp3lame-no}"

 echo "libnut enabled            ${libnut-no}"

 echo "libopencore-amrnb support ${libopencore_amrnb-no}"

 echo "libopencore-amrwb support ${libopencore_amrwb-no}"

-echo "libopencv support         ${libopencv-no}"

 echo "libopenjpeg enabled       ${libopenjpeg-no}"

 echo "librtmp enabled           ${librtmp-no}"

 echo "libschroedinger enabled   ${libschroedinger-no}"

@@ -3070,7 +2905,6 @@

 echo "libvorbis enabled         ${libvorbis-no}"

 echo "libvpx enabled            ${libvpx-no}"

 echo "libx264 enabled           ${libx264-no}"

-echo "libxavs enabled           ${libxavs-no}"

 echo "libxvid enabled           ${libxvid-no}"

 echo "zlib enabled              ${zlib-no}"

 echo "bzlib enabled             ${bzlib-no}"

@@ -3079,7 +2913,9 @@

 for type in decoder encoder hwaccel parser demuxer muxer protocol filter bsf indev outdev; do

     echo "Enabled ${type}s:"

     eval list=/$$(toupper $type)_LIST

-    print_enabled '_*' $list | sort | pr -3 -t

+    for part in $list; do

+        enabled $part && echo ${part%_*}

+    done | sort | pr -3 -t

     echo

 done

 

@@ -3104,10 +2940,8 @@

         doc

         libavcodec

         libavcodec/$arch

-        libavcore

         libavdevice

         libavfilter

-        libavfilter/$arch

         libavformat

         libavutil

         libavutil/$arch

@@ -3124,10 +2958,8 @@

         doc/texi2pod.pl

         libavcodec/Makefile

         libavcodec/${arch}/Makefile

-        libavcore/Makefile

         libavdevice/Makefile

         libavfilter/Makefile

-        libavfilter/${arch}/Makefile

         libavformat/Makefile

         libavutil/Makefile

         libpostproc/Makefile

@@ -3139,8 +2971,6 @@

 

 enabled stripping || strip="echo skipping strip"

 

-config_files="$TMPH config.mak"

-

 cat > config.mak <<EOF

 # Automatically generated by configure - do not modify!

 ifndef FFMPEG_CONFIG_MAK

@@ -3156,7 +2986,6 @@

 SRC_PATH="$source_path"

 SRC_PATH_BARE=$source_path

 BUILD_ROOT="$PWD"

-CC_IDENT=$cc_ident

 ARCH=$arch

 CC=$cc

 AS=$as

@@ -3227,12 +3056,13 @@

 get_version LIBSWSCALE  libswscale/swscale.h

 get_version LIBPOSTPROC libpostproc/postprocess.h

 get_version LIBAVCODEC  libavcodec/avcodec.h

-get_version LIBAVCORE   libavcore/avcore.h

 get_version LIBAVDEVICE libavdevice/avdevice.h

 get_version LIBAVFORMAT libavformat/avformat.h

 get_version LIBAVUTIL   libavutil/avutil.h

 get_version LIBAVFILTER libavfilter/avfilter.h

 

+enabled asmalign_pot || align_shift="1 <<"

+

 cat > $TMPH <<EOF

 /* Automatically generated by configure - do not modify! */

 #ifndef FFMPEG_CONFIG_H

@@ -3243,10 +3073,9 @@

 #define CC_TYPE "$cc_type"

 #define CC_VERSION $cc_version

 #define restrict $_restrict

-#define ASMALIGN(ZEROBITS) ".p2align " #ZEROBITS "//n//t"

+#define ASMALIGN(ZEROBITS) ".align $align_shift " #ZEROBITS "//n//t"

 #define EXTERN_PREFIX "${extern_prefix}"

 #define EXTERN_ASM ${extern_prefix}

-#define SLIBSUF "$SLIBSUF"

 EOF

 

 test -n "$malloc_prefix" &&

@@ -3254,50 +3083,30 @@

 

 if enabled small || disabled optimizations; then

     echo "#undef  av_always_inline"  >> $TMPH

-    if enabled small; then

-        echo "#define av_always_inline inline"  >> $TMPH

-    else

-        echo "#define av_always_inline av_unused"  >> $TMPH

-    fi

+    echo "#define av_always_inline"  >> $TMPH

 fi

 

-if enabled yasm; then

-    append config_files $TMPASM

-    printf '' >$TMPASM

-fi

-

-print_config ARCH_   "$config_files" $ARCH_LIST

-print_config HAVE_   "$config_files" $HAVE_LIST

-print_config CONFIG_ "$config_files" $CONFIG_LIST       /

-                                     $CONFIG_EXTRA      /

-                                     $DECODER_LIST      /

-                                     $ENCODER_LIST      /

-                                     $HWACCEL_LIST      /

-                                     $PARSER_LIST       /

-                                     $BSF_LIST          /

-                                     $DEMUXER_LIST      /

-                                     $MUXER_LIST        /

-                                     $FILTER_LIST       /

-                                     $PROTOCOL_LIST     /

-                                     $INDEV_LIST        /

-                                     $OUTDEV_LIST       /

-

-cat >>config.mak <<EOF

-ACODEC_TESTS=$(print_enabled -n _test $ACODEC_TESTS)

-VCODEC_TESTS=$(print_enabled -n _test $VCODEC_TESTS)

-LAVF_TESTS=$(print_enabled   -n _test $LAVF_TESTS)

-LAVFI_TESTS=$(print_enabled  -n _test $LAVFI_TESTS)

-SEEK_TESTS=$(print_enabled   -n _test $SEEK_TESTS)

-EOF

+print_config ARCH_   $TMPH config.mak $ARCH_LIST

+print_config HAVE_   $TMPH config.mak $HAVE_LIST

+print_config CONFIG_ $TMPH config.mak $CONFIG_LIST       /

+                                      $CONFIG_EXTRA      /

+                                      $DECODER_LIST      /

+                                      $ENCODER_LIST      /

+                                      $HWACCEL_LIST      /

+                                      $PARSER_LIST       /

+                                      $BSF_LIST          /

+                                      $DEMUXER_LIST      /

+                                      $MUXER_LIST        /

+                                      $FILTER_LIST       /

+                                      $PROTOCOL_LIST     /

+                                      $INDEV_LIST        /

+                                      $OUTDEV_LIST       /

 

 echo "#endif /* FFMPEG_CONFIG_H */" >> $TMPH

 echo "endif # FFMPEG_CONFIG_MAK" >> config.mak

 

 # Do not overwrite an unchanged config.h to avoid superfluous rebuilds.

 cp_if_changed $TMPH config.h

-touch .config

-

-enabled yasm && cp_if_changed $TMPASM config.asm

 

 cat > $TMPH <<EOF

 /* Generated by ffconf */

@@ -3305,14 +3114,12 @@

 #define AVUTIL_AVCONFIG_H

 EOF

 

-print_config AV_HAVE_ $TMPH $HAVE_LIST_PUB

+print_config AV_HAVE_ $TMPH /dev/null $HAVE_LIST_PUB

 

 echo "#endif /* AVUTIL_AVCONFIG_H */" >> $TMPH

 

 cp_if_changed $TMPH libavutil/avconfig.h

 

-test -n "$WARNINGS" && printf "/n$WARNINGS"

-

 # build pkg-config files

 

 pkgconfig_generate(){

@@ -3322,7 +3129,6 @@

 version=$3

 libs=$4

 requires=$5

-enabled ${name#lib} || return 0

 cat <<EOF > $name/$name.pc

 prefix=$prefix

 exec_prefix=/${prefix}

@@ -3356,10 +3162,11 @@

 }

 

 pkgconfig_generate libavutil "FFmpeg utility library" "$LIBAVUTIL_VERSION"

-pkgconfig_generate libavcore "FFmpeg multimedia shared core utilities library" "$LIBAVCORE_VERSION" "" "libavutil = $LIBAVUTIL_VERSION"

-pkgconfig_generate libavcodec "FFmpeg codec library" "$LIBAVCODEC_VERSION" "$extralibs" "libavcore = $LIBAVCORE_VERSION"

+pkgconfig_generate libavcodec "FFmpeg codec library" "$LIBAVCODEC_VERSION" "$extralibs" "libavutil = $LIBAVUTIL_VERSION"

 pkgconfig_generate libavformat "FFmpeg container format library" "$LIBAVFORMAT_VERSION" "$extralibs" "libavcodec = $LIBAVCODEC_VERSION"

 pkgconfig_generate libavdevice "FFmpeg device handling library" "$LIBAVDEVICE_VERSION" "$extralibs" "libavformat = $LIBAVFORMAT_VERSION"

-pkgconfig_generate libavfilter "FFmpeg video filtering library" "$LIBAVFILTER_VERSION" "$extralibs" "libavcore = $LIBAVCORE_VERSION"

-pkgconfig_generate libpostproc "FFmpeg post processing library" "$LIBPOSTPROC_VERSION"

+enabled avfilter &&

+    pkgconfig_generate libavfilter "FFmpeg video filtering library" "$LIBAVFILTER_VERSION" "$extralibs" "libavutil = $LIBAVUTIL_VERSION"

+enabled postproc &&

+    pkgconfig_generate libpostproc "FFmpeg post processing library" "$LIBPOSTPROC_VERSION"

 pkgconfig_generate libswscale "FFmpeg image rescaling library" "$LIBSWSCALE_VERSION" "" "libavutil = $LIBAVUTIL_VERSION"

Common subdirectories: ffmpeg/doc and ffmpeg-0.6.1/doc

diff -u ffmpeg/Doxyfile ffmpeg-0.6.1/Doxyfile

--- ffmpeg/Doxyfile 2011-01-08 09:07:51.371129744 -0800

+++ ffmpeg-0.6.1/Doxyfile 2010-03-18 08:00:18.000000000 -0700

@@ -1,4 +1,4 @@

-# Doxyfile 1.5.6

+# Doxyfile 1.3-rc1

 

 # This file describes the settings to be used by the documentation system

 # doxygen (www.doxygen.org) for a project

@@ -11,17 +11,9 @@

 # Values that contain spaces should be placed between quotes (" ")

 

 #---------------------------------------------------------------------------

-# Project related configuration options

+# General configuration options

 #---------------------------------------------------------------------------

 

-# This tag specifies the encoding used for all characters in the config file

-# that follow. The default is UTF-8 which is also the encoding used for all

-# text before the first occurrence of this tag. Doxygen uses libiconv (or the

-# iconv built into libc) for the transcoding. See

-# http://www.gnu.org/software/libiconv for the list of possible encodings.

-

-DOXYFILE_ENCODING      = UTF-8

-

 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded

 # by quotes) that should identify the project.

 

@@ -40,238 +32,17 @@

 

 OUTPUT_DIRECTORY       = doxy

 

-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create

-# 4096 sub-directories (in 2 levels) under the output directory of each output

-# format and will distribute the generated files over these directories.

-# Enabling this option can be useful when feeding doxygen a huge amount of

-# source files, where putting all generated files in the same directory would

-# otherwise cause performance problems for the file system.

-

-CREATE_SUBDIRS         = NO

-

 # The OUTPUT_LANGUAGE tag is used to specify the language in which all

 # documentation generated by doxygen is written. Doxygen will use this

 # information to generate all constant output in the proper language.

 # The default language is English, other supported languages are:

-# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,

-# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek,

-# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages),

-# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish,

-# Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish,

-# and Ukrainian.

+# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch,

+# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en

+# (Japanese with english messages), Korean, Norwegian, Polish, Portuguese,

+# Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish and Ukrainian.

 

 OUTPUT_LANGUAGE        = English

 

-# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will

-# include brief member descriptions after the members that are listed in

-# the file and class documentation (similar to JavaDoc).

-# Set to NO to disable this.

-

-BRIEF_MEMBER_DESC      = YES

-

-# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend

-# the brief description of a member or function before the detailed description.

-# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the

-# brief descriptions will be completely suppressed.

-

-REPEAT_BRIEF           = YES

-

-# This tag implements a quasi-intelligent brief description abbreviator

-# that is used to form the text in various listings. Each string

-# in this list, if found as the leading text of the brief description, will be

-# stripped from the text and the result after processing the whole list, is

-# used as the annotated text. Otherwise, the brief description is used as-is.

-# If left blank, the following values are used ("$name" is automatically

-# replaced with the name of the entity): "The $name class" "The $name widget"

-# "The $name file" "is" "provides" "specifies" "contains"

-# "represents" "a" "an" "the"

-

-ABBREVIATE_BRIEF       =

-

-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then

-# Doxygen will generate a detailed section even if there is only a brief

-# description.

-

-ALWAYS_DETAILED_SEC    = NO

-

-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all

-# inherited members of a class in the documentation of that class as if those

-# members were ordinary class members. Constructors, destructors and assignment

-# operators of the base classes will not be shown.

-

-INLINE_INHERITED_MEMB  = NO

-

-# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full

-# path before files name in the file list and in the header files. If set

-# to NO the shortest path that makes the file name unique will be used.

-

-FULL_PATH_NAMES        = YES

-

-# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag

-# can be used to strip a user-defined part of the path. Stripping is

-# only done if one of the specified strings matches the left-hand part of

-# the path. The tag can be used to show relative paths in the file list.

-# If left blank the directory from which doxygen is run is used as the

-# path to strip.

-

-STRIP_FROM_PATH        = .

-

-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of

-# the path mentioned in the documentation of a class, which tells

-# the reader which header file to include in order to use a class.

-# If left blank only the name of the header file containing the class

-# definition is used. Otherwise one should specify the include paths that

-# are normally passed to the compiler using the -I flag.

-

-STRIP_FROM_INC_PATH    =

-

-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter

-# (but less readable) file names. This can be useful is your file systems

-# doesn't support long names like on DOS, Mac, or CD-ROM.

-

-SHORT_NAMES            = NO

-

-# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen

-# will interpret the first line (until the first dot) of a JavaDoc-style

-# comment as the brief description. If set to NO, the JavaDoc

-# comments will behave just like regular Qt-style comments

-# (thus requiring an explicit @brief command for a brief description.)

-

-JAVADOC_AUTOBRIEF      = YES

-

-# If the QT_AUTOBRIEF tag is set to YES then Doxygen will

-# interpret the first line (until the first dot) of a Qt-style

-# comment as the brief description. If set to NO, the comments

-# will behave just like regular Qt-style comments (thus requiring

-# an explicit /brief command for a brief description.)

-

-QT_AUTOBRIEF           = NO

-

-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen

-# treat a multi-line C++ special comment block (i.e. a block of //! or ///

-# comments) as a brief description. This used to be the default behaviour.

-# The new default is to treat a multi-line C++ comment block as a detailed

-# description. Set this tag to YES if you prefer the old behaviour instead.

-

-MULTILINE_CPP_IS_BRIEF = NO

-

-# If the DETAILS_AT_TOP tag is set to YES then Doxygen

-# will output the detailed description near the top, like JavaDoc.

-# If set to NO, the detailed description appears after the member

-# documentation.

-

-DETAILS_AT_TOP         = NO

-

-# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented

-# member inherits the documentation from any documented member that it

-# re-implements.

-

-INHERIT_DOCS           = YES

-

-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce

-# a new page for each member. If set to NO, the documentation of a member will

-# be part of the file/class/namespace that contains it.

-

-SEPARATE_MEMBER_PAGES  = NO

-

-# The TAB_SIZE tag can be used to set the number of spaces in a tab.

-# Doxygen uses this value to replace tabs by spaces in code fragments.

-

-TAB_SIZE               = 8

-

-# This tag can be used to specify a number of aliases that acts

-# as commands in the documentation. An alias has the form "name=value".

-# For example adding "sideeffect=/par Side Effects:/n" will allow you to

-# put the command /sideeffect (or @sideeffect) in the documentation, which

-# will result in a user-defined paragraph with heading "Side Effects:".

-# You can put /n's in the value part of an alias to insert newlines.

-

-ALIASES                =

-

-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C

-# sources only. Doxygen will then generate output that is more tailored for C.

-# For instance, some of the names that are used will be different. The list

-# of all members will be omitted, etc.

-

-OPTIMIZE_OUTPUT_FOR_C  = YES

-

-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java

-# sources only. Doxygen will then generate output that is more tailored for

-# Java. For instance, namespaces will be presented as packages, qualified

-# scopes will look different, etc.

-

-OPTIMIZE_OUTPUT_JAVA   = NO

-

-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran

-# sources only. Doxygen will then generate output that is more tailored for

-# Fortran.

-

-OPTIMIZE_FOR_FORTRAN   = NO

-

-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL

-# sources. Doxygen will then generate output that is tailored for

-# VHDL.

-

-OPTIMIZE_OUTPUT_VHDL   = NO

-

-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want

-# to include (a tag file for) the STL sources as input, then you should

-# set this tag to YES in order to let doxygen match functions declarations and

-# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.

-# func(std::string) {}). This also make the inheritance and collaboration

-# diagrams that involve STL classes more complete and accurate.

-

-BUILTIN_STL_SUPPORT    = NO

-

-# If you use Microsoft's C++/CLI language, you should set this option to YES to

-# enable parsing support.

-

-CPP_CLI_SUPPORT        = NO

-

-# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.

-# Doxygen will parse them like normal C++ but will assume all classes use public

-# instead of private inheritance when no explicit protection keyword is present.

-

-SIP_SUPPORT            = NO

-

-# For Microsoft's IDL there are propget and propput attributes to indicate getter

-# and setter methods for a property. Setting this option to YES (the default)

-# will make doxygen to replace the get and set methods by a property in the

-# documentation. This will only work if the methods are indeed getting or

-# setting a simple type. If this is not the case, or you want to show the

-# methods anyway, you should set this option to NO.

-

-IDL_PROPERTY_SUPPORT   = YES

-

-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC

-# tag is set to YES, then doxygen will reuse the documentation of the first

-# member in the group (if any) for the other members of the group. By default

-# all members of a group must be documented explicitly.

-

-DISTRIBUTE_GROUP_DOC   = NO

-

-# Set the SUBGROUPING tag to YES (the default) to allow class member groups of

-# the same type (for instance a group of public functions) to be put as a

-# subgroup of that type (e.g. under the Public Functions section). Set it to

-# NO to prevent subgrouping. Alternatively, this can be done per class using

-# the /nosubgrouping command.

-

-SUBGROUPING            = YES

-

-# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum

-# is documented as struct, union, or enum with the name of the typedef. So

-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct

-# with name TypeT. When disabled the typedef will appear as a member of a file,

-# namespace, or class. And the struct will be named TypeS. This can typically

-# be useful for C code in case the coding convention dictates that all compound

-# types are typedef'ed and only the typedef is referenced, never the tag name.

-

-TYPEDEF_HIDES_STRUCT   = NO

-

-#---------------------------------------------------------------------------

-# Build related configuration options

-#---------------------------------------------------------------------------

-

 # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in

 # documentation are documented, even if no documentation was available.

 # Private class members and static file members will be hidden unless

@@ -295,21 +66,6 @@

 

 EXTRACT_LOCAL_CLASSES  = YES

 

-# This flag is only useful for Objective-C code. When set to YES local

-# methods, which are defined in the implementation section but not in

-# the interface are included in the documentation.

-# If set to NO (the default) only methods in the interface are included.

-

-EXTRACT_LOCAL_METHODS  = NO

-

-# If this flag is set to YES, the members of anonymous namespaces will be

-# extracted and appear in the documentation as a namespace called

-# 'anonymous_namespace{file}', where file will be replaced with the base

-# name of the file that contains the anonymous namespace. By default

-# anonymous namespace are hidden.

-

-EXTRACT_ANON_NSPACES   = NO

-

 # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all

 # undocumented members of documented classes, files or namespaces.

 # If set to NO (the default) these members will be included in the

@@ -320,7 +76,7 @@

 

 # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all

 # undocumented classes that are normally visible in the class hierarchy.

-# If set to NO (the default) these classes will be included in the various

+# If set to NO (the default) these class will be included in the various

 # overviews. This option has no effect if EXTRACT_ALL is enabled.

 

 HIDE_UNDOC_CLASSES     = NO

@@ -339,6 +95,46 @@

 

 HIDE_IN_BODY_DOCS      = NO

 

+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will

+# include brief member descriptions after the members that are listed in

+# the file and class documentation (similar to JavaDoc).

+# Set to NO to disable this.

+

+BRIEF_MEMBER_DESC      = YES

+

+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend

+# the brief description of a member or function before the detailed description.

+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the

+# brief descriptions will be completely suppressed.

+

+REPEAT_BRIEF           = YES

+

+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then

+# Doxygen will generate a detailed section even if there is only a brief

+# description.

+

+ALWAYS_DETAILED_SEC    = NO

+

+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited

+# members of a class in the documentation of that class as if those members were

+# ordinary class members. Constructors, destructors and assignment operators of

+# the base classes will not be shown.

+

+INLINE_INHERITED_MEMB  = NO

+

+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full

+# path before files name in the file list and in the header files. If set

+# to NO the shortest path that makes the file name unique will be used.

+

+FULL_PATH_NAMES        = YES

+

+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag

+# can be used to strip a user defined part of the path. Stripping is

+# only done if one of the specified strings matches the left-hand part of

+# the path. It is allowed to use relative paths in the argument list.

+

+STRIP_FROM_PATH        = .

+

 # The INTERNAL_DOCS tag determines if documentation

 # that is typed after a /internal command is included. If the tag is set

 # to NO (the default) then the documentation will be excluded.

@@ -347,25 +143,66 @@

 INTERNAL_DOCS          = NO

 

 # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate

-# file names in lower-case letters. If set to YES upper-case letters are also

+# file names in lower case letters. If set to YES upper case letters are also

 # allowed. This is useful if you have classes or files whose names only differ

 # in case and if your file system supports case sensitive file names. Windows

-# and Mac users are advised to set this option to NO.

+# users are adviced to set this option to NO.

 

 CASE_SENSE_NAMES       = YES

 

+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter

+# (but less readable) file names. This can be useful is your file systems

+# doesn't support long names like on DOS, Mac, or CD-ROM.

+

+SHORT_NAMES            = NO

+

 # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen

 # will show members with their full class and namespace scopes in the

 # documentation. If set to YES the scope will be hidden.

 

 HIDE_SCOPE_NAMES       = NO

 

+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen

+# will generate a verbatim copy of the header file for each class for

+# which an include is specified. Set to NO to disable this.

+

+VERBATIM_HEADERS       = YES

+

 # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen

-# will put a list of the files that are included by a file in the documentation

+# will put list of the files that are included by a file in the documentation

 # of that file.

 

 SHOW_INCLUDE_FILES     = YES

 

+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen

+# will interpret the first line (until the first dot) of a JavaDoc-style

+# comment as the brief description. If set to NO, the JavaDoc

+# comments  will behave just like the Qt-style comments (thus requiring an

+# explict @brief command for a brief description.

+

+JAVADOC_AUTOBRIEF      = YES

+

+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen

+# treat a multi-line C++ special comment block (i.e. a block of //! or ///

+# comments) as a brief description. This used to be the default behaviour.

+# The new default is to treat a multi-line C++ comment block as a detailed

+# description. Set this tag to YES if you prefer the old behaviour instead.

+

+MULTILINE_CPP_IS_BRIEF = NO

+

+# If the DETAILS_AT_TOP tag is set to YES then Doxygen

+# will output the detailed description near the top, like JavaDoc.

+# If set to NO, the detailed description appears after the member

+# documentation.

+

+DETAILS_AT_TOP         = NO

+

+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented

+# member inherits the documentation from any documented member that it

+# reimplements.

+

+INHERIT_DOCS           = YES

+

 # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]

 # is inserted in the documentation for inline members.

 

@@ -378,28 +215,17 @@

 

 SORT_MEMBER_DOCS       = YES

 

-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the

-# brief documentation of file, namespace and class members alphabetically

-# by member name. If set to NO (the default) the members will appear in

-# declaration order.

+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC

+# tag is set to YES, then doxygen will reuse the documentation of the first

+# member in the group (if any) for the other members of the group. By default

+# all members of a group must be documented explicitly.

 

-SORT_BRIEF_DOCS        = NO

+DISTRIBUTE_GROUP_DOC   = NO

 

-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the

-# hierarchy of group names into alphabetical order. If set to NO (the default)

-# the group names will appear in their defined order.

-

-SORT_GROUP_NAMES       = NO

-

-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be

-# sorted by fully-qualified names, including namespaces. If set to

-# NO (the default), the class list will be sorted only by class name,

-# not including the namespace part.

-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.

-# Note: This option applies only to the class list, not to the

-# alphabetical list.

+# The TAB_SIZE tag can be used to set the number of spaces in a tab.

+# Doxygen uses this value to replace tabs by spaces in code fragments.

 

-SORT_BY_SCOPE_NAME     = NO

+TAB_SIZE               = 8

 

 # The GENERATE_TODOLIST tag can be used to enable (YES) or

 # disable (NO) the todo list. This list is created by putting /todo

@@ -425,13 +251,22 @@

 

 GENERATE_DEPRECATEDLIST= YES

 

+# This tag can be used to specify a number of aliases that acts

+# as commands in the documentation. An alias has the form "name=value".

+# For example adding "sideeffect=/par Side Effects:/n" will allow you to

+# put the command /sideeffect (or @sideeffect) in the documentation, which

+# will result in a user defined paragraph with heading "Side Effects:".

+# You can put /n's in the value part of an alias to insert newlines.

+

+ALIASES                =

+

 # The ENABLED_SECTIONS tag can be used to enable conditional

 # documentation sections, marked by /if sectionname ... /endif.

 

 ENABLED_SECTIONS       =

 

 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines

-# the initial value of a variable or define consists of for it to appear in

+# the initial value of a variable or define consist of for it to appear in

 # the documentation. If the initializer consists of more lines than specified

 # here it will be hidden. Use a value of 0 to hide initializers completely.

 # The appearance of the initializer of individual variables and defines in the

@@ -440,39 +275,25 @@

 

 MAX_INITIALIZER_LINES  = 30

 

-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated

-# at the bottom of the documentation of classes and structs. If set to YES the

-# list will mention the files that were used to generate the documentation.

-

-SHOW_USED_FILES        = YES

-

-# If the sources in your project are distributed over multiple directories

-# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy

-# in the documentation. The default is NO.

-

-SHOW_DIRECTORIES       = NO

-

-# Set the SHOW_FILES tag to NO to disable the generation of the Files page.

-# This will remove the Files entry from the Quick Index and from the

-# Folder Tree View (if specified). The default is YES.

+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources

+# only. Doxygen will then generate output that is more tailored for C.

+# For instance some of the names that are used will be different. The list

+# of all members will be omitted, etc.

 

-SHOW_FILES             = YES

+OPTIMIZE_OUTPUT_FOR_C  = YES

 

-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the

-# Namespaces page.  This will remove the Namespaces entry from the Quick Index

-# and from the Folder Tree View (if specified). The default is YES.

+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources

+# only. Doxygen will then generate output that is more tailored for Java.

+# For instance namespaces will be presented as packages, qualified scopes

+# will look different, etc.

 

-SHOW_NAMESPACES        = YES

+OPTIMIZE_OUTPUT_JAVA   = NO

 

-# The FILE_VERSION_FILTER tag can be used to specify a program or script that

-# doxygen should invoke to get the current version for each file (typically from

-# the version control system). Doxygen will invoke the program by executing (via

-# popen()) the command <command> <input-file>, where <command> is the value of

-# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file

-# provided by doxygen. Whatever the program writes to standard output

-# is used as the file version. See the manual for examples.

+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated

+# at the bottom of the documentation of classes and structs. If set to YES the

+# list will mention the files that were used to generate the documentation.

 

-FILE_VERSION_FILTER    =

+SHOW_USED_FILES        = YES

 

 #---------------------------------------------------------------------------

 # configuration options related to warning and progress messages

@@ -481,7 +302,7 @@

 # The QUIET tag can be used to turn on/off the messages that are generated

 # by doxygen. Possible values are YES and NO. If left blank NO is used.

 

-QUIET                  = YES

+QUIET                  = NO

 

 # The WARNINGS tag can be used to turn on/off the warning messages that are

 # generated by doxygen. Possible values are YES and NO. If left blank

@@ -495,27 +316,10 @@

 

 WARN_IF_UNDOCUMENTED   = YES

 

-# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for

-# potential errors in the documentation, such as not documenting some

-# parameters in a documented function, or documenting parameters that

-# don't exist or using markup commands wrongly.

-

-WARN_IF_DOC_ERROR      = YES

-

-# This WARN_NO_PARAMDOC option can be abled to get warnings for

-# functions that are documented, but have no documentation for their parameters

-# or return value. If set to NO (the default) doxygen will only warn about

-# wrong or incomplete parameter documentation, but not about the absence of

-# documentation.

-

-WARN_NO_PARAMDOC       = NO

-

 # The WARN_FORMAT tag determines the format of the warning messages that

 # doxygen can produce. The string should contain the $file, $line, and $text

 # tags, which will be replaced by the file and line number from which the

-# warning originated and the warning text. Optionally the format may contain

-# $version, which will be replaced by the version of the file (if it could

-# be obtained via FILE_VERSION_FILTER)

+# warning originated and the warning text.

 

 WARN_FORMAT            = "$file:$line: $text"

 

@@ -536,20 +340,12 @@

 

 INPUT                  =

 

-# This tag can be used to specify the character encoding of the source files

-# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

-# also the default input encoding. Doxygen uses libiconv (or the iconv built

-# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for

-# the list of possible encodings.

-

-INPUT_ENCODING         = UTF-8

-

 # If the value of the INPUT tag contains directories, you can use the

 # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp

 # and *.h) to filter out the source-files in the directories. If left

 # blank the following patterns are tested:

-# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx

-# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90

+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp

+# *.h++ *.idl *.odl

 

 FILE_PATTERNS          =

 

@@ -565,27 +361,16 @@

 

 EXCLUDE                =

 

-# The EXCLUDE_SYMLINKS tag can be used select whether or not files or

-# directories that are symbolic links (a Unix filesystem feature) are excluded

-# from the input.

+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories

+# that are symbolic links (a Unix filesystem feature) are excluded from the input.

 

 EXCLUDE_SYMLINKS       = NO

 

 # If the value of the INPUT tag contains directories, you can use the

 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude

-# certain files from those directories. Note that the wildcards are matched

-# against the file with absolute path, so to exclude all test directories

-# for example use the pattern */test/*

-

-EXCLUDE_PATTERNS       = *.svn *.git *.d

-

-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names

-# (namespaces, classes, functions, etc.) that should be excluded from the

-# output. The symbol name can be a fully qualified name, a word, or if the

-# wildcard * is used, a substring. Examples: ANamespace, AClass,

-# AClass::ANamespace, ANamespace::*Test

+# certain files from those directories.

 

-EXCLUDE_SYMBOLS        =

+EXCLUDE_PATTERNS       = *.svn *.git

 

 # The EXAMPLE_PATH tag can be used to specify one or more files or

 # directories that contain example code fragments that are included (see

@@ -618,20 +403,10 @@

 # by executing (via popen()) the command <filter> <input-file>, where <filter>

 # is the value of the INPUT_FILTER tag, and <input-file> is the name of an

 # input file. Doxygen will then use the output that the filter program writes

-# to standard output.  If FILTER_PATTERNS is specified, this tag will be

-# ignored.

+# to standard output.

 

 INPUT_FILTER           =

 

-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern

-# basis.  Doxygen will compare the file name with each pattern and apply the

-# filter if there is a match.  The filters are a list of the form:

-# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further

-# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER

-# is applied to all files.

-

-FILTER_PATTERNS        =

-

 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using

 # INPUT_FILTER) will be used to filter the input files when producing source

 # files to browse (i.e. when SOURCE_BROWSER is set to YES).

@@ -644,8 +419,6 @@

 

 # If the SOURCE_BROWSER tag is set to YES then a list of source files will

 # be generated. Documented entities will be cross-referenced with these sources.

-# Note: To get rid of all source code in the generated output, make sure also

-# VERBATIM_HEADERS is set to NO.

 

 SOURCE_BROWSER         = YES

 

@@ -660,39 +433,18 @@

 

 STRIP_CODE_COMMENTS    = YES

 

-# If the REFERENCED_BY_RELATION tag is set to YES

+# If the REFERENCED_BY_RELATION tag is set to YES (the default)

 # then for each documented function all documented

 # functions referencing it will be listed.

 

 REFERENCED_BY_RELATION = YES

 

-# If the REFERENCES_RELATION tag is set to YES

+# If the REFERENCES_RELATION tag is set to YES (the default)

 # then for each documented function all documented entities

 # called/used by that function will be listed.

 

 REFERENCES_RELATION    = NO

 

-# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)

-# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from

-# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will

-# link to the source code.  Otherwise they will link to the documentstion.

-

-REFERENCES_LINK_SOURCE = YES

-

-# If the USE_HTAGS tag is set to YES then the references to source code

-# will point to the HTML generated by the htags(1) tool instead of doxygen

-# built-in source browser. The htags tool is part of GNU's global source

-# tagging system (see http://www.gnu.org/software/global/global.html). You

-# will need version 4.8.6 or higher.

-

-USE_HTAGS              = NO

-

-# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen

-# will generate a verbatim copy of the header file for each class for

-# which an include is specified. Set to NO to disable this.

-

-VERBATIM_HEADERS       = YES

-

 #---------------------------------------------------------------------------

 # configuration options related to the alphabetical class index

 #---------------------------------------------------------------------------

@@ -749,12 +501,10 @@

 

 HTML_FOOTER            =

 

-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading

+# The HTML_STYLESHEET tag can be used to specify a user defined cascading

 # style sheet that is used by each HTML page. It can be used to

 # fine-tune the look of the HTML output. If the tag is left blank doxygen

-# will generate a default style sheet. Note that doxygen will try to copy

-# the style sheet file to the HTML output directory, so don't put your own

-# stylesheet in the HTML output directory as well, or it will be erased!

+# will generate a default style sheet

 

 HTML_STYLESHEET        =

 

@@ -766,55 +516,22 @@

 

 # If the GENERATE_HTMLHELP tag is set to YES, additional index files

 # will be generated that can be used as input for tools like the

-# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)

+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)

 # of the generated HTML documentation.

 

 GENERATE_HTMLHELP      = NO

 

-# If the GENERATE_DOCSET tag is set to YES, additional index files

-# will be generated that can be used as input for Apple's Xcode 3

-# integrated development environment, introduced with OSX 10.5 (Leopard).

-# To create a documentation set, doxygen will generate a Makefile in the

-# HTML output directory. Running make will produce the docset in that

-# directory and running "make install" will install the docset in

-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find

-# it at startup.

-

-GENERATE_DOCSET        = NO

-

-# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the

-# feed. A documentation feed provides an umbrella under which multiple

-# documentation sets from a single provider (such as a company or product suite)

-# can be grouped.

-

-DOCSET_FEEDNAME        = "Doxygen generated docs"

-

-# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that

-# should uniquely identify the documentation set bundle. This should be a

-# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen

-# will append .docset to the name.

-

-DOCSET_BUNDLE_ID       = org.doxygen.Project

-

-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML

-# documentation will contain sections that can be hidden and shown after the

-# page has loaded. For this to work a browser that supports

-# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox

-# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).

-

-HTML_DYNAMIC_SECTIONS  = NO

-

 # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can

 # be used to specify the file name of the resulting .chm file. You

 # can add a path in front of the file if the result should not be

-# written to the html output directory.

+# written to the html output dir.

 

 CHM_FILE               =

 

 # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can

 # be used to specify the location (absolute path including file name) of

-# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run

-# the HTML help compiler on the generated index.hhp.

+# the HTML help compiler (hhc.exe). If non empty doxygen will try to run

+# the html help compiler on the generated index.hhp.

 

 HHC_LOCATION           =

 

@@ -824,12 +541,6 @@

 

 GENERATE_CHI           = NO

 

-# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING

-# is used to encode HtmlHelp index (hhk), content (hhc) and project file

-# content.

-

-CHM_INDEX_ENCODING     =

-

 # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag

 # controls whether a binary table of contents is generated (YES) or a

 # normal table of contents (NO) in the .chm file.

@@ -837,7 +548,7 @@

 BINARY_TOC             = NO

 

 # The TOC_EXPAND flag can be set to YES to add extra items for group members

-# to the contents of the HTML help documentation and to the tree view.

+# to the contents of the Html help documentation and to the tree view.

 

 TOC_EXPAND             = NO

 

@@ -852,20 +563,13 @@

 

 ENUM_VALUES_PER_LINE   = 4

 

-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index

-# structure should be generated to display hierarchical information.

-# If the tag value is set to FRAME, a side panel will be generated

-# containing a tree-like index structure (just like the one that

+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be

+# generated containing a tree-like index structure (just like the one that

 # is generated for HTML Help). For this to work a browser that supports

-# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,

-# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are

-# probably better off using the HTML help feature. Other possible values

-# for this tag are: HIERARCHIES, which will generate the Groups, Directories,

-# and Class Hiererachy pages using a tree view instead of an ordered list;

-# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which

-# disables this behavior completely. For backwards compatibility with previous

-# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE

-# respectively.

+# JavaScript and frames is required (for instance Mozilla, Netscape 4.0+,

+# or Internet explorer 4.0+). Note that for large projects the tree generation

+# can take a very long time. In such cases it is better to disable this feature.

+# Windows users are probably better off using the HTML help feature.

 

 GENERATE_TREEVIEW      = NO

 

@@ -875,14 +579,6 @@

 

 TREEVIEW_WIDTH         = 250

 

-# Use this tag to change the font size of Latex formulas included

-# as images in the HTML documentation. The default is 10. Note that

-# when you change the font size after a successful doxygen run you need

-# to manually remove any form_*.png images from the HTML output directory

-# to force them to be regenerated.

-

-FORMULA_FONTSIZE       = 10

-

 #---------------------------------------------------------------------------

 # configuration options related to the LaTeX output

 #---------------------------------------------------------------------------

@@ -890,7 +586,7 @@

 # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will

 # generate Latex output.

 

-GENERATE_LATEX         = NO

+GENERATE_LATEX         = YES

 

 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.

 # If a relative path is entered the value of OUTPUT_DIRECTORY will be

@@ -953,12 +649,6 @@

 

 LATEX_BATCHMODE        = NO

 

-# If LATEX_HIDE_INDICES is set to YES then doxygen will not

-# include the index chapters (such as File Index, Compound Index, etc.)

-# in the output.

-

-LATEX_HIDE_INDICES     = NO

-

 #---------------------------------------------------------------------------

 # configuration options related to the RTF output

 #---------------------------------------------------------------------------

@@ -991,7 +681,7 @@

 RTF_HYPERLINKS         = NO

 

 # Load stylesheet definitions from file. Syntax is similar to doxygen's

-# config file, i.e. a series of assignments. You only have to provide

+# config file, i.e. a series of assigments. You only have to provide

 # replacements, missing definitions are set to their default value.

 

 RTF_STYLESHEET_FILE    =

@@ -1035,16 +725,12 @@

 

 # If the GENERATE_XML tag is set to YES Doxygen will

 # generate an XML file that captures the structure of

-# the code including all documentation.

+# the code including all documentation. Note that this

+# feature is still experimental and incomplete at the

+# moment.

 

 GENERATE_XML           = NO

 

-# The XML_OUTPUT tag is used to specify where the XML pages will be put.

-# If a relative path is entered the value of OUTPUT_DIRECTORY will be

-# put in front of it. If left blank `xml' will be used as the default path.

-

-XML_OUTPUT             = xml

-

 # The XML_SCHEMA tag can be used to specify an XML schema,

 # which can be used by a validating XML parser to check the

 # syntax of the XML files.

@@ -1057,13 +743,6 @@

 

 XML_DTD                =

 

-# If the XML_PROGRAMLISTING tag is set to YES Doxygen will

-# dump the program listings (including syntax highlighting

-# and cross-referencing information) to the XML output. Note that

-# enabling this will significantly increase the size of the XML output.

-

-XML_PROGRAMLISTING     = YES

-

 #---------------------------------------------------------------------------

 # configuration options for the AutoGen Definitions output

 #---------------------------------------------------------------------------

@@ -1128,7 +807,7 @@

 

 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES

 # then the macro expansion is limited to the macros specified with the

-# PREDEFINED and EXPAND_AS_DEFINED tags.

+# PREDEFINED and EXPAND_AS_PREDEFINED tags.

 

 EXPAND_ONLY_PREDEF     = YES

 

@@ -1154,9 +833,7 @@

 # are defined before the preprocessor is started (similar to the -D option of

 # gcc). The argument of the tag is a list of macros of the form: name

 # or name=definition (no spaces). If the definition and the = are

-# omitted =1 is assumed. To prevent a macro definition from being

-# undefined via #undef or recursively expanded use the := operator

-# instead of the = operator.

+# omitted =1 is assumed.

 

 PREDEFINED             = __attribute__(x)="" "RENAME(x)=x ## _TMPL" "DEF(x)=x ## _TMPL" /

                          HAVE_AV_CONFIG_H HAVE_MMX HAVE_MMX2 HAVE_AMD3DNOW /

@@ -1172,29 +849,16 @@

 # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then

 # doxygen's preprocessor will remove all function-like macros that are alone

 # on a line, have an all uppercase name, and do not end with a semicolon. Such

-# function macros are typically used for boiler-plate code, and will confuse

-# the parser if not removed.

+# function macros are typically used for boiler-plate code, and will confuse the

+# parser if not removed.

 

 SKIP_FUNCTION_MACROS   = YES

 

 #---------------------------------------------------------------------------

-# Configuration::additions related to external references

+# Configuration::addtions related to external references

 #---------------------------------------------------------------------------

 

-# The TAGFILES option can be used to specify one or more tagfiles.

-# Optionally an initial location of the external documentation

-# can be added for each tagfile. The format of a tag file without

-# this location is as follows:

-#   TAGFILES = file1 file2 ...

-# Adding location for the tag files is done as follows:

-#   TAGFILES = file1=loc1 "file2 = loc2" ...

-# where "loc1" and "loc2" can be relative or absolute paths or

-# URLs. If a location is present for each tag, the installdox tool

-# does not have to be run to correct the links.

-# Note that each tag file must have a unique name

-# (where the name does NOT include the path)

-# If a tag file is not located in the directory in which doxygen

-# is run, you must also specify the path to the tagfile here.

+# The TAGFILES tag can be used to specify one or more tagfiles.

 

 TAGFILES               =

 

@@ -1225,23 +889,13 @@

 #---------------------------------------------------------------------------

 

 # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will

-# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base

-# or super classes. Setting the tag to NO turns the diagrams off. Note that

-# this option is superseded by the HAVE_DOT option below. This is only a

-# fallback. It is recommended to install and use dot, since it yields more

-# powerful graphs.

+# generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or

+# super classes. Setting the tag to NO turns the diagrams off. Note that this

+# option is superceded by the HAVE_DOT option below. This is only a fallback. It is

+# recommended to install and use dot, since it yield more powerful graphs.

 

 CLASS_DIAGRAMS         = YES

 

-# You can define message sequence charts within doxygen comments using the /msc

-# command. Doxygen will then run the mscgen tool (see

-# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the

-# documentation. The MSCGEN_PATH tag allows you to specify the directory where

-# the mscgen tool resides. If left empty the tool is assumed to be found in the

-# default search path.

-

-MSCGEN_PATH            =

-

 # If set to YES, the inheritance and collaboration graphs will hide

 # inheritance and usage relations if the target is undocumented

 # or is not a class.

@@ -1255,24 +909,6 @@

 

 HAVE_DOT               = NO

 

-# By default doxygen will write a font called FreeSans.ttf to the output

-# directory and reference it in all dot files that doxygen generates. This

-# font does not include all possible unicode characters however, so when you need

-# these (or just want a differently looking font) you can specify the font name

-# using DOT_FONTNAME. You need need to make sure dot is able to find the font,

-# which can be done by putting it in a standard location or by setting the

-# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory

-# containing the font.

-

-DOT_FONTNAME           = FreeSans

-

-# By default doxygen will tell dot to use the output directory to look for the

-# FreeSans.ttf font (which doxygen will put there itself). If you specify a

-# different font using DOT_FONTNAME you can set the path where dot

-# can find it using this tag.

-

-DOT_FONTPATH           =

-

 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen

 # will generate a graph for each documented class showing the direct and

 # indirect inheritance relations. Setting this tag to YES will force the

@@ -1287,17 +923,6 @@

 

 COLLABORATION_GRAPH    = YES

 

-# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen

-# will generate a graph for groups, showing the direct groups dependencies

-

-GROUP_GRAPHS           = YES

-

-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and

-# collaboration diagrams in a style similar to the OMG's Unified Modeling

-# Language.

-

-UML_LOOK               = NO

-

 # If set to YES, the inheritance and collaboration graphs will show the

 # relations between templates and their instances.

 

@@ -1317,34 +942,11 @@

 

 INCLUDED_BY_GRAPH      = YES

 

-# If the CALL_GRAPH and HAVE_DOT options are set to YES then

-# doxygen will generate a call dependency graph for every global function

-# or class method. Note that enabling this option will significantly increase

-# the time of a run. So in most cases it will be better to enable call graphs

-# for selected functions only using the /callgraph command.

-

-CALL_GRAPH             = NO

-

-# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then

-# doxygen will generate a caller dependency graph for every global function

-# or class method. Note that enabling this option will significantly increase

-# the time of a run. So in most cases it will be better to enable caller

-# graphs for selected functions only using the /callergraph command.

-

-CALLER_GRAPH           = NO

-

 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen

 # will graphical hierarchy of all classes instead of a textual one.

 

 GRAPHICAL_HIERARCHY    = YES

 

-# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES

-# then doxygen will show the dependencies a directory has on other directories

-# in a graphical way. The dependency relations are determined by the #include

-# relations between the files in the directories.

-

-DIRECTORY_GRAPH        = YES

-

 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images

 # generated by dot. Possible values are png, jpg, or gif

 # If left blank png will be used.

@@ -1352,7 +954,7 @@

 DOT_IMAGE_FORMAT       = png

 

 # The tag DOT_PATH can be used to specify the path where the dot tool can be

-# found. If left blank, it is assumed the dot tool can be found in the path.

+# found. If left blank, it is assumed the dot tool can be found on the path.

 

 DOT_PATH               =

 

@@ -1362,40 +964,21 @@

 

 DOTFILE_DIRS           =

 

-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of

-# nodes that will be shown in the graph. If the number of nodes in a graph

-# becomes larger than this value, doxygen will truncate the graph, which is

-# visualized by representing a node as a red box. Note that doxygen if the

-# number of direct children of the root node in a graph is already larger than

-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note

-# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.

-

-DOT_GRAPH_MAX_NODES    = 50

-

-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the

-# graphs generated by dot. A depth value of 3 means that only nodes reachable

-# from the root by following a path via at most 3 edges will be shown. Nodes

-# that lay further from the root node will be omitted. Note that setting this

-# option to 1 or 2 may greatly reduce the computation time needed for large

-# code bases. Also note that the size of a graph can be further restricted by

-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.

-

-MAX_DOT_GRAPH_DEPTH    = 0

-

-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent

-# background. This is enabled by default, which results in a transparent

-# background. Warning: Depending on the platform used, enabling this option

-# may lead to badly anti-aliased labels on the edges of a graph (i.e. they

-# become hard to read).

-

-DOT_TRANSPARENT        = YES

-

-# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output

-# files in one run (i.e. multiple -o and -T options on the command line). This

-# makes dot run faster, but since only newer versions of dot (>1.8.10)

-# support this, this feature is disabled by default.

+# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width

+# (in pixels) of the graphs generated by dot. If a graph becomes larger than

+# this value, doxygen will try to truncate the graph, so that it fits within

+# the specified constraint. Beware that most browsers cannot cope with very

+# large images.

+

+MAX_DOT_GRAPH_WIDTH    = 1024

+

+# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height

+# (in pixels) of the graphs generated by dot. If a graph becomes larger than

+# this value, doxygen will try to truncate the graph, so that it fits within

+# the specified constraint. Beware that most browsers cannot cope with very

+# large images.

 

-DOT_MULTI_TARGETS      = NO

+MAX_DOT_GRAPH_HEIGHT   = 1024

 

 # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will

 # generate a legend page explaining the meaning of the various boxes and

@@ -1404,16 +987,51 @@

 GENERATE_LEGEND        = YES

 

 # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will

-# remove the intermediate dot files that are used to generate

+# remove the intermedate dot files that are used to generate

 # the various graphs.

 

 DOT_CLEANUP            = YES

 

 #---------------------------------------------------------------------------

-# Configuration::additions related to the search engine

+# Configuration::addtions related to the search engine

 #---------------------------------------------------------------------------

 

 # The SEARCHENGINE tag specifies whether or not a search engine should be

 # used. If set to NO the values of all tags below this one will be ignored.

 

 SEARCHENGINE           = NO

+

+# The CGI_NAME tag should be the name of the CGI script that

+# starts the search engine (doxysearch) with the correct parameters.

+# A script with this name will be generated by doxygen.

+

+CGI_NAME               = search.cgi

+

+# The CGI_URL tag should be the absolute URL to the directory where the

+# cgi binaries are located. See the documentation of your http daemon for

+# details.

+

+CGI_URL                =

+

+# The DOC_URL tag should be the absolute URL to the directory where the

+# documentation is located. If left blank the absolute path to the

+# documentation, with file:// prepended to it, will be used.

+

+DOC_URL                =

+

+# The DOC_ABSPATH tag should be the absolute path to the directory where the

+# documentation is located. If left blank the directory on the local machine

+# will be used.

+

+DOC_ABSPATH            =

+

+# The BIN_ABSPATH tag must point to the directory where the doxysearch binary

+# is installed.

+

+BIN_ABSPATH            = /usr/local/bin/

+

+# The EXT_DOC_PATHS tag can be used to specify one or more paths to

+# documentation generated for other projects. This allows doxysearch to search

+# the documentation for these projects as well.

+

+EXT_DOC_PATHS          =

Binary files ffmpeg/ffmpeg and ffmpeg-0.6.1/ffmpeg differ

diff -u ffmpeg/ffmpeg.c ffmpeg-0.6.1/ffmpeg.c

--- ffmpeg/ffmpeg.c 2011-01-08 09:07:51.374711421 -0800

+++ ffmpeg-0.6.1/ffmpeg.c 2010-05-31 23:29:50.000000000 -0700

@@ -36,23 +36,13 @@

 #include "libswscale/swscale.h"

 #include "libavcodec/opt.h"

 #include "libavcodec/audioconvert.h"

-#include "libavcore/audioconvert.h"

-#include "libavcore/parseutils.h"

-#include "libavcore/samplefmt.h"

-#include "libavutil/colorspace.h"

+#include "libavcodec/colorspace.h"

 #include "libavutil/fifo.h"

-#include "libavutil/intreadwrite.h"

 #include "libavutil/pixdesc.h"

 #include "libavutil/avstring.h"

 #include "libavutil/libm.h"

 #include "libavformat/os_support.h"

 

-#if CONFIG_AVFILTER

-# include "libavfilter/avfilter.h"

-# include "libavfilter/avfiltergraph.h"

-# include "libavfilter/vsrc_buffer.h"

-#endif

-

 #if HAVE_SYS_RESOURCE_H

 #include <sys/types.h>

 #include <sys/time.h>

@@ -81,7 +71,8 @@

 

 #include "cmdutils.h"

 

-#include "libavutil/avassert.h"

+#undef NDEBUG

+#include <assert.h>

 

 const char program_name[] = "FFmpeg";

 const int program_birth_year = 2000;

@@ -94,63 +85,49 @@

     int sync_stream_index;

 } AVStreamMap;

 

-/**

- * select an input file for an output file

- */

+/** select an input file for an output file */

 typedef struct AVMetaDataMap {

-    int  file;      //< file index

-    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram

-    int  index;     //< stream/chapter/program number

-} AVMetaDataMap;

-

-typedef struct AVChapterMap {

-    int in_file;

     int out_file;

-} AVChapterMap;

+    int in_file;

+} AVMetaDataMap;

 

 static const OptionDef options[];

 

 #define MAX_FILES 100

-#if !FF_API_MAX_STREAMS

-#define MAX_STREAMS 1024    /* arbitrary sanity check value */

-#endif

 

 static const char *last_asked_format = NULL;

 static AVFormatContext *input_files[MAX_FILES];

 static int64_t input_files_ts_offset[MAX_FILES];

-static double *input_files_ts_scale[MAX_FILES] = {NULL};

-static AVCodec **input_codecs = NULL;

+static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];

+static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];

 static int nb_input_files = 0;

-static int nb_input_codecs = 0;

-static int nb_input_files_ts_scale[MAX_FILES] = {0};

+static int nb_icodecs;

 

 static AVFormatContext *output_files[MAX_FILES];

-static AVCodec **output_codecs = NULL;

+static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];

 static int nb_output_files = 0;

-static int nb_output_codecs = 0;

+static int nb_ocodecs;

 

-static AVStreamMap *stream_maps = NULL;

+static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];

 static int nb_stream_maps;

 

-/* first item specifies output metadata, second is input */

-static AVMetaDataMap (*meta_data_maps)[2] = NULL;

+static AVMetaDataMap meta_data_maps[MAX_FILES];

 static int nb_meta_data_maps;

-static int metadata_global_autocopy   = 1;

-static int metadata_streams_autocopy  = 1;

-static int metadata_chapters_autocopy = 1;

-

-static AVChapterMap *chapter_maps = NULL;

-static int nb_chapter_maps;

-

-/* indexed by output file stream index */

-static int *streamid_map = NULL;

-static int nb_streamid_map = 0;

 

 static int frame_width  = 0;

 static int frame_height = 0;

 static float frame_aspect_ratio = 0;

 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;

-static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;

+static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;

+static int frame_padtop  = 0;

+static int frame_padbottom = 0;

+static int frame_padleft  = 0;

+static int frame_padright = 0;

+static int padcolor[3] = {16,128,128}; /* default to black */

+static int frame_topBand  = 0;

+static int frame_bottomBand = 0;

+static int frame_leftBand  = 0;

+static int frame_rightBand = 0;

 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};

 static AVRational frame_rate;

 static float video_qscale = 0;

@@ -160,7 +137,7 @@

 static int video_disable = 0;

 static int video_discard = 0;

 static char *video_codec_name = NULL;

-static unsigned int video_codec_tag = 0;

+static int video_codec_tag = 0;

 static char *video_language = NULL;

 static int same_quality = 0;

 static int do_deinterlace = 0;

@@ -170,10 +147,6 @@

 static int loop_input = 0;

 static int loop_output = AVFMT_NOOUTPUTLOOP;

 static int qp_hist = 0;

-#if CONFIG_AVFILTER

-static char *vfilters = NULL;

-AVFilterGraph *graph = NULL;

-#endif

 

 static int intra_only = 0;

 static int audio_sample_rate = 44100;

@@ -183,23 +156,24 @@

 static int audio_disable = 0;

 static int audio_channels = 1;

 static char  *audio_codec_name = NULL;

-static unsigned int audio_codec_tag = 0;

+static int audio_codec_tag = 0;

 static char *audio_language = NULL;

 

 static int subtitle_disable = 0;

 static char *subtitle_codec_name = NULL;

 static char *subtitle_language = NULL;

-static unsigned int subtitle_codec_tag = 0;

+static int subtitle_codec_tag = 0;

 

 static float mux_preload= 0.5;

 static float mux_max_delay= 0.7;

 

 static int64_t recording_time = INT64_MAX;

 static int64_t start_time = 0;

-static int64_t recording_timestamp = 0;

+static int64_t rec_timestamp = 0;

 static int64_t input_ts_offset = 0;

 static int file_overwrite = 0;

-static AVMetadata *metadata;

+static int metadata_count;

+static AVMetadataTag *metadata;

 static int do_benchmark = 0;

 static int do_hex_dump = 0;

 static int do_pkt_dump = 0;

@@ -240,8 +214,8 @@

 static int input_sync;

 static uint64_t limit_filesize = 0;

 static int force_fps = 0;

-static char *forced_key_frames = NULL;

 

+static int pgmyuv_compatibility_hack=0;

 static float dts_delta_threshold = 10;

 

 static unsigned int sws_flags = SWS_BICUBIC;

@@ -257,6 +231,7 @@

 static AVBitStreamFilterContext *video_bitstream_filters=NULL;

 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;

 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;

+static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];

 

 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"

 

@@ -274,7 +249,6 @@

     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */

     struct AVInputStream *sync_ist; /* input stream to sync against */

     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number

-    AVBitStreamFilterContext *bitstream_filters;

     /* video only */

     int video_resample;

     AVFrame pict_tmp;      /* temporary image for resampling */

@@ -287,26 +261,35 @@

     int original_height;

     int original_width;

 

-    /* forced key frames */

-    int64_t *forced_kf_pts;

-    int forced_kf_count;

-    int forced_kf_index;

+    /* cropping area sizes */

+    int video_crop;

+    int topBand;

+    int bottomBand;

+    int leftBand;

+    int rightBand;

+

+    /* cropping area of first frame */

+    int original_topBand;

+    int original_bottomBand;

+    int original_leftBand;

+    int original_rightBand;

+

+    /* padding area sizes */

+    int video_pad;

+    int padtop;

+    int padbottom;

+    int padleft;

+    int padright;

 

     /* audio only */

     int audio_resample;

     ReSampleContext *resample; /* for audio resampling */

-    int resample_sample_fmt;

-    int resample_channels;

-    int resample_sample_rate;

     int reformat_pair;

     AVAudioConvert *reformat_ctx;

     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */

     FILE *logfile;

 } AVOutputStream;

 

-static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };

-static int nb_output_streams_for_file[MAX_FILES] = { 0 };

-

 typedef struct AVInputStream {

     int file_index;

     int index;

@@ -319,17 +302,9 @@

     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts

                                 is not defined */

     int64_t       pts;       /* current pts */

-    PtsCorrectionContext pts_ctx;

     int is_start;            /* is 1 at the start and after a discontinuity */

     int showed_multi_packet_warning;

     int is_past_recording_time;

-#if CONFIG_AVFILTER

-    AVFilterContext *output_video_filter;

-    AVFilterContext *input_video_filter;

-    AVFrame *filter_frame;

-    int has_filter_frame;

-    AVFilterBufferRef *picref;

-#endif

 } AVInputStream;

 

 typedef struct AVInputFile {

@@ -345,83 +320,8 @@

 static struct termios oldtty;

 #endif

 

-#if CONFIG_AVFILTER

-

-static int configure_filters(AVInputStream *ist, AVOutputStream *ost)

-{

-    AVFilterContext *last_filter, *filter;

-    /** filter graph containing all filters including input & output */

-    AVCodecContext *codec = ost->st->codec;

-    AVCodecContext *icodec = ist->st->codec;

-    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };

-    char args[255];

-    int ret;

-

-    graph = avfilter_graph_alloc();

-

-    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,

-             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);

-    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),

-                                       "src", args, NULL, graph);

-    if (ret < 0)

-        return ret;

-    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,

-                                       "out", NULL, &ffsink_ctx, graph);

-    if (ret < 0)

-        return ret;

-    last_filter = ist->input_video_filter;

-

-    if (codec->width  != icodec->width || codec->height != icodec->height) {

-        snprintf(args, 255, "%d:%d:flags=0x%X",

-                 codec->width,

-                 codec->height,

-                 (int)av_get_int(sws_opts, "sws_flags", NULL));

-        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),

-                                                NULL, args, NULL, graph)) < 0)

-            return ret;

-        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)

-            return ret;

-        last_filter = filter;

-    }

-

-    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));

-    graph->scale_sws_opts = av_strdup(args);

-

-    if (vfilters) {

-        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));

-        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));

-

-        outputs->name    = av_strdup("in");

-        outputs->filter_ctx = last_filter;

-        outputs->pad_idx = 0;

-        outputs->next    = NULL;

-

-        inputs->name    = av_strdup("out");

-        inputs->filter_ctx = ist->output_video_filter;

-        inputs->pad_idx = 0;

-        inputs->next    = NULL;

-

-        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)

-            return ret;

-        av_freep(&vfilters);

-    } else {

-        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)

-            return ret;

-    }

-

-    if ((ret = avfilter_graph_config(graph, NULL)) < 0)

-        return ret;

-

-    codec->width  = ist->output_video_filter->inputs[0]->w;

-    codec->height = ist->output_video_filter->inputs[0]->h;

-

-    return 0;

-}

-#endif /* CONFIG_AVFILTER */

-

 static void term_exit(void)

 {

-    av_log(NULL, AV_LOG_QUIET, "");

 #if HAVE_TERMIOS_H

     tcsetattr (0, TCSANOW, &oldtty);

 #endif

@@ -463,6 +363,10 @@

 #ifdef SIGXCPU

     signal(SIGXCPU, sigterm_handler);

 #endif

+

+#if CONFIG_BEOS_NETSERVER

+    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);

+#endif

 }

 

 /* read a key without blocking */

@@ -471,6 +375,7 @@

 #if HAVE_TERMIOS_H

     int n = 1;

     unsigned char ch;

+#if !CONFIG_BEOS_NETSERVER

     struct timeval tv;

     fd_set rfds;

 

@@ -479,6 +384,7 @@

     tv.tv_sec = 0;

     tv.tv_usec = 0;

     n = select(1, &rfds, NULL, NULL, &tv);

+#endif

     if (n > 0) {

         n = read(0, &ch, 1);

         if (n == 1)

@@ -498,7 +404,7 @@

     return q_pressed || (q_pressed = read_key() == 'q');

 }

 

-static int ffmpeg_exit(int ret)

+static int av_exit(int ret)

 {

     int i;

 

@@ -512,7 +418,6 @@

         for(j=0;j<s->nb_streams;j++) {

             av_metadata_free(&s->streams[j]->metadata);

             av_free(s->streams[j]->codec);

-            av_free(s->streams[j]->info);

             av_free(s->streams[j]);

         }

         for(j=0;j<s->nb_programs;j++) {

@@ -523,12 +428,9 @@

         }

         av_metadata_free(&s->metadata);

         av_free(s);

-        av_free(output_streams_for_file[i]);

     }

-    for(i=0;i<nb_input_files;i++) {

+    for(i=0;i<nb_input_files;i++)

         av_close_input_file(input_files[i]);

-        av_free(input_files_ts_scale[i]);

-    }

 

     av_free(intra_matrix);

     av_free(inter_matrix);

@@ -538,11 +440,6 @@

     av_free(vstats_filename);

 

     av_free(opt_names);

-    av_free(streamid_map);

-    av_free(input_codecs);

-    av_free(output_codecs);

-    av_free(stream_maps);

-    av_free(meta_data_maps);

 

     av_free(video_codec_name);

     av_free(audio_codec_name);

@@ -550,16 +447,20 @@

 

     av_free(video_standard);

 

-    uninit_opts();

+#if CONFIG_POWERPC_PERF

+    void powerpc_display_perf_report(void);

+    powerpc_display_perf_report();

+#endif /* CONFIG_POWERPC_PERF */

+

+    for (i=0;i<AVMEDIA_TYPE_NB;i++)

+        av_free(avcodec_opts[i]);

+    av_free(avformat_opts);

+    av_free(sws_opts);

     av_free(audio_buf);

     av_free(audio_out);

     allocated_audio_buf_size= allocated_audio_out_size= 0;

     av_free(samples);

 

-#if CONFIG_AVFILTER

-    avfilter_uninit();

-#endif

-

     if (received_sigterm) {

         fprintf(stderr,

             "Received signal %d: terminating./n",

@@ -571,30 +472,10 @@

     return ret;

 }

 

-/* similar to ff_dynarray_add() and av_fast_realloc() */

-static void *grow_array(void *array, int elem_size, int *size, int new_size)

-{

-    if (new_size >= INT_MAX / elem_size) {

-        fprintf(stderr, "Array too big./n");

-        ffmpeg_exit(1);

-    }

-    if (*size < new_size) {

-        uint8_t *tmp = av_realloc(array, new_size*elem_size);

-        if (!tmp) {

-            fprintf(stderr, "Could not alloc buffer./n");

-            ffmpeg_exit(1);

-        }

-        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);

-        *size = new_size;

-        return tmp;

-    }

-    return array;

-}

-

 static void choose_sample_fmt(AVStream *st, AVCodec *codec)

 {

     if(codec && codec->sample_fmts){

-        const enum AVSampleFormat *p= codec->sample_fmts;

+        const enum SampleFormat *p= codec->sample_fmts;

         for(; *p!=-1; p++){

             if(*p == st->codec->sample_fmt)

                 break;

@@ -608,7 +489,7 @@

 {

     if(codec && codec->supported_samplerates){

         const int *p= codec->supported_samplerates;

-        int best=0;

+        int best;

         int best_dist=INT_MAX;

         for(; *p; p++){

             int dist= abs(st->codec->sample_rate - *p);

@@ -628,43 +509,19 @@

 {

     if(codec && codec->pix_fmts){

         const enum PixelFormat *p= codec->pix_fmts;

-        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){

-            if(st->codec->codec_id==CODEC_ID_MJPEG){

-                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};

-            }else if(st->codec->codec_id==CODEC_ID_LJPEG){

-                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};

-            }

-        }

         for(; *p!=-1; p++){

             if(*p == st->codec->pix_fmt)

                 break;

         }

-        if(*p == -1)

+        if(*p == -1

+           && !(   st->codec->codec_id==CODEC_ID_MJPEG

+                && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL

+                && (   st->codec->pix_fmt == PIX_FMT_YUV420P

+                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))

             st->codec->pix_fmt = codec->pix_fmts[0];

     }

 }

 

-static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)

-{

-    int idx = oc->nb_streams - 1;

-    AVOutputStream *ost;

-

-    output_streams_for_file[file_idx] =

-        grow_array(output_streams_for_file[file_idx],

-                   sizeof(*output_streams_for_file[file_idx]),

-                   &nb_output_streams_for_file[file_idx],

-                   oc->nb_streams);

-    ost = output_streams_for_file[file_idx][idx] =

-        av_mallocz(sizeof(AVOutputStream));

-    if (!ost) {

-        fprintf(stderr, "Could not alloc output stream/n");

-        ffmpeg_exit(1);

-    }

-    ost->file_index = file_idx;

-    ost->index = idx;

-    return ost;

-}

-

 static int read_ffserver_streams(AVFormatContext *s, const char *filename)

 {

     int i, err;

@@ -675,20 +532,18 @@

     if (err < 0)

         return err;

     /* copy stream format */

-    s->nb_streams = 0;

+    s->nb_streams = ic->nb_streams;

     for(i=0;i<ic->nb_streams;i++) {

         AVStream *st;

         AVCodec *codec;

 

-        s->nb_streams++;

-

         // FIXME: a more elegant solution is needed

         st = av_mallocz(sizeof(AVStream));

         memcpy(st, ic->streams[i], sizeof(AVStream));

         st->codec = avcodec_alloc_context();

         if (!st->codec) {

             print_error(filename, AVERROR(ENOMEM));

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         avcodec_copy_context(st->codec, ic->streams[i]->codec);

         s->streams[i] = st;

@@ -713,8 +568,6 @@

 

         if(st->codec->flags & CODEC_FLAG_BITEXACT)

             nopts = 1;

-

-        new_output_stream(s, nb_output_files);

     }

 

     if (!nopts)

@@ -749,7 +602,7 @@

                     avctx->codec ? avctx->codec->name : "copy");

             print_error("", a);

             if (exit_on_error)

-                ffmpeg_exit(1);

+                av_exit(1);

         }

         *pkt= new_pkt;

 

@@ -759,7 +612,7 @@

     ret= av_interleaved_write_frame(s, pkt);

     if(ret < 0){

         print_error("av_interleaved_write_frame()", ret);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 }

 

@@ -774,18 +627,17 @@

     int64_t audio_out_size, audio_buf_size;

     int64_t allocated_for_size= size;

 

-    int size_out, frame_bytes, ret, resample_changed;

+    int size_out, frame_bytes, ret;

     AVCodecContext *enc= ost->st->codec;

     AVCodecContext *dec= ist->st->codec;

-    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;

-    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;

+    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;

+    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;

     const int coded_bps = av_get_bits_per_sample(enc->codec->id);

 

 need_realloc:

     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);

     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;

     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API

-    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);

     audio_buf_size*= osize*enc->channels;

 

     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);

@@ -795,57 +647,35 @@

 

     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){

         fprintf(stderr, "Buffer sizes too large/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);

     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);

     if (!audio_buf || !audio_out){

         fprintf(stderr, "Out of memory in do_audio_out/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     if (enc->channels != dec->channels)

         ost->audio_resample = 1;

 

-    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||

-                       ost->resample_channels    != dec->channels   ||

-                       ost->resample_sample_rate != dec->sample_rate;

-

-    if ((ost->audio_resample && !ost->resample) || resample_changed) {

-        if (resample_changed) {

-            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d/n",

-                   ist->file_index, ist->index,

-                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,

-                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);

-            ost->resample_sample_fmt  = dec->sample_fmt;

-            ost->resample_channels    = dec->channels;

-            ost->resample_sample_rate = dec->sample_rate;

-            if (ost->resample)

-                audio_resample_close(ost->resample);

-        }

-        if (ost->resample_sample_fmt  == enc->sample_fmt &&

-            ost->resample_channels    == enc->channels   &&

-            ost->resample_sample_rate == enc->sample_rate) {

-            ost->resample = NULL;

-            ost->audio_resample = 0;

-        } else {

-            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)

-                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling/n");

-            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,

-                                                   enc->sample_rate, dec->sample_rate,

-                                                   enc->sample_fmt,  dec->sample_fmt,

-                                                   16, 10, 0, 0.8);

-            if (!ost->resample) {

-                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz/n",

-                        dec->channels, dec->sample_rate,

-                        enc->channels, enc->sample_rate);

-                ffmpeg_exit(1);

-            }

+    if (ost->audio_resample && !ost->resample) {

+        if (dec->sample_fmt != SAMPLE_FMT_S16)

+            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling/n");

+        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,

+                                               enc->sample_rate, dec->sample_rate,

+                                               enc->sample_fmt,  dec->sample_fmt,

+                                               16, 10, 0, 0.8);

+        if (!ost->resample) {

+            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz/n",

+                    dec->channels, dec->sample_rate,

+                    enc->channels, enc->sample_rate);

+            av_exit(1);

         }

     }

 

-#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))

+#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))

     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&

         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {

         if (ost->reformat_ctx)

@@ -854,18 +684,18 @@

                                                    dec->sample_fmt, 1, NULL, 0);

         if (!ost->reformat_ctx) {

             fprintf(stderr, "Cannot convert %s sample format to %s sample format/n",

-                av_get_sample_fmt_name(dec->sample_fmt),

-                av_get_sample_fmt_name(enc->sample_fmt));

-            ffmpeg_exit(1);

+                avcodec_get_sample_fmt_name(dec->sample_fmt),

+                avcodec_get_sample_fmt_name(enc->sample_fmt));

+            av_exit(1);

         }

         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);

     }

 

     if(audio_sync_method){

         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts

-                - av_fifo_size(ost->fifo)/(enc->channels * 2);

-        double idelta= delta*dec->sample_rate / enc->sample_rate;

-        int byte_delta= ((int)idelta)*2*dec->channels;

+                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);

+        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;

+        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;

 

         //FIXME resample delay

         if(fabs(delta) > 50){

@@ -898,7 +728,7 @@

                 }

             }else if(audio_sync_method>1){

                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);

-                av_assert0(ost->audio_resample);

+                assert(ost->audio_resample);

                 if(verbose > 2)

                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d/n", delta, comp, enc->sample_rate);

 //                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d/n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));

@@ -907,13 +737,13 @@

         }

     }else

         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)

-                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong

+                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong

 

     if (ost->audio_resample) {

         buftmp = audio_buf;

         size_out = audio_resample(ost->resample,

                                   (short *)buftmp, (short *)buf,

-                                  size / (dec->channels * isize));

+                                  size / (ist->st->codec->channels * isize));

         size_out = size_out * enc->channels * osize;

     } else {

         buftmp = buf;

@@ -929,7 +759,7 @@

         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

             printf("av_audio_convert() failed/n");

             if (exit_on_error)

-                ffmpeg_exit(1);

+                av_exit(1);

             return;

         }

         buftmp = audio_buf;

@@ -941,7 +771,7 @@

         /* output resampled raw samples */

         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {

             fprintf(stderr, "av_fifo_realloc2() failed/n");

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);

 

@@ -959,7 +789,7 @@

                                        (short *)audio_buf);

             if (ret < 0) {

                 fprintf(stderr, "Audio encoding failed/n");

-                ffmpeg_exit(1);

+                av_exit(1);

             }

             audio_size += ret;

             pkt.stream_index= ost->index;

@@ -968,7 +798,7 @@

             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

             pkt.flags |= AV_PKT_FLAG_KEY;

-            write_frame(s, &pkt, enc, ost->bitstream_filters);

+            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

 

             ost->sync_opts += enc->frame_size;

         }

@@ -986,7 +816,7 @@

 

         if(size_out > audio_out_size){

             fprintf(stderr, "Internal error, buffer size too small/n");

-            ffmpeg_exit(1);

+            av_exit(1);

         }

 

         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

@@ -994,7 +824,7 @@

                                    (short *)buftmp);

         if (ret < 0) {

             fprintf(stderr, "Audio encoding failed/n");

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         audio_size += ret;

         pkt.stream_index= ost->index;

@@ -1003,7 +833,7 @@

         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

         pkt.flags |= AV_PKT_FLAG_KEY;

-        write_frame(s, &pkt, enc, ost->bitstream_filters);

+        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

     }

 }

 

@@ -1064,7 +894,7 @@

     if (pts == AV_NOPTS_VALUE) {

         fprintf(stderr, "Subtitle packets must have a pts/n");

         if (exit_on_error)

-            ffmpeg_exit(1);

+            av_exit(1);

         return;

     }

 

@@ -1092,7 +922,7 @@

                                                     subtitle_out_max_size, sub);

         if (subtitle_out_size < 0) {

             fprintf(stderr, "Subtitle encoding failed/n");

-            ffmpeg_exit(1);

+            av_exit(1);

         }

 

         av_init_packet(&pkt);

@@ -1108,7 +938,7 @@

             else

                 pkt.pts += 90 * sub->end_display_time;

         }

-        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

+        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

     }

 }

 

@@ -1122,10 +952,15 @@

                          int *frame_size)

 {

     int nb_frames, i, ret;

+    int64_t topBand, bottomBand, leftBand, rightBand;

     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;

+    AVFrame picture_crop_temp, picture_pad_temp;

     AVCodecContext *enc, *dec;

     double sync_ipts;

 

+    avcodec_get_frame_defaults(&picture_crop_temp);

+    avcodec_get_frame_defaults(&picture_pad_temp);

+

     enc = ost->st->codec;

     dec = ist->st->codec;

 

@@ -1145,7 +980,7 @@

             if(vdelta<=-0.6){

                 nb_frames=0;

             }else if(vdelta>0.6)

-                ost->sync_opts= lrintf(sync_ipts);

+            ost->sync_opts= lrintf(sync_ipts);

         }else if (vdelta > 1.1)

             nb_frames = lrintf(vdelta);

 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d/n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);

@@ -1165,48 +1000,96 @@

     if (nb_frames <= 0)

         return;

 

-    formatted_picture = in_picture;

+    if (ost->video_crop) {

+        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {

+            fprintf(stderr, "error cropping picture/n");

+            if (exit_on_error)

+                av_exit(1);

+            return;

+        }

+        formatted_picture = &picture_crop_temp;

+    } else {

+        formatted_picture = in_picture;

+    }

+

     final_picture = formatted_picture;

     padding_src = formatted_picture;

     resampling_dst = &ost->pict_tmp;

+    if (ost->video_pad) {

+        final_picture = &ost->pict_tmp;

+        if (ost->video_resample) {

+            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {

+                fprintf(stderr, "error padding picture/n");

+                if (exit_on_error)

+                    av_exit(1);

+                return;

+            }

+            resampling_dst = &picture_pad_temp;

+        }

+    }

 

-    if (   ost->resample_height != ist->st->codec->height

-        || ost->resample_width  != ist->st->codec->width

+    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))

+        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))

         || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {

 

         fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s/n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));

         if(!ost->video_resample)

-            ffmpeg_exit(1);

+            av_exit(1);

     }

 

-#if !CONFIG_AVFILTER

     if (ost->video_resample) {

         padding_src = NULL;

         final_picture = &ost->pict_tmp;

-        if(  ost->resample_height != ist->st->codec->height

-          || ost->resample_width  != ist->st->codec->width

+        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))

+          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))

           || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {

 

+            /* keep bands proportional to the frame size */

+            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;

+            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;

+            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;

+            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;

+

+            /* sanity check to ensure no bad band sizes sneak in */

+            assert(topBand    <= INT_MAX && topBand    >= 0);

+            assert(bottomBand <= INT_MAX && bottomBand >= 0);

+            assert(leftBand   <= INT_MAX && leftBand   >= 0);

+            assert(rightBand  <= INT_MAX && rightBand  >= 0);

+

+            ost->topBand    = topBand;

+            ost->bottomBand = bottomBand;

+            ost->leftBand   = leftBand;

+            ost->rightBand  = rightBand;

+

+            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);

+            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);

+            ost->resample_pix_fmt= ist->st->codec->pix_fmt;

+

             /* initialize a new scaler context */

             sws_freeContext(ost->img_resample_ctx);

             sws_flags = av_get_int(sws_opts, "sws_flags", NULL);

             ost->img_resample_ctx = sws_getContext(

-                ist->st->codec->width,

-                ist->st->codec->height,

+                ist->st->codec->width  - (ost->leftBand + ost->rightBand),

+                ist->st->codec->height - (ost->topBand  + ost->bottomBand),

                 ist->st->codec->pix_fmt,

-                ost->st->codec->width,

-                ost->st->codec->height,

+                ost->st->codec->width  - (ost->padleft  + ost->padright),

+                ost->st->codec->height - (ost->padtop   + ost->padbottom),

                 ost->st->codec->pix_fmt,

                 sws_flags, NULL, NULL, NULL);

             if (ost->img_resample_ctx == NULL) {

                 fprintf(stderr, "Cannot get resampling context/n");

-                ffmpeg_exit(1);

+                av_exit(1);

             }

         }

         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,

               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);

     }

-#endif

+

+    if (ost->video_pad) {

+        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,

+                enc->height, enc->width, enc->pix_fmt,

+                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);

+    }

 

     /* duplicates frame if needed */

     for(i=0;i<nb_frames;i++) {

@@ -1225,7 +1108,7 @@

             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);

             pkt.flags |= AV_PKT_FLAG_KEY;

 

-            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

+            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

             enc->coded_frame = old_frame;

         } else {

             AVFrame big_picture;

@@ -1243,24 +1126,22 @@

 

             /* handles sameq here. This is not correct because it may

                not be a global option */

-            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;

+            if (same_quality) {

+                big_picture.quality = ist->st->quality;

+            }else

+                big_picture.quality = ost->st->quality;

             if(!me_threshold)

                 big_picture.pict_type = 0;

 //            big_picture.pts = AV_NOPTS_VALUE;

             big_picture.pts= ost->sync_opts;

 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);

 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder/n", ost->sync_opts);

-            if (ost->forced_kf_index < ost->forced_kf_count &&

-                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {

-                big_picture.pict_type = FF_I_TYPE;

-                ost->forced_kf_index++;

-            }

             ret = avcodec_encode_video(enc,

                                        bit_buffer, bit_buffer_size,

                                        &big_picture);

             if (ret < 0) {

                 fprintf(stderr, "Video encoding failed/n");

-                ffmpeg_exit(1);

+                av_exit(1);

             }

 

             if(ret>0){

@@ -1274,7 +1155,7 @@

 

                 if(enc->coded_frame->key_frame)

                     pkt.flags |= AV_PKT_FLAG_KEY;

-                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

+                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

                 *frame_size = ret;

                 video_size += ret;

                 //fprintf(stderr,"/nFrame: %3d size: %5d type: %d",

@@ -1306,7 +1187,7 @@

         vstats_file = fopen(vstats_filename, "w");

         if (!vstats_file) {

             perror("fopen");

-            ffmpeg_exit(1);

+            av_exit(1);

         }

     }

 

@@ -1467,13 +1348,9 @@

     void *buffer_to_free;

     static unsigned int samples_size= 0;

     AVSubtitle subtitle, *subtitle_to_free;

-    int64_t pkt_pts = AV_NOPTS_VALUE;

-#if CONFIG_AVFILTER

-    int frame_available;

-#endif

-

+    int got_subtitle;

     AVPacket avpkt;

-    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;

+    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;

 

     if(ist->next_pts == AV_NOPTS_VALUE)

         ist->next_pts= ist->pts;

@@ -1490,8 +1367,6 @@

 

     if(pkt->dts != AV_NOPTS_VALUE)

         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);

-    if(pkt->pts != AV_NOPTS_VALUE)

-        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);

 

     //while we have more to decode or while the decoder did output something on EOF

     while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {

@@ -1544,8 +1419,6 @@

                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;

                     /* XXX: allocate picture correctly */

                     avcodec_get_frame_defaults(&picture);

-                    ist->st->codec->reordered_opaque = pkt_pts;

-                    pkt_pts = AV_NOPTS_VALUE;

 

                     ret = avcodec_decode_video2(ist->st->codec,

                                                 &picture, &got_picture, &avpkt);

@@ -1556,7 +1429,6 @@

                         /* no picture yet */

                         goto discard_packet;

                     }

-                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);

                     if (ist->st->codec->time_base.num != 0) {

                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;

                         ist->next_pts += ((int64_t)AV_TIME_BASE *

@@ -1567,10 +1439,10 @@

                     break;

             case AVMEDIA_TYPE_SUBTITLE:

                 ret = avcodec_decode_subtitle2(ist->st->codec,

-                                               &subtitle, &got_picture, &avpkt);

+                                               &subtitle, &got_subtitle, &avpkt);

                 if (ret < 0)

                     goto fail_decode;

-                if (!got_picture) {

+                if (!got_subtitle) {

                     goto discard_packet;

                 }

                 subtitle_to_free = &subtitle;

@@ -1604,15 +1476,6 @@

                                     &buffer_to_free);

         }

 

-#if CONFIG_AVFILTER

-        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {

-            // add it to be filtered

-            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,

-                                     ist->pts,

-                                     ist->st->codec->sample_aspect_ratio);

-        }

-#endif

-

         // preprocess audio (volume)

         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {

             if (audio_volume != 256) {

@@ -1634,21 +1497,10 @@

             if (pts > now)

                 usleep(pts - now);

         }

-#if CONFIG_AVFILTER

-        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||

-            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);

-#endif

+

         /* if output time reached then transcode raw format,

            encode packets and output them */

         if (start_time == 0 || ist->pts >= start_time)

-#if CONFIG_AVFILTER

-        while (frame_available) {

-            AVRational ist_pts_tb;

-            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)

-                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);

-            if (ist->picref)

-                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);

-#endif

             for(i=0;i<nb_ostreams;i++) {

                 int frame_size;

 

@@ -1660,16 +1512,12 @@

                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;

 

                     if (ost->encoding_needed) {

-                        av_assert0(ist->decoding_needed);

+                        assert(ist->decoding_needed);

                         switch(ost->st->codec->codec_type) {

                         case AVMEDIA_TYPE_AUDIO:

                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);

                             break;

                         case AVMEDIA_TYPE_VIDEO:

-#if CONFIG_AVFILTER

-                            if (ist->picref->video)

-                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;

-#endif

                             do_video_out(os, ost, ist, &picture, &frame_size);

                             if (vstats_filename && frame_size)

                                 do_video_stats(os, ost, frame_size);

@@ -1732,25 +1580,25 @@

                             opkt.size = data_size;

                         }

 

-                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);

+                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);

                         ost->st->codec->frame_number++;

                         ost->frame_number++;

                         av_free_packet(&opkt);

                     }

                 }

             }

-

-#if CONFIG_AVFILTER

-            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&

-                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);

-            if(ist->picref)

-                avfilter_unref_buffer(ist->picref);

-        }

-#endif

         av_free(buffer_to_free);

         /* XXX: allocate the subtitles in the codec ? */

         if (subtitle_to_free) {

-            avsubtitle_free(subtitle_to_free);

+            if (subtitle_to_free->rects != NULL) {

+                for (i = 0; i < subtitle_to_free->num_rects; i++) {

+                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);

+                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);

+                    av_freep(&subtitle_to_free->rects[i]);

+                }

+                av_freep(&subtitle_to_free->rects);

+            }

+            subtitle_to_free->num_rects = 0;

             subtitle_to_free = NULL;

         }

     }

@@ -1782,20 +1630,20 @@

                             ret = 0;

                             /* encode any samples remaining in fifo */

                             if (fifo_bytes > 0) {

-                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;

+                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;

                                 int fs_tmp = enc->frame_size;

 

-                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);

+                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);

                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {

                                     enc->frame_size = fifo_bytes / (osize * enc->channels);

                                 } else { /* pad */

                                     int frame_bytes = enc->frame_size*osize*enc->channels;

-                                    if (allocated_audio_buf_size < frame_bytes)

-                                        ffmpeg_exit(1);

-                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);

+                                    if (samples_size < frame_bytes)

+                                        av_exit(1);

+                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);

                                 }

 

-                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);

+                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);

                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,

                                                           ost->st->time_base.num, enc->sample_rate);

                                 enc->frame_size = fs_tmp;

@@ -1805,7 +1653,7 @@

                             }

                             if (ret < 0) {

                                 fprintf(stderr, "Audio encoding failed/n");

-                                ffmpeg_exit(1);

+                                av_exit(1);

                             }

                             audio_size += ret;

                             pkt.flags |= AV_PKT_FLAG_KEY;

@@ -1814,7 +1662,7 @@

                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);

                             if (ret < 0) {

                                 fprintf(stderr, "Video encoding failed/n");

-                                ffmpeg_exit(1);

+                                av_exit(1);

                             }

                             video_size += ret;

                             if(enc->coded_frame && enc->coded_frame->key_frame)

@@ -1833,7 +1681,7 @@

                         pkt.size= ret;

                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

-                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);

+                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

                     }

                 }

             }

@@ -1883,9 +1731,8 @@

         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);

         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);

 

-        if (metadata_chapters_autocopy)

-            while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))

-                av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);

+        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))

+            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);

 

         os->nb_chapters++;

         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);

@@ -1896,37 +1743,14 @@

     return 0;

 }

 

-static void parse_forced_key_frames(char *kf, AVOutputStream *ost,

-                                    AVCodecContext *avctx)

-{

-    char *p;

-    int n = 1, i;

-    int64_t t;

-

-    for (p = kf; *p; p++)

-        if (*p == ',')

-            n++;

-    ost->forced_kf_count = n;

-    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);

-    if (!ost->forced_kf_pts) {

-        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array./n");

-        ffmpeg_exit(1);

-    }

-    for (i = 0; i < n; i++) {

-        p = i ? strchr(p, ',') + 1 : kf;

-        t = parse_time_or_die("force_key_frames", p, 1);

-        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);

-    }

-}

-

 /*

  * The following code is the main loop of the file converter

  */

-static int transcode(AVFormatContext **output_files,

-                     int nb_output_files,

-                     AVFormatContext **input_files,

-                     int nb_input_files,

-                     AVStreamMap *stream_maps, int nb_stream_maps)

+static int av_transcode(AVFormatContext **output_files,

+                        int nb_output_files,

+                        AVFormatContext **input_files,

+                        int nb_input_files,

+                        AVStreamMap *stream_maps, int nb_stream_maps)

 {

     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;

     AVFormatContext *is, *os;

@@ -1985,18 +1809,16 @@

     nb_ostreams = 0;

     for(i=0;i<nb_output_files;i++) {

         os = output_files[i];

-        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {

+        if (!os->nb_streams) {

             dump_format(output_files[i], i, output_files[i]->filename, 1);

             fprintf(stderr, "Output file #%d does not contain any stream/n", i);

-            ret = AVERROR(EINVAL);

-            goto fail;

+            av_exit(1);

         }

         nb_ostreams += os->nb_streams;

     }

     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {

         fprintf(stderr, "Number of stream maps must match number of output streams/n");

-        ret = AVERROR(EINVAL);

-        goto fail;

+        av_exit(1);

     }

 

     /* Sanity check the mapping args -- do the input files & streams exist? */

@@ -2007,28 +1829,35 @@

         if (fi < 0 || fi > nb_input_files - 1 ||

             si < 0 || si > file_table[fi].nb_streams - 1) {

             fprintf(stderr,"Could not find input stream #%d.%d/n", fi, si);

-            ret = AVERROR(EINVAL);

-            goto fail;

+            av_exit(1);

         }

         fi = stream_maps[i].sync_file_index;

         si = stream_maps[i].sync_stream_index;

         if (fi < 0 || fi > nb_input_files - 1 ||

             si < 0 || si > file_table[fi].nb_streams - 1) {

             fprintf(stderr,"Could not find sync stream #%d.%d/n", fi, si);

-            ret = AVERROR(EINVAL);

-            goto fail;

+            av_exit(1);

         }

     }

 

     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);

     if (!ost_table)

         goto fail;

+    for(i=0;i<nb_ostreams;i++) {

+        ost = av_mallocz(sizeof(AVOutputStream));

+        if (!ost)

+            goto fail;

+        ost_table[i] = ost;

+    }

+

     n = 0;

     for(k=0;k<nb_output_files;k++) {

         os = output_files[k];

         for(i=0;i<os->nb_streams;i++,n++) {

             int found;

-            ost = ost_table[n] = output_streams_for_file[k][i];

+            ost = ost_table[n];

+            ost->file_index = k;

+            ost->index = i;

             ost->st = os->streams[i];

             if (nb_stream_maps > 0) {

                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +

@@ -2041,38 +1870,38 @@

                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d/n",

                         stream_maps[n].file_index, stream_maps[n].stream_index,

                         ost->file_index, ost->index);

-                    ffmpeg_exit(1);

+                    av_exit(1);

                 }

 

             } else {

                 int best_nb_frames=-1;

-                /* get corresponding input stream index : we select the first one with the right type */

-                found = 0;

-                for(j=0;j<nb_istreams;j++) {

-                    int skip=0;

-                    ist = ist_table[j];

-                    if(opt_programid){

-                        int pi,si;

-                        AVFormatContext *f= input_files[ ist->file_index ];

-                        skip=1;

-                        for(pi=0; pi<f->nb_programs; pi++){

-                            AVProgram *p= f->programs[pi];

-                            if(p->id == opt_programid)

-                                for(si=0; si<p->nb_stream_indexes; si++){

-                                    if(f->streams[ p->stream_index[si] ] == ist->st)

-                                        skip=0;

-                                }

+                    /* get corresponding input stream index : we select the first one with the right type */

+                    found = 0;

+                    for(j=0;j<nb_istreams;j++) {

+                        int skip=0;

+                        ist = ist_table[j];

+                        if(opt_programid){

+                            int pi,si;

+                            AVFormatContext *f= input_files[ ist->file_index ];

+                            skip=1;

+                            for(pi=0; pi<f->nb_programs; pi++){

+                                AVProgram *p= f->programs[pi];

+                                if(p->id == opt_programid)

+                                    for(si=0; si<p->nb_stream_indexes; si++){

+                                        if(f->streams[ p->stream_index[si] ] == ist->st)

+                                            skip=0;

+                                    }

+                            }

                         }

-                    }

-                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&

-                        ist->st->codec->codec_type == ost->st->codec->codec_type) {

-                        if(best_nb_frames < ist->st->codec_info_nb_frames){

-                            best_nb_frames= ist->st->codec_info_nb_frames;

-                            ost->source_index = j;

-                            found = 1;

+                        if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&

+                            ist->st->codec->codec_type == ost->st->codec->codec_type) {

+                            if(best_nb_frames < ist->st->codec_info_nb_frames){

+                                best_nb_frames= ist->st->codec_info_nb_frames;

+                                ost->source_index = j;

+                                found = 1;

+                            }

                         }

                     }

-                }

 

                 if (!found) {

                     if(! opt_programid) {

@@ -2091,7 +1920,7 @@

                         dump_format(output_files[i], i, output_files[i]->filename, 1);

                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d/n",

                                 ost->file_index, ost->index);

-                        ffmpeg_exit(1);

+                        av_exit(1);

                     }

                 }

             }

@@ -2113,21 +1942,15 @@

         codec = ost->st->codec;

         icodec = ist->st->codec;

 

-        if (metadata_streams_autocopy)

-            while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {

-                av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);

-            }

+        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {

+            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);

+        }

 

         ost->st->disposition = ist->st->disposition;

         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;

         codec->chroma_sample_location = icodec->chroma_sample_location;

 

         if (ost->st->stream_copy) {

-            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;

-

-            if (extra_size > INT_MAX)

-                goto fail;

-

             /* if stream_copy is selected, no need to decode or encode */

             codec->codec_id = icodec->codec_id;

             codec->codec_type = icodec->codec_type;

@@ -2140,25 +1963,18 @@

             }

 

             codec->bit_rate = icodec->bit_rate;

-            codec->rc_max_rate    = icodec->rc_max_rate;

-            codec->rc_buffer_size = icodec->rc_buffer_size;

-            codec->extradata= av_mallocz(extra_size);

-            if (!codec->extradata)

-                goto fail;

-            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);

+            codec->extradata= icodec->extradata;

             codec->extradata_size= icodec->extradata_size;

             if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){

                 codec->time_base = icodec->time_base;

                 codec->time_base.num *= icodec->ticks_per_frame;

-                av_reduce(&codec->time_base.num, &codec->time_base.den,

-                          codec->time_base.num, codec->time_base.den, INT_MAX);

             }else

                 codec->time_base = ist->st->time_base;

             switch(codec->codec_type) {

             case AVMEDIA_TYPE_AUDIO:

                 if(audio_volume != 256) {

                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)/n");

-                    ffmpeg_exit(1);

+                    av_exit(1);

                 }

                 codec->channel_layout = icodec->channel_layout;

                 codec->sample_rate = icodec->sample_rate;

@@ -2189,62 +2005,75 @@

                 ost->fifo= av_fifo_alloc(1024);

                 if(!ost->fifo)

                     goto fail;

-                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);

+                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);

                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;

                 icodec->request_channels = codec->channels;

                 ist->decoding_needed = 1;

                 ost->encoding_needed = 1;

-                ost->resample_sample_fmt  = icodec->sample_fmt;

-                ost->resample_sample_rate = icodec->sample_rate;

-                ost->resample_channels    = icodec->channels;

                 break;

             case AVMEDIA_TYPE_VIDEO:

                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {

                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded/n");

-                    ffmpeg_exit(1);

+                    av_exit(1);

                 }

-                ost->video_resample = (codec->width != icodec->width   ||

-                                       codec->height != icodec->height ||

+                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);

+                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);

+                ost->video_resample = ((codec->width != icodec->width -

+                                (frame_leftBand + frame_rightBand) +

+                                (frame_padleft + frame_padright)) ||

+                        (codec->height != icodec->height -

+                                (frame_topBand  + frame_bottomBand) +

+                                (frame_padtop + frame_padbottom)) ||

                         (codec->pix_fmt != icodec->pix_fmt));

+                if (ost->video_crop) {

+                    ost->topBand    = ost->original_topBand    = frame_topBand;

+                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;

+                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;

+                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;

+                }

+                if (ost->video_pad) {

+                    ost->padtop = frame_padtop;

+                    ost->padleft = frame_padleft;

+                    ost->padbottom = frame_padbottom;

+                    ost->padright = frame_padright;

+                    if (!ost->video_resample) {

+                        avcodec_get_frame_defaults(&ost->pict_tmp);

+                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,

+                                         codec->width, codec->height))

+                            goto fail;

+                    }

+                }

                 if (ost->video_resample) {

                     avcodec_get_frame_defaults(&ost->pict_tmp);

                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,

                                          codec->width, codec->height)) {

                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt/n");

-                        ffmpeg_exit(1);

+                        av_exit(1);

                     }

                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);

                     ost->img_resample_ctx = sws_getContext(

-                        icodec->width,

-                        icodec->height,

+                            icodec->width - (frame_leftBand + frame_rightBand),

+                            icodec->height - (frame_topBand + frame_bottomBand),

                             icodec->pix_fmt,

-                            codec->width,

-                            codec->height,

+                            codec->width - (frame_padleft + frame_padright),

+                            codec->height - (frame_padtop + frame_padbottom),

                             codec->pix_fmt,

                             sws_flags, NULL, NULL, NULL);

                     if (ost->img_resample_ctx == NULL) {

                         fprintf(stderr, "Cannot get resampling context/n");

-                        ffmpeg_exit(1);

+                        av_exit(1);

                     }

 

-#if !CONFIG_AVFILTER

                     ost->original_height = icodec->height;

                     ost->original_width  = icodec->width;

-#endif

+

                     codec->bits_per_raw_sample= 0;

                 }

-                ost->resample_height = icodec->height;

-                ost->resample_width  = icodec->width;

+                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);

+                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);

                 ost->resample_pix_fmt= icodec->pix_fmt;

                 ost->encoding_needed = 1;

                 ist->decoding_needed = 1;

-

-#if CONFIG_AVFILTER

-                if (configure_filters(ist, ost)) {

-                    fprintf(stderr, "Error opening filters!/n");

-                    exit(1);

-                }

-#endif

                 break;

             case AVMEDIA_TYPE_SUBTITLE:

                 ost->encoding_needed = 1;

@@ -2267,7 +2096,7 @@

                     f = fopen(logfilename, "wb");

                     if (!f) {

                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s/n", logfilename, strerror(errno));

-                        ffmpeg_exit(1);

+                        av_exit(1);

                     }

                     ost->logfile = f;

                 } else {

@@ -2275,7 +2104,7 @@

                     size_t logbuffer_size;

                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {

                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding/n", logfilename);

-                        ffmpeg_exit(1);

+                        av_exit(1);

                     }

                     codec->stats_in = logbuffer;

                 }

@@ -2300,8 +2129,7 @@

     for(i=0;i<nb_ostreams;i++) {

         ost = ost_table[i];

         if (ost->encoding_needed) {

-            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;

-            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;

+            AVCodec *codec = output_codecs[i];

             if (!codec)

                 codec = avcodec_find_encoder(ost->st->codec->codec_id);

             if (!codec) {

@@ -2310,15 +2138,6 @@

                 ret = AVERROR(EINVAL);

                 goto dump_format;

             }

-            if (dec->subtitle_header) {

-                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);

-                if (!ost->st->codec->subtitle_header) {

-                    ret = AVERROR(ENOMEM);

-                    goto dump_format;

-                }

-                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);

-                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;

-            }

             if (avcodec_open(ost->st->codec, codec) < 0) {

                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",

                         ost->file_index, ost->index);

@@ -2333,7 +2152,7 @@

     for(i=0;i<nb_istreams;i++) {

         ist = ist_table[i];

         if (ist->decoding_needed) {

-            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;

+            AVCodec *codec = input_codecs[i];

             if (!codec)

                 codec = avcodec_find_decoder(ist->st->codec->codec_id);

             if (!codec) {

@@ -2360,102 +2179,50 @@

         st= ist->st;

         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;

         ist->next_pts = AV_NOPTS_VALUE;

-        init_pts_correction(&ist->pts_ctx);

         ist->is_start = 1;

     }

 

     /* set meta data information from input file if required */

     for (i=0;i<nb_meta_data_maps;i++) {

-        AVFormatContext *files[2];

-        AVMetadata      **meta[2];

+        AVFormatContext *out_file;

+        AVFormatContext *in_file;

         AVMetadataTag *mtag;

-        int j;

-

-#define METADATA_CHECK_INDEX(index, nb_elems, desc)/

-        if ((index) < 0 || (index) >= (nb_elems)) {/

-            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps/n",/

-                     (desc), (index));/

-            ret = AVERROR(EINVAL);/

-            goto dump_format;/

-        }

-

-        int out_file_index = meta_data_maps[i][0].file;

-        int in_file_index = meta_data_maps[i][1].file;

-        if (in_file_index < 0 || out_file_index < 0)

-            continue;

-        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")

-        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")

-

-        files[0] = output_files[out_file_index];

-        files[1] = input_files[in_file_index];

 

-        for (j = 0; j < 2; j++) {

-            AVMetaDataMap *map = &meta_data_maps[i][j];

-

-            switch (map->type) {

-            case 'g':

-                meta[j] = &files[j]->metadata;

-                break;

-            case 's':

-                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")

-                meta[j] = &files[j]->streams[map->index]->metadata;

-                break;

-            case 'c':

-                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")

-                meta[j] = &files[j]->chapters[map->index]->metadata;

-                break;

-            case 'p':

-                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")

-                meta[j] = &files[j]->programs[map->index]->metadata;

-                break;

-            }

-        }

-

-        mtag=NULL;

-        while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))

-            av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);

-    }

-

-    /* copy global metadata by default */

-    if (metadata_global_autocopy) {

-        AVMetadataTag *t = NULL;

-

-        while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))

-            for (i = 0; i < nb_output_files; i++)

-                av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);

-    }

-

-    /* copy chapters according to chapter maps */

-    for (i = 0; i < nb_chapter_maps; i++) {

-        int infile  = chapter_maps[i].in_file;

-        int outfile = chapter_maps[i].out_file;

-

-        if (infile < 0 || outfile < 0)

-            continue;

-        if (infile >= nb_input_files) {

-            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping./n", infile);

+        int out_file_index = meta_data_maps[i].out_file;

+        int in_file_index = meta_data_maps[i].in_file;

+        if (out_file_index < 0 || out_file_index >= nb_output_files) {

+            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",

+                     out_file_index, out_file_index, in_file_index);

             ret = AVERROR(EINVAL);

             goto dump_format;

         }

-        if (outfile >= nb_output_files) {

-            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping./n",outfile);

+        if (in_file_index < 0 || in_file_index >= nb_input_files) {

+            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",

+                     in_file_index, out_file_index, in_file_index);

             ret = AVERROR(EINVAL);

             goto dump_format;

         }

-        copy_chapters(infile, outfile);

+

+        out_file = output_files[out_file_index];

+        in_file = input_files[in_file_index];

+

+

+        mtag=NULL;

+        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))

+            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);

+        av_metadata_conv(out_file, out_file->oformat->metadata_conv,

+                                    in_file->iformat->metadata_conv);

     }

 

     /* copy chapters from the first input file that has them*/

-    if (!nb_chapter_maps)

-        for (i = 0; i < nb_input_files; i++) {

-            if (!input_files[i]->nb_chapters)

-                continue;

+    for (i = 0; i < nb_input_files; i++) {

+        if (!input_files[i]->nb_chapters)

+            continue;

 

-            for (j = 0; j < nb_output_files; j++)

-                if ((ret = copy_chapters(i, j)) < 0)

-                    goto dump_format;

-            break;

-        }

+        for (j = 0; j < nb_output_files; j++)

+            if ((ret = copy_chapters(i, j)) < 0)

+                goto dump_format;

+    }

 

     /* open files and write file headers */

     for(i=0;i<nb_output_files;i++) {

@@ -2570,7 +2337,7 @@

         }

 

         /* finish if limit size exhausted */

-        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))

+        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))

             break;

 

         /* read a frame from it and output it in the fifo */

@@ -2609,8 +2376,7 @@

         if (pkt.pts != AV_NOPTS_VALUE)

             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);

 

-        if (pkt.stream_index < nb_input_files_ts_scale[file_index]

-            && input_files_ts_scale[file_index][pkt.stream_index]){

+        if(input_files_ts_scale[file_index][pkt.stream_index]){

             if(pkt.pts != AV_NOPTS_VALUE)

                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];

             if(pkt.dts != AV_NOPTS_VALUE)

@@ -2646,7 +2412,7 @@

                 fprintf(stderr, "Error while decoding stream #%d.%d/n",

                         ist->file_index, ist->index);

             if (exit_on_error)

-                ffmpeg_exit(1);

+                av_exit(1);

             av_free_packet(&pkt);

             goto redo;

         }

@@ -2693,12 +2459,6 @@

             avcodec_close(ist->st->codec);

         }

     }

-#if CONFIG_AVFILTER

-    if (graph) {

-        avfilter_graph_free(graph);

-        av_freep(&graph);

-    }

-#endif

 

     /* finished ! */

     ret = 0;

@@ -2718,17 +2478,13 @@

         for(i=0;i<nb_ostreams;i++) {

             ost = ost_table[i];

             if (ost) {

-                if (ost->st->stream_copy)

-                    av_freep(&ost->st->codec->extradata);

                 if (ost->logfile) {

                     fclose(ost->logfile);

                     ost->logfile = NULL;

                 }

                 av_fifo_free(ost->fifo); /* works even if fifo is not

                                              initialized but set to zero */

-                av_freep(&ost->st->codec->subtitle_header);

                 av_free(ost->pict_tmp.data[0]);

-                av_free(ost->forced_kf_pts);

                 if (ost->video_resample)

                     sws_freeContext(ost->img_resample_ctx);

                 if (ost->resample)

@@ -2745,6 +2501,14 @@

 

 static void opt_format(const char *arg)

 {

+    /* compatibility stuff for pgmyuv */

+    if (!strcmp(arg, "pgmyuv")) {

+        pgmyuv_compatibility_hack=1;

+//        opt_image_format(arg);

+        arg = "image2";

+        fprintf(stderr, "pgmyuv format is deprecated, use image2/n");

+    }

+

     last_asked_format = arg;

 }

 

@@ -2767,9 +2531,9 @@

 

 static int opt_frame_rate(const char *opt, const char *arg)

 {

-    if (av_parse_video_rate(&frame_rate, arg) < 0) {

+    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {

         fprintf(stderr, "Incorrect value for %s: %s/n", opt, arg);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     return 0;

 }

@@ -2786,23 +2550,121 @@

     return 0;

 }

 

-static int opt_frame_crop(const char *opt, const char *arg)

+static void opt_frame_crop_top(const char *arg)

 {

-    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead/n", opt);

-    return AVERROR(EINVAL);

+    frame_topBand = atoi(arg);

+    if (frame_topBand < 0) {

+        fprintf(stderr, "Incorrect top crop size/n");

+        av_exit(1);

+    }

+    if ((frame_topBand) >= frame_height){

+        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

+        av_exit(1);

+    }

+    frame_height -= frame_topBand;

+}

+

+static void opt_frame_crop_bottom(const char *arg)

+{

+    frame_bottomBand = atoi(arg);

+    if (frame_bottomBand < 0) {

+        fprintf(stderr, "Incorrect bottom crop size/n");

+        av_exit(1);

+    }

+    if ((frame_bottomBand) >= frame_height){

+        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

+        av_exit(1);

+    }

+    frame_height -= frame_bottomBand;

+}

+

+static void opt_frame_crop_left(const char *arg)

+{

+    frame_leftBand = atoi(arg);

+    if (frame_leftBand < 0) {

+        fprintf(stderr, "Incorrect left crop size/n");

+        av_exit(1);

+    }

+    if ((frame_leftBand) >= frame_width){

+        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

+        av_exit(1);

+    }

+    frame_width -= frame_leftBand;

+}

+

+static void opt_frame_crop_right(const char *arg)

+{

+    frame_rightBand = atoi(arg);

+    if (frame_rightBand < 0) {

+        fprintf(stderr, "Incorrect right crop size/n");

+        av_exit(1);

+    }

+    if ((frame_rightBand) >= frame_width){

+        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image./nRemember to crop first and scale second./n");

+        av_exit(1);

+    }

+    frame_width -= frame_rightBand;

 }

 

 static void opt_frame_size(const char *arg)

 {

-    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {

+    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {

         fprintf(stderr, "Incorrect frame size/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 }

 

-static int opt_pad(const char *opt, const char *arg) {

-    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead/n", opt);

-    return -1;

+static void opt_pad_color(const char *arg) {

+    /* Input is expected to be six hex digits similar to

+       how colors are expressed in html tags (but without the #) */

+    int rgb = strtol(arg, NULL, 16);

+    int r,g,b;

+

+    r = (rgb >> 16);

+    g = ((rgb >> 8) & 255);

+    b = (rgb & 255);

+

+    padcolor[0] = RGB_TO_Y(r,g,b);

+    padcolor[1] = RGB_TO_U(r,g,b,0);

+    padcolor[2] = RGB_TO_V(r,g,b,0);

+}

+

+static void opt_frame_pad_top(const char *arg)

+{

+    frame_padtop = atoi(arg);

+    if (frame_padtop < 0) {

+        fprintf(stderr, "Incorrect top pad size/n");

+        av_exit(1);

+    }

+}

+

+static void opt_frame_pad_bottom(const char *arg)

+{

+    frame_padbottom = atoi(arg);

+    if (frame_padbottom < 0) {

+        fprintf(stderr, "Incorrect bottom pad size/n");

+        av_exit(1);

+    }

+}

+

+

+static void opt_frame_pad_left(const char *arg)

+{

+    frame_padleft = atoi(arg);

+    if (frame_padleft < 0) {

+        fprintf(stderr, "Incorrect left pad size/n");

+        av_exit(1);

+    }

+}

+

+

+static void opt_frame_pad_right(const char *arg)

+{

+    frame_padright = atoi(arg);

+    if (frame_padright < 0) {

+        fprintf(stderr, "Incorrect right pad size/n");

+        av_exit(1);

+    }

 }

 

 static void opt_frame_pix_fmt(const char *arg)

@@ -2811,11 +2673,11 @@

         frame_pix_fmt = av_get_pix_fmt(arg);

         if (frame_pix_fmt == PIX_FMT_NONE) {

             fprintf(stderr, "Unknown pixel format requested: %s/n", arg);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

     } else {

         show_pix_fmts();

-        ffmpeg_exit(0);

+        av_exit(0);

     }

 }

 

@@ -2838,7 +2700,7 @@

 

     if (!ar) {

         fprintf(stderr, "Incorrect aspect ratio specification./n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     frame_aspect_ratio = ar;

 }

@@ -2849,11 +2711,14 @@

 

     if(!mid){

         fprintf(stderr, "Missing =/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     *mid++= 0;

 

-    av_metadata_set2(&metadata, arg, mid, 0);

+    metadata_count++;

+    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);

+    metadata[metadata_count-1].key  = av_strdup(arg);

+    metadata[metadata_count-1].value= av_strdup(mid);

 

     return 0;

 }

@@ -2864,7 +2729,7 @@

     if (video_qscale <= 0 ||

         video_qscale > 255) {

         fprintf(stderr, "qscale must be > 0.0 and <= 255/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 }

 

@@ -2886,10 +2751,10 @@

 static void opt_audio_sample_fmt(const char *arg)

 {

     if (strcmp(arg, "list"))

-        audio_sample_fmt = av_get_sample_fmt(arg);

+        audio_sample_fmt = avcodec_get_sample_fmt(arg);

     else {

-        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);

-        ffmpeg_exit(0);

+        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);

+        av_exit(0);

     }

 }

 

@@ -2931,6 +2796,24 @@

     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);

 }

 

+static void opt_audio_tag(const char *arg)

+{

+    char *tail;

+    audio_codec_tag= strtol(arg, &tail, 0);

+

+    if(!tail || *tail)

+        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);

+}

+

+static void opt_video_tag(const char *arg)

+{

+    char *tail;

+    video_codec_tag= strtol(arg, &tail, 0);

+

+    if(!tail || *tail)

+        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);

+}

+

 static void opt_video_codec(const char *arg)

 {

     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);

@@ -2941,22 +2824,13 @@

     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);

 }

 

-static int opt_codec_tag(const char *opt, const char *arg)

+static void opt_subtitle_tag(const char *arg)

 {

     char *tail;

-    uint32_t *codec_tag;

-

-    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :

-                !strcmp(opt, "vtag") ? &video_codec_tag :

-                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;

-    if (!codec_tag)

-        return -1;

-

-    *codec_tag = strtol(arg, &tail, 0);

-    if (!tail || *tail)

-        *codec_tag = AV_RL32(arg);

+    subtitle_codec_tag= strtol(arg, &tail, 0);

 

-    return 0;

+    if(!tail || *tail)

+        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);

 }

 

 static void opt_map(const char *arg)

@@ -2964,8 +2838,7 @@

     AVStreamMap *m;

     char *p;

 

-    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);

-    m = &stream_maps[nb_stream_maps-1];

+    m = &stream_maps[nb_stream_maps++];

 

     m->file_index = strtol(arg, &p, 0);

     if (*p)

@@ -2984,66 +2857,18 @@

     }

 }

 

-static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)

-{

-    *endptr = arg;

-    if (*arg == ',') {

-        *type = *(++arg);

-        switch (*arg) {

-        case 'g':

-            break;

-        case 's':

-        case 'c':

-        case 'p':

-            *index = strtol(++arg, endptr, 0);

-            break;

-        default:

-            fprintf(stderr, "Invalid metadata type %c./n", *arg);

-            ffmpeg_exit(1);

-        }

-    } else

-        *type = 'g';

-}

-

 static void opt_map_meta_data(const char *arg)

 {

-    AVMetaDataMap *m, *m1;

+    AVMetaDataMap *m;

     char *p;

 

-    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),

-                                &nb_meta_data_maps, nb_meta_data_maps + 1);

+    m = &meta_data_maps[nb_meta_data_maps++];

 

-    m = &meta_data_maps[nb_meta_data_maps - 1][0];

-    m->file = strtol(arg, &p, 0);

-    parse_meta_type(p, &m->type, &m->index, &p);

+    m->out_file = strtol(arg, &p, 0);

     if (*p)

         p++;

 

-    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];

-    m1->file = strtol(p, &p, 0);

-    parse_meta_type(p, &m1->type, &m1->index, &p);

-

-    if (m->type == 'g' || m1->type == 'g')

-        metadata_global_autocopy = 0;

-    if (m->type == 's' || m1->type == 's')

-        metadata_streams_autocopy = 0;

-    if (m->type == 'c' || m1->type == 'c')

-        metadata_chapters_autocopy = 0;

-}

-

-static void opt_map_chapters(const char *arg)

-{

-    AVChapterMap *c;

-    char *p;

-

-    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,

-                              nb_chapter_maps + 1);

-    c = &chapter_maps[nb_chapter_maps - 1];

-    c->out_file = strtol(arg, &p, 0);

-    if (*p)

-        p++;

-

-    c->in_file = strtol(p, &p, 0);

+    m->in_file = strtol(p, &p, 0);

 }

 

 static void opt_input_ts_scale(const char *arg)

@@ -3058,9 +2883,8 @@

     scale= strtod(p, &p);

 

     if(stream >= MAX_STREAMS)

-        ffmpeg_exit(1);

+        av_exit(1);

 

-    input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);

     input_files_ts_scale[nb_input_files][stream]= scale;

 }

 

@@ -3076,9 +2900,9 @@

     return 0;

 }

 

-static int opt_recording_timestamp(const char *opt, const char *arg)

+static int opt_rec_timestamp(const char *opt, const char *arg)

 {

-    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;

+    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;

     return 0;

 }

 

@@ -3100,11 +2924,11 @@

         avcodec_find_decoder_by_name(name);

     if(!codec) {

         fprintf(stderr, "Unknown %s '%s'/n", codec_string, name);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     if(codec->type != type) {

         fprintf(stderr, "Invalid %s type '%s'/n", codec_string, name);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&

        strict > FF_COMPLIANCE_EXPERIMENTAL) {

@@ -3117,7 +2941,7 @@

         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))

             fprintf(stderr, "Or use the non experimental %s '%s'./n",

                     codec_string, codec->name);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     return codec->id;

 }

@@ -3133,7 +2957,7 @@

     if (last_asked_format) {

         if (!(file_iformat = av_find_input_format(last_asked_format))) {

             fprintf(stderr, "Unknown input format: '%s'/n", last_asked_format);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         last_asked_format = NULL;

     }

@@ -3148,7 +2972,7 @@

     ic = avformat_alloc_context();

     if (!ic) {

         print_error(filename, AVERROR(ENOMEM));

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     memset(ap, 0, sizeof(*ap));

@@ -3157,14 +2981,14 @@

     ap->channels = audio_channels;

     ap->time_base.den = frame_rate.num;

     ap->time_base.num = frame_rate.den;

-    ap->width = frame_width;

-    ap->height = frame_height;

+    ap->width = frame_width + frame_padleft + frame_padright;

+    ap->height = frame_height + frame_padtop + frame_padbottom;

     ap->pix_fmt = frame_pix_fmt;

    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat

     ap->channel = video_channel;

     ap->standard = video_standard;

 

-    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);

+    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);

 

     ic->video_codec_id   =

         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,

@@ -3177,11 +3001,14 @@

                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);

     ic->flags |= AVFMT_FLAG_NONBLOCK;

 

+    if(pgmyuv_compatibility_hack)

+        ic->video_codec_id= CODEC_ID_PGMYUV;

+

     /* open the input file with generic libav function */

     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);

     if (err < 0) {

         print_error(filename, err);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     if(opt_programid) {

         int i, j;

@@ -3202,7 +3029,7 @@

         }

         if(!found){

             fprintf(stderr, "Specified program id not found/n");

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         opt_programid=0;

     }

@@ -3214,8 +3041,7 @@

     ret = av_find_stream_info(ic);

     if (ret < 0 && verbose >= 0) {

         fprintf(stderr, "%s: could not find codec parameters/n", filename);

-        av_close_input_file(ic);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     timestamp = start_time;

@@ -3237,54 +3063,45 @@

     /* update the current parameters so that they match the one of the input stream */

     for(i=0;i<ic->nb_streams;i++) {

         AVStream *st = ic->streams[i];

-        AVCodecContext *dec = st->codec;

-        avcodec_thread_init(dec, thread_count);

-        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);

-        switch (dec->codec_type) {

+        AVCodecContext *enc = st->codec;

+        avcodec_thread_init(enc, thread_count);

+        switch(enc->codec_type) {

         case AVMEDIA_TYPE_AUDIO:

-            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);

-            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);

-            //fprintf(stderr, "/nInput Audio channels: %d", dec->channels);

-            channel_layout    = dec->channel_layout;

-            audio_channels    = dec->channels;

-            audio_sample_rate = dec->sample_rate;

-            audio_sample_fmt  = dec->sample_fmt;

+            set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);

+            //fprintf(stderr, "/nInput Audio channels: %d", enc->channels);

+            channel_layout = enc->channel_layout;

+            audio_channels = enc->channels;

+            audio_sample_rate = enc->sample_rate;

+            audio_sample_fmt = enc->sample_fmt;

+            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);

             if(audio_disable)

                 st->discard= AVDISCARD_ALL;

-            /* Note that av_find_stream_info can add more streams, and we

-             * currently have no chance of setting up lowres decoding

-             * early enough for them. */

-            if (dec->lowres)

-                audio_sample_rate >>= dec->lowres;

             break;

         case AVMEDIA_TYPE_VIDEO:

-            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);

-            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);

-            frame_height = dec->height;

-            frame_width  = dec->width;

+            set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);

+            frame_height = enc->height;

+            frame_width = enc->width;

             if(ic->streams[i]->sample_aspect_ratio.num)

                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);

             else

-                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);

-            frame_aspect_ratio *= (float) dec->width / dec->height;

-            frame_pix_fmt = dec->pix_fmt;

+                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);

+            frame_aspect_ratio *= (float) enc->width / enc->height;

+            frame_pix_fmt = enc->pix_fmt;

             rfps      = ic->streams[i]->r_frame_rate.num;

             rfps_base = ic->streams[i]->r_frame_rate.den;

-            if (dec->lowres) {

-                dec->flags |= CODEC_FLAG_EMU_EDGE;

-                frame_height >>= dec->lowres;

-                frame_width  >>= dec->lowres;

-                dec->height = frame_height;

-                dec->width  = frame_width;

+            if(enc->lowres) {

+                enc->flags |= CODEC_FLAG_EMU_EDGE;

+                frame_height >>= enc->lowres;

+                frame_width  >>= enc->lowres;

             }

             if(me_threshold)

-                dec->debug |= FF_DEBUG_MV;

+                enc->debug |= FF_DEBUG_MV;

 

-            if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {

+            if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {

 

                 if (verbose >= 0)

                     fprintf(stderr,"/nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)/n",

-                            i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,

+                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,

 

                     (float)rfps / rfps_base, rfps, rfps_base);

             }

@@ -3292,6 +3109,7 @@

             frame_rate.num = rfps;

             frame_rate.den = rfps_base;

 

+            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);

             if(video_disable)

                 st->discard= AVDISCARD_ALL;

             else if(video_discard)

@@ -3300,12 +3118,13 @@

         case AVMEDIA_TYPE_DATA:

             break;

         case AVMEDIA_TYPE_SUBTITLE:

-            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);

+            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);

             if(subtitle_disable)

                 st->discard = AVDISCARD_ALL;

             break;

         case AVMEDIA_TYPE_ATTACHMENT:

         case AVMEDIA_TYPE_UNKNOWN:

+            nb_icodecs++;

             break;

         default:

             abort();

@@ -3364,36 +3183,19 @@

     *has_subtitle_ptr = has_subtitle;

 }

 

-static void new_video_stream(AVFormatContext *oc, int file_idx)

+static void new_video_stream(AVFormatContext *oc)

 {

     AVStream *st;

-    AVOutputStream *ost;

     AVCodecContext *video_enc;

     enum CodecID codec_id;

-    AVCodec *codec= NULL;

 

-    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

+    st = av_new_stream(oc, oc->nb_streams);

     if (!st) {

         fprintf(stderr, "Could not alloc stream/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

-    ost = new_output_stream(oc, file_idx);

-

-    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);

-    if(!video_stream_copy){

-        if (video_codec_name) {

-            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,

-                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);

-            codec = avcodec_find_encoder_by_name(video_codec_name);

-            output_codecs[nb_output_codecs-1] = codec;

-        } else {

-            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);

-            codec = avcodec_find_encoder(codec_id);

-        }

-    }

-

-    avcodec_get_context_defaults3(st->codec, codec);

-    ost->bitstream_filters = video_bitstream_filters;

+    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);

+    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;

     video_bitstream_filters= NULL;

 

     avcodec_thread_init(st->codec, thread_count);

@@ -3421,18 +3223,30 @@

     } else {

         const char *p;

         int i;

+        AVCodec *codec;

         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};

 

+        if (video_codec_name) {

+            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,

+                                         video_enc->strict_std_compliance);

+            codec = avcodec_find_encoder_by_name(video_codec_name);

+            output_codecs[nb_ocodecs] = codec;

+        } else {

+            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);

+            codec = avcodec_find_encoder(codec_id);

+        }

+

         video_enc->codec_id = codec_id;

-        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);

+

+        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);

 

         if (codec && codec->supported_framerates && !force_fps)

             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];

         video_enc->time_base.den = fps.num;

         video_enc->time_base.num = fps.den;

 

-        video_enc->width = frame_width;

-        video_enc->height = frame_height;

+        video_enc->width = frame_width + frame_padright + frame_padleft;

+        video_enc->height = frame_height + frame_padtop + frame_padbottom;

         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);

         video_enc->pix_fmt = frame_pix_fmt;

         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;

@@ -3458,7 +3272,7 @@

             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);

             if(e!=3){

                 fprintf(stderr, "error parsing rc_override/n");

-                ffmpeg_exit(1);

+                av_exit(1);

             }

             video_enc->rc_override=

                 av_realloc(video_enc->rc_override,

@@ -3493,10 +3307,8 @@

                 video_enc->flags |= CODEC_FLAG_PASS2;

             }

         }

-

-        if (forced_key_frames)

-            parse_forced_key_frames(forced_key_frames, ost, video_enc);

     }

+    nb_ocodecs++;

     if (video_language) {

         av_metadata_set2(&st->metadata, "language", video_language, 0);

         av_freep(&video_language);

@@ -3505,42 +3317,24 @@

     /* reset some key parameters */

     video_disable = 0;

     av_freep(&video_codec_name);

-    av_freep(&forced_key_frames);

     video_stream_copy = 0;

     frame_pix_fmt = PIX_FMT_NONE;

 }

 

-static void new_audio_stream(AVFormatContext *oc, int file_idx)

+static void new_audio_stream(AVFormatContext *oc)

 {

     AVStream *st;

-    AVOutputStream *ost;

-    AVCodec *codec= NULL;

     AVCodecContext *audio_enc;

     enum CodecID codec_id;

 

-    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

+    st = av_new_stream(oc, oc->nb_streams);

     if (!st) {

         fprintf(stderr, "Could not alloc stream/n");

-        ffmpeg_exit(1);

-    }

-    ost = new_output_stream(oc, file_idx);

-

-    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);

-    if(!audio_stream_copy){

-        if (audio_codec_name) {

-            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,

-                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);

-            codec = avcodec_find_encoder_by_name(audio_codec_name);

-            output_codecs[nb_output_codecs-1] = codec;

-        } else {

-            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);

-            codec = avcodec_find_encoder(codec_id);

-        }

+        av_exit(1);

     }

+    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);

 

-    avcodec_get_context_defaults3(st->codec, codec);

-

-    ost->bitstream_filters = audio_bitstream_filters;

+    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;

     audio_bitstream_filters= NULL;

 

     avcodec_thread_init(st->codec, thread_count);

@@ -3560,8 +3354,20 @@

         audio_enc->channels = audio_channels;

         audio_enc->sample_rate = audio_sample_rate;

     } else {

+        AVCodec *codec;

+

+        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);

+

+        if (audio_codec_name) {

+            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,

+                                         audio_enc->strict_std_compliance);

+            codec = avcodec_find_encoder_by_name(audio_codec_name);

+            output_codecs[nb_ocodecs] = codec;

+        } else {

+            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);

+            codec = avcodec_find_encoder(codec_id);

+        }

         audio_enc->codec_id = codec_id;

-        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);

 

         if (audio_qscale > QSCALE_NONE) {

             audio_enc->flags |= CODEC_FLAG_QSCALE;

@@ -3571,11 +3377,12 @@

         audio_enc->sample_fmt = audio_sample_fmt;

         audio_enc->sample_rate = audio_sample_rate;

         audio_enc->channel_layout = channel_layout;

-        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)

+        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)

             audio_enc->channel_layout = 0;

         choose_sample_fmt(st, codec);

         choose_sample_rate(st, codec);

     }

+    nb_ocodecs++;

     audio_enc->time_base= (AVRational){1, audio_sample_rate};

     if (audio_language) {

         av_metadata_set2(&st->metadata, "language", audio_language, 0);

@@ -3588,52 +3395,36 @@

     audio_stream_copy = 0;

 }

 

-static void new_subtitle_stream(AVFormatContext *oc, int file_idx)

+static void new_subtitle_stream(AVFormatContext *oc)

 {

     AVStream *st;

-    AVOutputStream *ost;

-    AVCodec *codec=NULL;

     AVCodecContext *subtitle_enc;

-    enum CodecID codec_id;

 

-    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

+    st = av_new_stream(oc, oc->nb_streams);

     if (!st) {

         fprintf(stderr, "Could not alloc stream/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

-    ost = new_output_stream(oc, file_idx);

-    subtitle_enc = st->codec;

-    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);

-    if(!subtitle_stream_copy){

-        if (subtitle_codec_name) {

-            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,

-                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);

-            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);

-        } else {

-            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);

-            codec = avcodec_find_encoder(codec_id);

-        }

-    }

-    avcodec_get_context_defaults3(st->codec, codec);

+    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);

 

-    ost->bitstream_filters = subtitle_bitstream_filters;

+    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;

     subtitle_bitstream_filters= NULL;

 

+    subtitle_enc = st->codec;

     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;

 

     if(subtitle_codec_tag)

         subtitle_enc->codec_tag= subtitle_codec_tag;

 

-    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {

-        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

-        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;

-    }

     if (subtitle_stream_copy) {

         st->stream_copy = 1;

     } else {

-        subtitle_enc->codec_id = codec_id;

-        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);

+        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);

+        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,

+                                                   subtitle_enc->strict_std_compliance);

+        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);

     }

+    nb_ocodecs++;

 

     if (subtitle_language) {

         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);

@@ -3645,44 +3436,37 @@

     subtitle_stream_copy = 0;

 }

 

-static int opt_new_stream(const char *opt, const char *arg)

+static void opt_new_audio_stream(void)

 {

     AVFormatContext *oc;

-    int file_idx = nb_output_files - 1;

     if (nb_output_files <= 0) {

         fprintf(stderr, "At least one output file must be specified/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

-    oc = output_files[file_idx];

-

-    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);

-    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);

-    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);

-    else av_assert0(0);

-    return 0;

+    oc = output_files[nb_output_files - 1];

+    new_audio_stream(oc);

 }

 

-/* arg format is "output-stream-index:streamid-value". */

-static int opt_streamid(const char *opt, const char *arg)

+static void opt_new_video_stream(void)

 {

-    int idx;

-    char *p;

-    char idx_str[16];

+    AVFormatContext *oc;

+    if (nb_output_files <= 0) {

+        fprintf(stderr, "At least one output file must be specified/n");

+        av_exit(1);

+    }

+    oc = output_files[nb_output_files - 1];

+    new_video_stream(oc);

+}

 

-    strncpy(idx_str, arg, sizeof(idx_str));

-    idx_str[sizeof(idx_str)-1] = '/0';

-    p = strchr(idx_str, ':');

-    if (!p) {

-        fprintf(stderr,

-                "Invalid value '%s' for option '%s', required syntax is 'index:value'/n",

-                arg, opt);

-        ffmpeg_exit(1);

-    }

-    *p++ = '/0';

-    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);

-    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);

-    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);

-    return 0;

+static void opt_new_subtitle_stream(void)

+{

+    AVFormatContext *oc;

+    if (nb_output_files <= 0) {

+        fprintf(stderr, "At least one output file must be specified/n");

+        av_exit(1);

+    }

+    oc = output_files[nb_output_files - 1];

+    new_subtitle_stream(oc);

 }

 

 static void opt_output_file(const char *filename)

@@ -3692,7 +3476,6 @@

     int input_has_video, input_has_audio, input_has_subtitle;

     AVFormatParameters params, *ap = &params;

     AVOutputFormat *file_oformat;

-    AVMetadataTag *tag = NULL;

 

     if (!strcmp(filename, "-"))

         filename = "pipe:";

@@ -3700,14 +3483,14 @@

     oc = avformat_alloc_context();

     if (!oc) {

         print_error(filename, AVERROR(ENOMEM));

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     if (last_asked_format) {

         file_oformat = av_guess_format(last_asked_format, NULL, NULL);

         if (!file_oformat) {

             fprintf(stderr, "Requested output format '%s' is not a suitable output format/n", last_asked_format);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         last_asked_format = NULL;

     } else {

@@ -3715,7 +3498,7 @@

         if (!file_oformat) {

             fprintf(stderr, "Unable to find a suitable output format for '%s'/n",

                     filename);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

     }

 

@@ -3729,7 +3512,7 @@

         int err = read_ffserver_streams(oc, filename);

         if (err < 0) {

             print_error(filename, err);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

     } else {

         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;

@@ -3750,19 +3533,35 @@

         }

 

         /* manual disable */

-        if (audio_disable)    use_audio    = 0;

-        if (video_disable)    use_video    = 0;

-        if (subtitle_disable) use_subtitle = 0;

-

-        if (use_video)    new_video_stream(oc, nb_output_files);

-        if (use_audio)    new_audio_stream(oc, nb_output_files);

-        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);

-

-        oc->timestamp = recording_timestamp;

-

-        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))

-            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);

-        av_metadata_free(&metadata);

+        if (audio_disable) {

+            use_audio = 0;

+        }

+        if (video_disable) {

+            use_video = 0;

+        }

+        if (subtitle_disable) {

+            use_subtitle = 0;

+        }

+

+        if (use_video) {

+            new_video_stream(oc);

+        }

+

+        if (use_audio) {

+            new_audio_stream(oc);

+        }

+

+        if (use_subtitle) {

+            new_subtitle_stream(oc);

+        }

+

+        oc->timestamp = rec_timestamp;

+

+        for(; metadata_count>0; metadata_count--){

+            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,

+                                            metadata[metadata_count-1].value, 0);

+        }

+        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);

     }

 

     output_files[nb_output_files++] = oc;

@@ -3771,7 +3570,7 @@

     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {

         if (!av_filename_number_test(oc->filename)) {

             print_error(oc->filename, AVERROR_NUMEXPECTED);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

     }

 

@@ -3787,12 +3586,12 @@

                     fflush(stderr);

                     if (!read_yesno()) {

                         fprintf(stderr, "Not overwriting - exiting/n");

-                        ffmpeg_exit(1);

+                        av_exit(1);

                     }

                 }

                 else {

                     fprintf(stderr,"File '%s' already exists. Exiting./n", filename);

-                    ffmpeg_exit(1);

+                    av_exit(1);

                 }

             }

         }

@@ -3800,7 +3599,7 @@

         /* open the file */

         if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {

             print_error(filename, err);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

     }

 

@@ -3808,7 +3607,7 @@

     if (av_set_parameters(oc, ap) < 0) {

         fprintf(stderr, "%s: Invalid encoding parameters/n",

                 oc->filename);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     oc->preload= (int)(mux_preload*AV_TIME_BASE);

@@ -3816,10 +3615,7 @@

     oc->loop_output = loop_output;

     oc->flags |= AVFMT_FLAG_NONBLOCK;

 

-    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);

-

-    nb_streamid_map = 0;

-    av_freep(&forced_key_frames);

+    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);

 }

 

 /* same option as mencoder */

@@ -3829,7 +3625,7 @@

     pass = atoi(pass_str);

     if (pass != 1 && pass != 2) {

         fprintf(stderr, "pass number can be only 1 or 2/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

     do_pass = pass;

 }

@@ -3881,7 +3677,7 @@

         p = strchr(p, ',');

         if(!p) {

             fprintf(stderr, "Syntax error in matrix /"%s/" at coeff %d/n", str, i);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         p++;

     }

@@ -3899,6 +3695,15 @@

     parse_matrix_coeffs(intra_matrix, arg);

 }

 

+/**

+ * Trivial log callback.

+ * Only suitable for show_help and similar since it lacks prefix handling.

+ */

+static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)

+{

+    vfprintf(stdout, fmt, vl);

+}

+

 static void show_usage(void)

 {

     printf("Hyper fast Audio and Video encoder/n");

@@ -3908,9 +3713,6 @@

 

 static void show_help(void)

 {

-    AVCodec *c;

-    AVOutputFormat *oformat = NULL;

-

     av_log_set_callback(log_callback_help);

     show_usage();

     show_help_options(options, "Main options:/n",

@@ -3937,30 +3739,11 @@

                       OPT_GRAB,

                       OPT_GRAB);

     printf("/n");

-    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

+    av_opt_show(avcodec_opts[0], NULL);

     printf("/n");

-

-    /* individual codec options */

-    c = NULL;

-    while ((c = av_codec_next(c))) {

-        if (c->priv_class) {

-            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

-            printf("/n");

-        }

-    }

-

-    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

+    av_opt_show(avformat_opts, NULL);

     printf("/n");

-

-    /* individual muxer options */

-    while ((oformat = av_oformat_next(oformat))) {

-        if (oformat->priv_class) {

-            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);

-            printf("/n");

-        }

-    }

-

-    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

+    av_opt_show(sws_opts, NULL);

 }

 

 static void opt_target(const char *arg)

@@ -4016,7 +3799,7 @@

         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target./n");

         fprintf(stderr, "Please prefix target with /"pal-/", /"ntsc-/" or /"film-/",/n");

         fprintf(stderr, "or set a framerate with /"-r xxx/"./n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     if(!strcmp(arg, "vcd")) {

@@ -4104,7 +3887,7 @@

 

     } else {

         fprintf(stderr, "Unknown target: %s/n", arg);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 }

 

@@ -4132,7 +3915,7 @@

 

     if(!bsfc){

         fprintf(stderr, "Unknown bitstream filter %s/n", arg);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     bsfp= *opt == 'v' ? &video_bitstream_filters :

@@ -4150,13 +3933,34 @@

 {

     FILE *f=NULL;

     char filename[1000], tmp[1000], tmp2[1000], line[1000];

-    char *codec_name = *opt == 'v' ? video_codec_name :

-                       *opt == 'a' ? audio_codec_name :

-                                     subtitle_codec_name;

+    int i;

+    const char *base[3]= { getenv("FFMPEG_DATADIR"),

+                           getenv("HOME"),

+                           FFMPEG_DATADIR,

+                         };

+

+    if (*opt != 'f') {

+        for(i=0; i<3 && !f; i++){

+            if(!base[i])

+                continue;

+            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);

+            f= fopen(filename, "r");

+            if(!f){

+                char *codec_name= *opt == 'v' ? video_codec_name :

+                                  *opt == 'a' ? audio_codec_name :

+                                                subtitle_codec_name;

+                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);

+                f= fopen(filename, "r");

+            }

+        }

+    } else {

+        av_strlcpy(filename, arg, sizeof(filename));

+        f= fopen(filename, "r");

+    }

 

-    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {

+    if(!f){

         fprintf(stderr, "File for preset '%s' not found/n", arg);

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     while(!feof(f)){

@@ -4166,7 +3970,7 @@

         e|= sscanf(line, "%999[^=]=%999[^/n]/n", tmp, tmp2) - 2;

         if(e){

             fprintf(stderr, "%s: Invalid syntax: '%s'/n", filename, line);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

         if(!strcmp(tmp, "acodec")){

             opt_audio_codec(tmp2);

@@ -4176,7 +3980,7 @@

             opt_subtitle_codec(tmp2);

         }else if(opt_default(tmp, tmp2) < 0){

             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'/n", filename, line, tmp, tmp2);

-            ffmpeg_exit(1);

+            av_exit(1);

         }

     }

 

@@ -4192,14 +3996,13 @@

     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },

     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },

     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },

-    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },

-    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },

+    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },

     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode /"duration/" seconds of audio/video", "duration" },

     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //

     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },

     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },

     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },

-    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },

+    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },

     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },

     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },

     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},

@@ -4234,15 +4037,15 @@

     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },

     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },

     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },

-    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

-    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

-    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

-    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

-    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

-    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

-    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

-    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

-    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },

+    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },

+    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },

+    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },

+    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },

+    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },

+    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },

+    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },

+    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },

+    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },

     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},

     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },

     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },

@@ -4259,20 +4062,15 @@

     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },

     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },

     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },

-#if CONFIG_AVFILTER

-    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },

-#endif

     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },

     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },

     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },

     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },

-    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },

-    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },

+    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },

+    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },

     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },

     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },

     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },

-    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },

-    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },

 

     /* audio options */

     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },

@@ -4282,18 +4080,18 @@

     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },

     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },

     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },

-    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },

+    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },

     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //

-    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },

+    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },

     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },

     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },

 

     /* subtitle options */

     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },

     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },

-    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },

+    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },

     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },

-    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },

+    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },

 

     /* grab options */

     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },

@@ -4319,17 +4117,13 @@

 

 int main(int argc, char **argv)

 {

+    int i;

     int64_t ti;

 

-    av_log_set_flags(AV_LOG_SKIP_REPEATED);

-

     avcodec_register_all();

 #if CONFIG_AVDEVICE

     avdevice_register_all();

 #endif

-#if CONFIG_AVFILTER

-    avfilter_register_all();

-#endif

     av_register_all();

 

 #if HAVE_ISATTY

@@ -4337,7 +4131,11 @@

         url_set_interrupt_cb(decode_interrupt_cb);

 #endif

 

-    init_opts();

+    for(i=0; i<AVMEDIA_TYPE_NB; i++){

+        avcodec_opts[i]= avcodec_alloc_context2(i);

+    }

+    avformat_opts = avformat_alloc_context();

+    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);

 

     show_banner();

 

@@ -4347,29 +4145,29 @@

     if(nb_output_files <= 0 && nb_input_files == 0) {

         show_usage();

         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     /* file converter / grab */

     if (nb_output_files <= 0) {

         fprintf(stderr, "At least one output file must be specified/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     if (nb_input_files == 0) {

         fprintf(stderr, "At least one input file must be specified/n");

-        ffmpeg_exit(1);

+        av_exit(1);

     }

 

     ti = getutime();

-    if (transcode(output_files, nb_output_files, input_files, nb_input_files,

-                  stream_maps, nb_stream_maps) < 0)

-        ffmpeg_exit(1);

+    if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,

+                     stream_maps, nb_stream_maps) < 0)

+        av_exit(1);

     ti = getutime() - ti;

     if (do_benchmark) {

         int maxrss = getmaxrss() / 1024;

         printf("bench: utime=%0.3fs maxrss=%ikB/n", ti / 1000000.0, maxrss);

     }

 

-    return ffmpeg_exit(0);

+    return av_exit(0);

 }

diff -u ffmpeg/ffmpeg.d ffmpeg-0.6.1/ffmpeg.d

--- ffmpeg/ffmpeg.d 2011-01-08 09:20:01.910113764 -0800

+++ ffmpeg-0.6.1/ffmpeg.d 2011-01-07 06:54:42.350912495 -0800

@@ -1,18 +1,12 @@

 ffmpeg.o: ffmpeg.c config.h libavformat/avformat.h libavcodec/avcodec.h /

- libavcore/samplefmt.h libavutil/avutil.h libavutil/common.h /

- libavutil/attributes.h libavutil/avconfig.h libavutil/mem.h /

- libavutil/avutil.h libavutil/error.h libavutil/mathematics.h /

- libavutil/rational.h libavutil/intfloat_readwrite.h libavutil/log.h /

- libavutil/pixfmt.h libavutil/cpu.h libavcore/audioconvert.h /

- libavcore/avcore.h libavformat/avio.h libavutil/common.h libavutil/log.h /

+ libavutil/avutil.h libavutil/common.h libavutil/attributes.h /

+ libavutil/mem.h libavutil/error.h libavutil/avutil.h /

+ libavutil/mathematics.h libavutil/rational.h /

+ libavutil/intfloat_readwrite.h libavutil/log.h libavutil/pixfmt.h /

+ libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

  libavdevice/avdevice.h libswscale/swscale.h libavcodec/opt.h /

- libavutil/rational.h libavcodec/avcodec.h libavutil/opt.h /

- libavcodec/audioconvert.h libavcore/audioconvert.h /

- libavcore/parseutils.h libavcore/samplefmt.h libavutil/colorspace.h /

- libavutil/fifo.h libavutil/intreadwrite.h libavutil/attributes.h /

- libavutil/bswap.h libavutil/pixdesc.h libavutil/avstring.h /

- libavutil/libm.h config.h libavformat/os_support.h /

- libavfilter/avfilter.h libavcore/avcore.h libavfilter/avfiltergraph.h /

- libavfilter/avfilter.h libavfilter/vsrc_buffer.h cmdutils.h /

- libavcodec/avcodec.h libavutil/avassert.h libavutil/avutil.h /

- libavutil/log.h cmdutils_common_opts.h

+ libavutil/rational.h libavcodec/avcodec.h libavcodec/audioconvert.h /

+ libavcodec/colorspace.h libavutil/fifo.h libavutil/pixdesc.h /

+ libavutil/avstring.h libavutil/libm.h config.h libavutil/attributes.h /

+ libavformat/os_support.h cmdutils.h libavcodec/avcodec.h /

+ cmdutils_common_opts.h

Binary files ffmpeg/ffmpeg_g and ffmpeg-0.6.1/ffmpeg_g differ

Binary files ffmpeg/ffmpeg.o and ffmpeg-0.6.1/ffmpeg.o differ

Only in ffmpeg: ffplay

diff -u ffmpeg/ffplay.c ffmpeg-0.6.1/ffplay.c

--- ffmpeg/ffplay.c 2011-01-08 09:07:51.378864202 -0800

+++ ffmpeg-0.6.1/ffplay.c 2010-05-25 13:56:34.000000000 -0700

@@ -19,28 +19,24 @@

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  */

 

-#define _XOPEN_SOURCE 600

-

 #include "config.h"

 #include <inttypes.h>

 #include <math.h>

 #include <limits.h>

 #include "libavutil/avstring.h"

-#include "libavutil/colorspace.h"

 #include "libavutil/pixdesc.h"

-#include "libavcore/imgutils.h"

-#include "libavcore/parseutils.h"

-#include "libavcore/samplefmt.h"

 #include "libavformat/avformat.h"

 #include "libavdevice/avdevice.h"

 #include "libswscale/swscale.h"

 #include "libavcodec/audioconvert.h"

+#include "libavcodec/colorspace.h"

 #include "libavcodec/opt.h"

 #include "libavcodec/avfft.h"

 

 #if CONFIG_AVFILTER

 # include "libavfilter/avfilter.h"

 # include "libavfilter/avfiltergraph.h"

+# include "libavfilter/graphparser.h"

 #endif

 

 #include "cmdutils.h"

@@ -84,7 +80,9 @@

 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */

 #define SAMPLE_ARRAY_SIZE (2*65536)

 

+#if !CONFIG_AVFILTER

 static int sws_flags = SWS_BICUBIC;

+#endif

 

 typedef struct PacketQueue {

     AVPacketList *first_pkt, *last_pkt;

@@ -108,7 +106,7 @@

     enum PixelFormat pix_fmt;

 

 #if CONFIG_AVFILTER

-    AVFilterBufferRef *picref;

+    AVFilterPicRef *picref;

 #endif

 } VideoPicture;

 

@@ -163,7 +161,7 @@

     int audio_buf_index; /* in bytes */

     AVPacket audio_pkt_temp;

     AVPacket audio_pkt;

-    enum AVSampleFormat audio_src_fmt;

+    enum SampleFormat audio_src_fmt;

     AVAudioConvert *reformat_ctx;

 

     int show_audio; /* if true, display audio samples */

@@ -172,7 +170,6 @@

     int last_i_start;

     RDFTContext *rdft;

     int rdft_bits;

-    FFTSample *rdft_data;

     int xpos;

 

     SDL_Thread *subtitle_tid;

@@ -207,7 +204,10 @@

     char filename[1024];

     int width, height, xleft, ytop;

 

-    PtsCorrectionContext pts_ctx;

+    int64_t faulty_pts;

+    int64_t faulty_dts;

+    int64_t last_dts_for_fault_detection;

+    int64_t last_pts_for_fault_detection;

 

 #if CONFIG_AVFILTER

     AVFilterContext *out_video_filter;          ///<the last filter in the video chain

@@ -261,8 +261,6 @@

 static int error_concealment = 3;

 static int decoder_reorder_pts= -1;

 static int autoexit;

-static int exit_on_keydown;

-static int exit_on_mousedown;

 static int loop=1;

 static int framedrop=1;

 

@@ -678,7 +676,18 @@

 

 static void free_subpicture(SubPicture *sp)

 {

-    avsubtitle_free(&sp->sub);

+    int i;

+

+    for (i = 0; i < sp->sub.num_rects; i++)

+    {

+        av_freep(&sp->sub.rects[i]->pict.data[0]);

+        av_freep(&sp->sub.rects[i]->pict.data[1]);

+        av_freep(&sp->sub.rects[i]);

+    }

+

+    av_free(sp->sub.rects);

+

+    memset(&sp->sub, 0, sizeof(AVSubtitle));

 }

 

 static void video_image_display(VideoState *is)

@@ -694,10 +703,10 @@

     vp = &is->pictq[is->pictq_rindex];

     if (vp->bmp) {

 #if CONFIG_AVFILTER

-         if (vp->picref->video->pixel_aspect.num == 0)

+         if (vp->picref->pixel_aspect.num == 0)

              aspect_ratio = 0;

          else

-             aspect_ratio = av_q2d(vp->picref->video->pixel_aspect);

+             aspect_ratio = av_q2d(vp->picref->pixel_aspect);

 #else

 

         /* XXX: use variable in the frame */

@@ -910,15 +919,12 @@

         nb_display_channels= FFMIN(nb_display_channels, 2);

         if(rdft_bits != s->rdft_bits){

             av_rdft_end(s->rdft);

-            av_free(s->rdft_data);

             s->rdft = av_rdft_init(rdft_bits, DFT_R2C);

             s->rdft_bits= rdft_bits;

-            s->rdft_data= av_malloc(4*nb_freq*sizeof(*s->rdft_data));

         }

         {

-            FFTSample *data[2];

+            FFTSample data[2][2*nb_freq];

             for(ch = 0;ch < nb_display_channels; ch++) {

-                data[ch] = s->rdft_data + 2*nb_freq*ch;

                 i = i_start + ch;

                 for(x = 0; x < 2*nb_freq; x++) {

                     double w= (x-nb_freq)*(1.0/nb_freq);

@@ -933,8 +939,7 @@

             for(y=0; y<s->height; y++){

                 double w= 1/sqrt(nb_freq);

                 int a= sqrt(w*sqrt(data[0][2*y+0]*data[0][2*y+0] + data[0][2*y+1]*data[0][2*y+1]));

-                int b= (nb_display_channels == 2 ) ? sqrt(w*sqrt(data[1][2*y+0]*data[1][2*y+0]

-                       + data[1][2*y+1]*data[1][2*y+1])) : a;

+                int b= sqrt(w*sqrt(data[1][2*y+0]*data[1][2*y+0] + data[1][2*y+1]*data[1][2*y+1]));

                 a= FFMIN(a,255);

                 b= FFMIN(b,255);

                 fgcolor = SDL_MapRGB(screen->format, a, b, (a+b)/2);

@@ -1283,64 +1288,13 @@

             if (is->audio_st && is->video_st)

                 av_diff = get_audio_clock(is) - get_video_clock(is);

             printf("%7.2f A-V:%7.3f s:%3.1f aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64"   /r",

-                   get_master_clock(is), av_diff, FFMAX(is->skip_frames-1, 0), aqsize / 1024, vqsize / 1024, sqsize, is->pts_ctx.num_faulty_dts, is->pts_ctx.num_faulty_pts);

+                   get_master_clock(is), av_diff, FFMAX(is->skip_frames-1, 0), aqsize / 1024, vqsize / 1024, sqsize, is->faulty_dts, is->faulty_pts);

             fflush(stdout);

             last_time = cur_time;

         }

     }

 }

 

-static void stream_close(VideoState *is)

-{

-    VideoPicture *vp;

-    int i;

-    /* XXX: use a special url_shutdown call to abort parse cleanly */

-    is->abort_request = 1;

-    SDL_WaitThread(is->parse_tid, NULL);

-    SDL_WaitThread(is->refresh_tid, NULL);

-

-    /* free all pictures */

-    for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {

-        vp = &is->pictq[i];

-#if CONFIG_AVFILTER

-        if (vp->picref) {

-            avfilter_unref_buffer(vp->picref);

-            vp->picref = NULL;

-        }

-#endif

-        if (vp->bmp) {

-            SDL_FreeYUVOverlay(vp->bmp);

-            vp->bmp = NULL;

-        }

-    }

-    SDL_DestroyMutex(is->pictq_mutex);

-    SDL_DestroyCond(is->pictq_cond);

-    SDL_DestroyMutex(is->subpq_mutex);

-    SDL_DestroyCond(is->subpq_cond);

-#if !CONFIG_AVFILTER

-    if (is->img_convert_ctx)

-        sws_freeContext(is->img_convert_ctx);

-#endif

-    av_free(is);

-}

-

-static void do_exit(void)

-{

-    if (cur_stream) {

-        stream_close(cur_stream);

-        cur_stream = NULL;

-    }

-    uninit_opts();

-#if CONFIG_AVFILTER

-    avfilter_uninit();

-#endif

-    if (show_status)

-        printf("/n");

-    SDL_Quit();

-    av_log(NULL, AV_LOG_QUIET, "");

-    exit(0);

-}

-

 /* allocate a picture (needs to do that in main thread to avoid

    potential locking problems */

 static void alloc_picture(void *opaque)

@@ -1355,7 +1309,7 @@

 

 #if CONFIG_AVFILTER

     if (vp->picref)

-        avfilter_unref_buffer(vp->picref);

+        avfilter_unref_pic(vp->picref);

     vp->picref = NULL;

 

     vp->width   = is->out_video_filter->inputs[0]->w;

@@ -1370,14 +1324,6 @@

     vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,

                                    SDL_YV12_OVERLAY,

                                    screen);

-    if (!vp->bmp || vp->bmp->pitches[0] < vp->width) {

-        /* SDL allocates a buffer smaller than requested if the video

-         * overlay hardware is unable to support the requested size. */

-        fprintf(stderr, "Error: the video system does not support an image/n"

-                        "size of %dx%d pixels. Try using -lowres or -vf /"scale=w:h/"/n"

-                        "to reduce the image size./n", vp->width, vp->height );

-        do_exit();

-    }

 

     SDL_LockMutex(is->pictq_mutex);

     vp->allocated = 1;

@@ -1448,7 +1394,7 @@

         AVPicture pict;

 #if CONFIG_AVFILTER

         if(vp->picref)

-            avfilter_unref_buffer(vp->picref);

+            avfilter_unref_pic(vp->picref);

         vp->picref = src_frame->opaque;

 #endif

 

@@ -1558,7 +1504,8 @@

             is->video_current_pos= -1;

             SDL_UnlockMutex(is->pictq_mutex);

 

-            init_pts_correction(&is->pts_ctx);

+            is->last_dts_for_fault_detection=

+            is->last_pts_for_fault_detection= INT64_MIN;

             is->frame_last_pts= AV_NOPTS_VALUE;

             is->frame_last_delay = 0;

             is->frame_timer = (double)av_gettime() / 1000000.0;

@@ -1575,19 +1522,26 @@

                                     pkt);

 

         if (got_picture) {

-            if (decoder_reorder_pts == -1) {

-                *pts = guess_correct_pts(&is->pts_ctx, frame->reordered_opaque, pkt->dts);

-            } else if (decoder_reorder_pts) {

-                *pts = frame->reordered_opaque;

-            } else {

-                *pts = pkt->dts;

-            }

-

-            if (*pts == AV_NOPTS_VALUE) {

-                *pts = 0;

+            if(pkt->dts != AV_NOPTS_VALUE){

+                is->faulty_dts += pkt->dts <= is->last_dts_for_fault_detection;

+                is->last_dts_for_fault_detection= pkt->dts;

+            }

+            if(frame->reordered_opaque != AV_NOPTS_VALUE){

+                is->faulty_pts += frame->reordered_opaque <= is->last_pts_for_fault_detection;

+                is->last_pts_for_fault_detection= frame->reordered_opaque;

             }

         }

 

+        if(   (   decoder_reorder_pts==1

+               || (decoder_reorder_pts && is->faulty_pts<is->faulty_dts)

+               || pkt->dts == AV_NOPTS_VALUE)

+           && frame->reordered_opaque != AV_NOPTS_VALUE)

+            *pts= frame->reordered_opaque;

+        else if(pkt->dts != AV_NOPTS_VALUE)

+            *pts= pkt->dts;

+        else

+            *pts= 0;

+

 //            if (len1 < 0)

 //                break;

     if (got_picture){

@@ -1611,14 +1565,11 @@

 static int input_get_buffer(AVCodecContext *codec, AVFrame *pic)

 {

     AVFilterContext *ctx = codec->opaque;

-    AVFilterBufferRef  *ref;

+    AVFilterPicRef  *ref;

     int perms = AV_PERM_WRITE;

-    int i, w, h, stride[4];

+    int w, h, stride[4];

     unsigned edge;

 

-    if (codec->codec->capabilities & CODEC_CAP_NEG_LINESIZES)

-        perms |= AV_PERM_NEG_LINESIZES;

-

     if(pic->buffer_hints & FF_BUFFER_HINTS_VALID) {

         if(pic->buffer_hints & FF_BUFFER_HINTS_READABLE) perms |= AV_PERM_READ;

         if(pic->buffer_hints & FF_BUFFER_HINTS_PRESERVE) perms |= AV_PERM_PRESERVE;

@@ -1636,11 +1587,11 @@

     if(!(ref = avfilter_get_video_buffer(ctx->outputs[0], perms, w, h)))

         return -1;

 

-    ref->video->w = codec->width;

-    ref->video->h = codec->height;

-    for(i = 0; i < 4; i ++) {

-        unsigned hshift = (i == 1 || i == 2) ? av_pix_fmt_descriptors[ref->format].log2_chroma_w : 0;

-        unsigned vshift = (i == 1 || i == 2) ? av_pix_fmt_descriptors[ref->format].log2_chroma_h : 0;

+    ref->w = codec->width;

+    ref->h = codec->height;

+    for(int i = 0; i < 3; i ++) {

+        unsigned hshift = i == 0 ? 0 : av_pix_fmt_descriptors[ref->pic->format].log2_chroma_w;

+        unsigned vshift = i == 0 ? 0 : av_pix_fmt_descriptors[ref->pic->format].log2_chroma_h;

 

         if (ref->data[i]) {

             ref->data[i]    += (edge >> hshift) + ((edge * ref->linesize[i]) >> vshift);

@@ -1651,37 +1602,13 @@

     pic->opaque = ref;

     pic->age    = INT_MAX;

     pic->type   = FF_BUFFER_TYPE_USER;

-    pic->reordered_opaque = codec->reordered_opaque;

-    if(codec->pkt) pic->pkt_pts = codec->pkt->pts;

-    else           pic->pkt_pts = AV_NOPTS_VALUE;

     return 0;

 }

 

 static void input_release_buffer(AVCodecContext *codec, AVFrame *pic)

 {

     memset(pic->data, 0, sizeof(pic->data));

-    avfilter_unref_buffer(pic->opaque);

-}

-

-static int input_reget_buffer(AVCodecContext *codec, AVFrame *pic)

-{

-    AVFilterBufferRef *ref = pic->opaque;

-

-    if (pic->data[0] == NULL) {

-        pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;

-        return codec->get_buffer(codec, pic);

-    }

-

-    if ((codec->width != ref->video->w) || (codec->height != ref->video->h) ||

-        (codec->pix_fmt != ref->format)) {

-        av_log(codec, AV_LOG_ERROR, "Picture properties changed./n");

-        return -1;

-    }

-

-    pic->reordered_opaque = codec->reordered_opaque;

-    if(codec->pkt) pic->pkt_pts = codec->pkt->pts;

-    else           pic->pkt_pts = AV_NOPTS_VALUE;

-    return 0;

+    avfilter_unref_pic(pic->opaque);

 }

 

 static int input_init(AVFilterContext *ctx, const char *args, void *opaque)

@@ -1697,7 +1624,6 @@

         priv->use_dr1 = 1;

         codec->get_buffer     = input_get_buffer;

         codec->release_buffer = input_release_buffer;

-        codec->reget_buffer   = input_reget_buffer;

     }

 

     priv->frame = avcodec_alloc_frame();

@@ -1714,7 +1640,7 @@

 static int input_request_frame(AVFilterLink *link)

 {

     FilterPriv *priv = link->src->priv;

-    AVFilterBufferRef *picref;

+    AVFilterPicRef *picref;

     int64_t pts = 0;

     AVPacket pkt;

     int ret;

@@ -1725,18 +1651,17 @@

         return -1;

 

     if(priv->use_dr1) {

-        picref = avfilter_ref_buffer(priv->frame->opaque, ~0);

+        picref = avfilter_ref_pic(priv->frame->opaque, ~0);

     } else {

         picref = avfilter_get_video_buffer(link, AV_PERM_WRITE, link->w, link->h);

-        av_image_copy(picref->data, picref->linesize,

-                      priv->frame->data, priv->frame->linesize,

-                      picref->format, link->w, link->h);

+        av_picture_copy((AVPicture *)&picref->data, (AVPicture *)priv->frame,

+                        picref->pic->format, link->w, link->h);

     }

     av_free_packet(&pkt);

 

     picref->pts = pts;

     picref->pos = pkt.pos;

-    picref->video->pixel_aspect = priv->is->video_st->codec->sample_aspect_ratio;

+    picref->pixel_aspect = priv->is->video_st->codec->sample_aspect_ratio;

     avfilter_start_frame(link, picref);

     avfilter_draw_slice(link, 0, link->h, 1);

     avfilter_end_frame(link);

@@ -1762,7 +1687,6 @@

 

     link->w = c->width;

     link->h = c->height;

-    link->time_base = priv->is->video_st->time_base;

 

     return 0;

 }

@@ -1786,6 +1710,52 @@

                                   { .name = NULL }},

 };

 

+static void output_end_frame(AVFilterLink *link)

+{

+}

+

+static int output_query_formats(AVFilterContext *ctx)

+{

+    enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };

+

+    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));

+    return 0;

+}

+

+static int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,

+                                    int64_t *pts, int64_t *pos)

+{

+    AVFilterPicRef *pic;

+

+    if(avfilter_request_frame(ctx->inputs[0]))

+        return -1;

+    if(!(pic = ctx->inputs[0]->cur_pic))

+        return -1;

+    ctx->inputs[0]->cur_pic = NULL;

+

+    frame->opaque = pic;

+    *pts          = pic->pts;

+    *pos          = pic->pos;

+

+    memcpy(frame->data,     pic->data,     sizeof(frame->data));

+    memcpy(frame->linesize, pic->linesize, sizeof(frame->linesize));

+

+    return 1;

+}

+

+static AVFilter output_filter =

+{

+    .name      = "ffplay_output",

+

+    .query_formats = output_query_formats,

+

+    .inputs    = (AVFilterPad[]) {{ .name          = "default",

+                                    .type          = AVMEDIA_TYPE_VIDEO,

+                                    .end_frame     = output_end_frame,

+                                    .min_perms     = AV_PERM_READ, },

+                                  { .name = NULL }},

+    .outputs   = (AVFilterPad[]) {{ .name = NULL }},

+};

 #endif  /* CONFIG_AVFILTER */

 

 static int video_thread(void *arg)

@@ -1798,31 +1768,28 @@

 

 #if CONFIG_AVFILTER

     int64_t pos;

-    char sws_flags_str[128];

-    FFSinkContext ffsink_ctx = { .pix_fmt = PIX_FMT_YUV420P };

     AVFilterContext *filt_src = NULL, *filt_out = NULL;

-    AVFilterGraph *graph = avfilter_graph_alloc();

-    snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%d", sws_flags);

-    graph->scale_sws_opts = av_strdup(sws_flags_str);

-

-    if (avfilter_graph_create_filter(&filt_src, &input_filter, "src",

-                                     NULL, is, graph) < 0)

-        goto the_end;

-    if (avfilter_graph_create_filter(&filt_out, &ffsink, "out",

-                                     NULL, &ffsink_ctx, graph) < 0)

-        goto the_end;

+    AVFilterGraph *graph = av_mallocz(sizeof(AVFilterGraph));

+    graph->scale_sws_opts = av_strdup("sws_flags=bilinear");

+

+    if(!(filt_src = avfilter_open(&input_filter,  "src")))   goto the_end;

+    if(!(filt_out = avfilter_open(&output_filter, "out")))   goto the_end;

+

+    if(avfilter_init_filter(filt_src, NULL, is))             goto the_end;

+    if(avfilter_init_filter(filt_out, NULL, frame))          goto the_end;

+

 

     if(vfilters) {

         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));

         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));

 

         outputs->name    = av_strdup("in");

-        outputs->filter_ctx = filt_src;

+        outputs->filter  = filt_src;

         outputs->pad_idx = 0;

         outputs->next    = NULL;

 

         inputs->name    = av_strdup("out");

-        inputs->filter_ctx = filt_out;

+        inputs->filter  = filt_out;

         inputs->pad_idx = 0;

         inputs->next    = NULL;

 

@@ -1832,9 +1799,12 @@

     } else {

         if(avfilter_link(filt_src, 0, filt_out, 0) < 0)          goto the_end;

     }

+    avfilter_graph_add_filter(graph, filt_src);

+    avfilter_graph_add_filter(graph, filt_out);

 

-    if (avfilter_graph_config(graph, NULL) < 0)

-        goto the_end;

+    if(avfilter_graph_check_validity(graph, NULL))           goto the_end;

+    if(avfilter_graph_config_formats(graph, NULL))           goto the_end;

+    if(avfilter_graph_config_links(graph, NULL))             goto the_end;

 

     is->out_video_filter = filt_out;

 #endif

@@ -1842,28 +1812,11 @@

     for(;;) {

 #if !CONFIG_AVFILTER

         AVPacket pkt;

-#else

-        AVFilterBufferRef *picref;

-        AVRational tb;

 #endif

         while (is->paused && !is->videoq.abort_request)

             SDL_Delay(10);

 #if CONFIG_AVFILTER

-        ret = get_filtered_video_frame(filt_out, frame, &picref, &tb);

-        if (picref) {

-            pts_int = picref->pts;

-            pos     = picref->pos;

-            frame->opaque = picref;

-        }

-

-        if (av_cmp_q(tb, is->video_st->time_base)) {

-            int64_t pts1 = pts_int;

-            pts_int = av_rescale_q(pts_int, tb, is->video_st->time_base);

-            av_log(NULL, AV_LOG_DEBUG, "video_thread(): "

-                   "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"/n",

-                   tb.num, tb.den, pts1,

-                   is->video_st->time_base.num, is->video_st->time_base.den, pts_int);

-        }

+        ret = get_filtered_video_frame(filt_out, frame, &pts_int, &pos);

 #else

         ret = get_video_frame(is, frame, &pts_int, &pkt);

 #endif

@@ -1890,7 +1843,7 @@

     }

  the_end:

 #if CONFIG_AVFILTER

-    avfilter_graph_free(graph);

+    avfilter_graph_destroy(graph);

     av_freep(&graph);

 #endif

     av_free(frame);

@@ -2100,12 +2053,12 @@

             if (dec->sample_fmt != is->audio_src_fmt) {

                 if (is->reformat_ctx)

                     av_audio_convert_free(is->reformat_ctx);

-                is->reformat_ctx= av_audio_convert_alloc(AV_SAMPLE_FMT_S16, 1,

+                is->reformat_ctx= av_audio_convert_alloc(SAMPLE_FMT_S16, 1,

                                                          dec->sample_fmt, 1, NULL, 0);

                 if (!is->reformat_ctx) {

                     fprintf(stderr, "Cannot convert %s sample format to %s sample format/n",

-                        av_get_sample_fmt_name(dec->sample_fmt),

-                        av_get_sample_fmt_name(AV_SAMPLE_FMT_S16));

+                        avcodec_get_sample_fmt_name(dec->sample_fmt),

+                        avcodec_get_sample_fmt_name(SAMPLE_FMT_S16));

                         break;

                 }

                 is->audio_src_fmt= dec->sample_fmt;

@@ -2114,7 +2067,7 @@

             if (is->reformat_ctx) {

                 const void *ibuf[6]= {is->audio_buf1};

                 void *obuf[6]= {is->audio_buf2};

-                int istride[6]= {av_get_bits_per_sample_fmt(dec->sample_fmt)/8};

+                int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};

                 int ostride[6]= {2};

                 int len= data_size/istride[0];

                 if (av_audio_convert(is->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

@@ -2253,7 +2206,7 @@

     avctx->error_concealment= error_concealment;

     avcodec_thread_init(avctx, thread_count);

 

-    set_context_opts(avctx, avcodec_opts[avctx->codec_type], 0, codec);

+    set_context_opts(avctx, avcodec_opts[avctx->codec_type], 0);

 

     if (!codec ||

         avcodec_open(avctx, codec) < 0)

@@ -2273,7 +2226,7 @@

             return -1;

         }

         is->audio_hw_buf_size = spec.size;

-        is->audio_src_fmt= AV_SAMPLE_FMT_S16;

+        is->audio_src_fmt= SAMPLE_FMT_S16;

     }

 

     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;

@@ -2405,6 +2358,8 @@

     AVFormatContext *ic;

     int err, i, ret;

     int st_index[AVMEDIA_TYPE_NB];

+    int st_count[AVMEDIA_TYPE_NB]={0};

+    int st_best_packet_count[AVMEDIA_TYPE_NB];

     AVPacket pkt1, *pkt = &pkt1;

     AVFormatParameters params, *ap = &params;

     int eof=0;

@@ -2413,6 +2368,7 @@

     ic = avformat_alloc_context();

 

     memset(st_index, -1, sizeof(st_index));

+    memset(st_best_packet_count, -1, sizeof(st_best_packet_count));

     is->video_stream = -1;

     is->audio_stream = -1;

     is->subtitle_stream = -1;

@@ -2428,7 +2384,7 @@

     ap->time_base= (AVRational){1, 25};

     ap->pix_fmt = frame_pix_fmt;

 

-    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);

+    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);

 

     err = av_open_input_file(&ic, is->filename, is->iformat, 0, ap);

     if (err < 0) {

@@ -2468,26 +2424,33 @@

         }

     }

 

-    for (i = 0; i < ic->nb_streams; i++)

+    for(i = 0; i < ic->nb_streams; i++) {

+        AVStream *st= ic->streams[i];

+        AVCodecContext *avctx = st->codec;

         ic->streams[i]->discard = AVDISCARD_ALL;

-    if (!video_disable)

-        st_index[AVMEDIA_TYPE_VIDEO] =

-            av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,

-                                wanted_stream[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);

-    if (!audio_disable)

-        st_index[AVMEDIA_TYPE_AUDIO] =

-            av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,

-                                wanted_stream[AVMEDIA_TYPE_AUDIO],

-                                st_index[AVMEDIA_TYPE_VIDEO],

-                                NULL, 0);

-    if (!video_disable)

-        st_index[AVMEDIA_TYPE_SUBTITLE] =

-            av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,

-                                wanted_stream[AVMEDIA_TYPE_SUBTITLE],

-                                (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?

-                                 st_index[AVMEDIA_TYPE_AUDIO] :

-                                 st_index[AVMEDIA_TYPE_VIDEO]),

-                                NULL, 0);

+        if(avctx->codec_type >= (unsigned)AVMEDIA_TYPE_NB)

+            continue;

+        if(st_count[avctx->codec_type]++ != wanted_stream[avctx->codec_type] && wanted_stream[avctx->codec_type] >= 0)

+            continue;

+

+        if(st_best_packet_count[avctx->codec_type] >= st->codec_info_nb_frames)

+            continue;

+        st_best_packet_count[avctx->codec_type]= st->codec_info_nb_frames;

+

+        switch(avctx->codec_type) {

+        case AVMEDIA_TYPE_AUDIO:

+            if (!audio_disable)

+                st_index[AVMEDIA_TYPE_AUDIO] = i;

+            break;

+        case AVMEDIA_TYPE_VIDEO:

+        case AVMEDIA_TYPE_SUBTITLE:

+            if (!video_disable)

+                st_index[avctx->codec_type] = i;

+            break;

+        default:

+            break;

+        }

+    }

     if (show_status) {

         dump_format(ic, 0, is->filename, 0);

     }

@@ -2572,7 +2535,7 @@

             SDL_Delay(10);

             continue;

         }

-        if(eof) {

+        if(url_feof(ic->pb) || eof) {

             if(is->video_stream >= 0){

                 av_init_packet(pkt);

                 pkt->data=NULL;

@@ -2593,7 +2556,7 @@

         }

         ret = av_read_frame(ic, pkt);

         if (ret < 0) {

-            if (ret == AVERROR_EOF || url_feof(ic->pb))

+            if (ret == AVERROR_EOF)

                 eof=1;

             if (url_ferror(ic->pb))

                 break;

@@ -2677,6 +2640,40 @@

     return is;

 }

 

+static void stream_close(VideoState *is)

+{

+    VideoPicture *vp;

+    int i;

+    /* XXX: use a special url_shutdown call to abort parse cleanly */

+    is->abort_request = 1;

+    SDL_WaitThread(is->parse_tid, NULL);

+    SDL_WaitThread(is->refresh_tid, NULL);

+

+    /* free all pictures */

+    for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {

+        vp = &is->pictq[i];

+#if CONFIG_AVFILTER

+        if (vp->picref) {

+            avfilter_unref_pic(vp->picref);

+            vp->picref = NULL;

+        }

+#endif

+        if (vp->bmp) {

+            SDL_FreeYUVOverlay(vp->bmp);

+            vp->bmp = NULL;

+        }

+    }

+    SDL_DestroyMutex(is->pictq_mutex);

+    SDL_DestroyCond(is->pictq_cond);

+    SDL_DestroyMutex(is->subpq_mutex);

+    SDL_DestroyCond(is->subpq_cond);

+#if !CONFIG_AVFILTER

+    if (is->img_convert_ctx)

+        sws_freeContext(is->img_convert_ctx);

+#endif

+    av_free(is);

+}

+

 static void stream_cycle_channel(VideoState *is, int codec_type)

 {

     AVFormatContext *ic = is->ic;

@@ -2754,6 +2751,26 @@

     step = 1;

 }

 

+static void do_exit(void)

+{

+    int i;

+    if (cur_stream) {

+        stream_close(cur_stream);

+        cur_stream = NULL;

+    }

+    for (i = 0; i < AVMEDIA_TYPE_NB; i++)

+        av_free(avcodec_opts[i]);

+    av_free(avformat_opts);

+    av_free(sws_opts);

+#if CONFIG_AVFILTER

+    avfilter_uninit();

+#endif

+    if (show_status)

+        printf("/n");

+    SDL_Quit();

+    exit(0);

+}

+

 static void toggle_audio_display(void)

 {

     if (cur_stream) {

@@ -2777,10 +2794,6 @@

         SDL_WaitEvent(&event);

         switch(event.type) {

         case SDL_KEYDOWN:

-            if (exit_on_keydown) {

-                do_exit();

-                break;

-            }

             switch(event.key.keysym.sym) {

             case SDLK_ESCAPE:

             case SDLK_q:

@@ -2849,10 +2862,6 @@

             }

             break;

         case SDL_MOUSEBUTTONDOWN:

-            if (exit_on_mousedown) {

-                do_exit();

-                break;

-            }

         case SDL_MOUSEMOTION:

             if(event.type ==SDL_MOUSEBUTTONDOWN){

                 x= event.button.x;

@@ -2915,7 +2924,7 @@

 

 static void opt_frame_size(const char *arg)

 {

-    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {

+    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {

         fprintf(stderr, "Incorrect frame size/n");

         exit(1);

     }

@@ -3034,13 +3043,11 @@

     { "sync", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_sync}, "set audio-video sync. type (type=audio/video/ext)", "type" },

     { "threads", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },

     { "autoexit", OPT_BOOL | OPT_EXPERT, {(void*)&autoexit}, "exit at the end", "" },

-    { "exitonkeydown", OPT_BOOL | OPT_EXPERT, {(void*)&exit_on_keydown}, "exit on key down", "" },

-    { "exitonmousedown", OPT_BOOL | OPT_EXPERT, {(void*)&exit_on_mousedown}, "exit on mouse down", "" },

     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&loop}, "set number of times the playback shall be looped", "loop count" },

     { "framedrop", OPT_BOOL | OPT_EXPERT, {(void*)&framedrop}, "drop frames when cpu is too slow", "" },

     { "window_title", OPT_STRING | HAS_ARG, {(void*)&window_title}, "set window title", "window title" },

 #if CONFIG_AVFILTER

-    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },

+    { "vfilters", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },

 #endif

     { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, {(void*)&rdftspeed}, "rdft speed", "msecs" },

     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },

@@ -3056,23 +3063,11 @@

 

 static void show_help(void)

 {

-    av_log_set_callback(log_callback_help);

     show_usage();

     show_help_options(options, "Main options:/n",

                       OPT_EXPERT, 0);

     show_help_options(options, "/nAdvanced options:/n",

                       OPT_EXPERT, OPT_EXPERT);

-    printf("/n");

-    av_opt_show2(avcodec_opts[0], NULL,

-                 AV_OPT_FLAG_DECODING_PARAM, 0);

-    printf("/n");

-    av_opt_show2(avformat_opts, NULL,

-                 AV_OPT_FLAG_DECODING_PARAM, 0);

-#if !CONFIG_AVFILTER

-    printf("/n");

-    av_opt_show2(sws_opts, NULL,

-                 AV_OPT_FLAG_ENCODING_PARAM, 0);

-#endif

     printf("/nWhile playing:/n"

            "q, ESC              quit/n"

            "f                   toggle full screen/n"

@@ -3103,9 +3098,7 @@

 /* Called from the main */

 int main(int argc, char **argv)

 {

-    int flags;

-

-    av_log_set_flags(AV_LOG_SKIP_REPEATED);

+    int flags, i;

 

     /* register all codecs, demux and protocols */

     avcodec_register_all();

@@ -3117,7 +3110,13 @@

 #endif

     av_register_all();

 

-    init_opts();

+    for(i=0; i<AVMEDIA_TYPE_NB; i++){

+        avcodec_opts[i]= avcodec_alloc_context2(i);

+    }

+    avformat_opts = avformat_alloc_context();

+#if !CONFIG_AVFILTER

+    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);

+#endif

 

     show_banner();

 

Only in ffmpeg: ffplay.d

Only in ffmpeg: ffplay_g

Only in ffmpeg: ffplay.o

Common subdirectories: ffmpeg/ffpresets and ffmpeg-0.6.1/ffpresets

Binary files ffmpeg/ffprobe and ffmpeg-0.6.1/ffprobe differ

diff -u ffmpeg/ffprobe.c ffmpeg-0.6.1/ffprobe.c

--- ffmpeg/ffprobe.c 2011-01-08 09:07:51.382773533 -0800

+++ ffmpeg-0.6.1/ffprobe.c 2010-04-27 16:22:30.000000000 -0700

@@ -32,9 +32,9 @@

 const int program_birth_year = 2007;

 

 static int do_show_format  = 0;

-static int do_show_packets = 0;

 static int do_show_streams = 0;

 

+static int convert_tags                 = 0;

 static int show_value_unit              = 0;

 static int use_value_prefix             = 0;

 static int use_byte_value_binary_prefix = 0;

@@ -101,17 +101,6 @@

     return buf;

 }

 

-static char *ts_value_string (char *buf, int buf_size, int64_t ts)

-{

-    if (ts == AV_NOPTS_VALUE) {

-        snprintf(buf, buf_size, "N/A");

-    } else {

-        snprintf(buf, buf_size, "%"PRId64, ts);

-    }

-

-    return buf;

-}

-

 static const char *media_type_string(enum AVMediaType media_type)

 {

     switch (media_type) {

@@ -124,36 +113,6 @@

     }

 }

 

-static void show_packet(AVFormatContext *fmt_ctx, AVPacket *pkt)

-{

-    char val_str[128];

-    AVStream *st = fmt_ctx->streams[pkt->stream_index];

-

-    printf("[PACKET]/n");

-    printf("codec_type=%s/n"   , media_type_string(st->codec->codec_type));

-    printf("stream_index=%d/n" , pkt->stream_index);

-    printf("pts=%s/n"          , ts_value_string  (val_str, sizeof(val_str), pkt->pts));

-    printf("pts_time=%s/n"     , time_value_string(val_str, sizeof(val_str), pkt->pts, &st->time_base));

-    printf("dts=%s/n"          , ts_value_string  (val_str, sizeof(val_str), pkt->dts));

-    printf("dts_time=%s/n"     , time_value_string(val_str, sizeof(val_str), pkt->dts, &st->time_base));

-    printf("duration=%s/n"     , ts_value_string  (val_str, sizeof(val_str), pkt->duration));

-    printf("duration_time=%s/n", time_value_string(val_str, sizeof(val_str), pkt->duration, &st->time_base));

-    printf("size=%s/n"         , value_string     (val_str, sizeof(val_str), pkt->size, unit_byte_str));

-    printf("pos=%"PRId64"/n"   , pkt->pos);

-    printf("flags=%c/n"        , pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_');

-    printf("[/PACKET]/n");

-}

-

-static void show_packets(AVFormatContext *fmt_ctx)

-{

-    AVPacket pkt;

-

-    av_init_packet(&pkt);

-

-    while (!av_read_frame(fmt_ctx, &pkt))

-        show_packet(fmt_ctx, &pkt);

-}

-

 static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)

 {

     AVStream *stream = fmt_ctx->streams[stream_idx];

@@ -161,6 +120,7 @@

     AVCodec *dec;

     char val_str[128];

     AVMetadataTag *tag = NULL;

+    char a, b, c, d;

     AVRational display_aspect_ratio;

 

     printf("[STREAM]/n");

@@ -179,9 +139,16 @@

         printf("codec_time_base=%d/%d/n", dec_ctx->time_base.num, dec_ctx->time_base.den);

 

         /* print AVI/FourCC tag */

-        av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);

-        printf("codec_tag_string=%s/n", val_str);

-        printf("codec_tag=0x%04x/n", dec_ctx->codec_tag);

+        a = dec_ctx->codec_tag     & 0xff;

+        b = dec_ctx->codec_tag>>8  & 0xff;

+        c = dec_ctx->codec_tag>>16 & 0xff;

+        d = dec_ctx->codec_tag>>24 & 0xff;

+        printf("codec_tag_string=");

+        if (isprint(a)) printf("%c", a); else printf("[%d]", a);

+        if (isprint(b)) printf("%c", b); else printf("[%d]", b);

+        if (isprint(c)) printf("%c", c); else printf("[%d]", c);

+        if (isprint(d)) printf("%c", d); else printf("[%d]", d);

+        printf("/ncodec_tag=0x%04x/n", dec_ctx->codec_tag);

 

         switch (dec_ctx->codec_type) {

         case AVMEDIA_TYPE_VIDEO:

@@ -219,6 +186,8 @@

     printf("r_frame_rate=%d/%d/n",         stream->r_frame_rate.num,   stream->r_frame_rate.den);

     printf("avg_frame_rate=%d/%d/n",       stream->avg_frame_rate.num, stream->avg_frame_rate.den);

     printf("time_base=%d/%d/n",            stream->time_base.num,      stream->time_base.den);

+    if (stream->language[0])

+        printf("language=%s/n",            stream->language);

     printf("start_time=%s/n",   time_value_string(val_str, sizeof(val_str), stream->start_time,

                                                   &stream->time_base));

     printf("duration=%s/n",     time_value_string(val_str, sizeof(val_str), stream->duration,

@@ -252,6 +221,8 @@

     printf("bit_rate=%s/n",         value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate,

                                                  unit_bit_per_second_str));

 

+    if (convert_tags)

+        av_metadata_conv(fmt_ctx, NULL, fmt_ctx->iformat->metadata_conv);

     while ((tag = av_metadata_get(fmt_ctx->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))

         printf("TAG:%s=%s/n", tag->key, tag->value);

 

@@ -264,7 +235,6 @@

     AVFormatContext *fmt_ctx;

 

     fmt_ctx = avformat_alloc_context();

-    set_context_opts(fmt_ctx, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);

 

     if ((err = av_open_input_file(&fmt_ctx, filename, iformat, 0, NULL)) < 0) {

         print_error(filename, err);

@@ -305,9 +275,6 @@

     if ((ret = open_input_file(&fmt_ctx, filename)))

         return ret;

 

-    if (do_show_packets)

-        show_packets(fmt_ctx);

-

     if (do_show_streams)

         for (i = 0; i < fmt_ctx->nb_streams; i++)

             show_stream(fmt_ctx, i);

@@ -349,12 +316,9 @@

 

 static void show_help(void)

 {

-    av_log_set_callback(log_callback_help);

     show_usage();

     show_help_options(options, "Main options:/n", 0, 0);

     printf("/n");

-    av_opt_show2(avformat_opts, NULL,

-                 AV_OPT_FLAG_DECODING_PARAM, 0);

 }

 

 static void opt_pretty(void)

@@ -367,6 +331,7 @@

 

 static const OptionDef options[] = {

 #include "cmdutils_common_opts.h"

+    { "convert_tags", OPT_BOOL, {(void*)&convert_tags}, "convert tag names to the FFmpeg generic tag names" },

     { "f", HAS_ARG, {(void*)opt_format}, "force format", "format" },

     { "unit", OPT_BOOL, {(void*)&show_value_unit}, "show unit of the displayed values" },

     { "prefix", OPT_BOOL, {(void*)&use_value_prefix}, "use SI prefixes for the displayed values" },

@@ -377,23 +342,17 @@

     { "pretty", 0, {(void*)&opt_pretty},

       "prettify the format of displayed values, make it more human readable" },

     { "show_format",  OPT_BOOL, {(void*)&do_show_format} , "show format/container info" },

-    { "show_packets", OPT_BOOL, {(void*)&do_show_packets}, "show packets info" },

     { "show_streams", OPT_BOOL, {(void*)&do_show_streams}, "show streams info" },

-    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },

     { NULL, },

 };

 

 int main(int argc, char **argv)

 {

-    int ret;

-

     av_register_all();

 #if CONFIG_AVDEVICE

     avdevice_register_all();

 #endif

 

-    avformat_opts = avformat_alloc_context();

-

     show_banner();

     parse_options(argc, argv, options, opt_input_file);

 

@@ -404,9 +363,5 @@

         exit(1);

     }

 

-    ret = probe_file(input_filename);

-

-    av_free(avformat_opts);

-

-    return ret;

+    return probe_file(input_filename);

 }

diff -u ffmpeg/ffprobe.d ffmpeg-0.6.1/ffprobe.d

--- ffmpeg/ffprobe.d 2011-01-08 09:20:04.635880563 -0800

+++ ffmpeg-0.6.1/ffprobe.d 2011-01-07 06:54:45.881430418 -0800

@@ -1,11 +1,9 @@

 ffprobe.o: ffprobe.c config.h libavformat/avformat.h libavcodec/avcodec.h /

- libavcore/samplefmt.h libavutil/avutil.h libavutil/common.h /

- libavutil/attributes.h libavutil/avconfig.h libavutil/mem.h /

- libavutil/avutil.h libavutil/error.h libavutil/mathematics.h /

- libavutil/rational.h libavutil/intfloat_readwrite.h libavutil/log.h /

- libavutil/pixfmt.h libavutil/cpu.h libavcore/audioconvert.h /

- libavcore/avcore.h libavformat/avio.h libavutil/common.h libavutil/log.h /

+ libavutil/avutil.h libavutil/common.h libavutil/attributes.h /

+ libavutil/mem.h libavutil/error.h libavutil/avutil.h /

+ libavutil/mathematics.h libavutil/rational.h /

+ libavutil/intfloat_readwrite.h libavutil/log.h libavutil/pixfmt.h /

+ libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

  libavcodec/avcodec.h libavcodec/opt.h libavutil/rational.h /

- libavcodec/avcodec.h libavutil/opt.h libavutil/pixdesc.h /

- libavdevice/avdevice.h cmdutils.h libswscale/swscale.h /

- libavfilter/avfilter.h libavcore/avcore.h cmdutils_common_opts.h

+ libavcodec/avcodec.h libavutil/pixdesc.h libavdevice/avdevice.h /

+ cmdutils.h libswscale/swscale.h cmdutils_common_opts.h

Binary files ffmpeg/ffprobe_g and ffmpeg-0.6.1/ffprobe_g differ

Binary files ffmpeg/ffprobe.o and ffmpeg-0.6.1/ffprobe.o differ

Binary files ffmpeg/ffserver and ffmpeg-0.6.1/ffserver differ

diff -u ffmpeg/ffserver.c ffmpeg-0.6.1/ffserver.c

--- ffmpeg/ffserver.c 2011-01-08 09:07:51.382773533 -0800

+++ ffmpeg-0.6.1/ffserver.c 2010-05-29 07:41:26.000000000 -0700

@@ -36,7 +36,6 @@

 #include "libavutil/avstring.h"

 #include "libavutil/lfg.h"

 #include "libavutil/random_seed.h"

-#include "libavcore/parseutils.h"

 #include "libavcodec/opt.h"

 #include <stdarg.h>

 #include <unistd.h>

@@ -92,10 +91,6 @@

     "RTSP_SEND_PACKET",

 };

 

-#if !FF_API_MAX_STREAMS

-#define MAX_STREAMS 20

-#endif

-

 #define IOBUFFER_INIT_SIZE 8192

 

 /* timeouts are in ms */

@@ -745,7 +740,7 @@

 {

     char buffer[300];

     int len = snprintf(buffer, sizeof(buffer),

-                       "HTTP/1.0 503 Server too busy/r/n"

+                       "HTTP/1.0 200 Server too busy/r/n"

                        "Content-type: text/html/r/n"

                        "/r/n"

                        "<html><head><title>Too busy</title></head><body>/r/n"

@@ -1594,10 +1589,10 @@

     }

 

     if (c->post == 0 && max_bandwidth < current_bandwidth) {

-        c->http_error = 503;

+        c->http_error = 200;

         q = c->buffer;

         q += snprintf(q, c->buffer_size,

-                      "HTTP/1.0 503 Server too busy/r/n"

+                      "HTTP/1.0 200 Server too busy/r/n"

                       "Content-type: text/html/r/n"

                       "/r/n"

                       "<html><head><title>Too busy</title></head><body>/r/n"

@@ -2311,16 +2306,12 @@

         else {

             AVPacket pkt;

         redo:

-            ret = av_read_frame(c->fmt_in, &pkt);

-            if (ret < 0) {

-                if (c->stream->feed) {

+            if (av_read_frame(c->fmt_in, &pkt) < 0) {

+                if (c->stream->feed && c->stream->feed->feed_opened) {

                     /* if coming from feed, it means we reached the end of the

                        ffm file, so must wait for more data */

                     c->state = HTTPSTATE_WAIT_FEED;

                     return 1; /* state changed */

-                } else if (ret == AVERROR(EAGAIN)) {

-                    /* input not ready, come back later */

-                    return 0;

                 } else {

                     if (c->stream->loop) {

                         av_close_input_file(c->fmt_in);

@@ -2377,7 +2368,8 @@

                     if (c->is_packetized) {

                         /* compute send time and duration */

                         c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);

-                        c->cur_pts -= c->first_pts;

+                        if (ist->start_time != AV_NOPTS_VALUE)

+                            c->cur_pts -= av_rescale_q(ist->start_time, ist->time_base, AV_TIME_BASE_Q);

                         c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);

                         /* find RTP context */

                         c->packet_stream_index = pkt.stream_index;

@@ -2640,7 +2632,6 @@

                 ff_neterrno() != FF_NETERROR(EINTR))

                 /* error : close connection */

                 goto fail;

-            return 0;

         } else if (len == 0) {

             /* end of connection : close it */

             goto fail;

@@ -2753,7 +2744,14 @@

             for (i = 0; i < s->nb_streams; i++) {

                 AVStream *fst = feed->streams[i];

                 AVStream *st = s->streams[i];

-                avcodec_copy_context(fst->codec, st->codec);

+                memcpy(fst->codec, st->codec, sizeof(AVCodecContext));

+                if (fst->codec->extradata_size) {

+                    fst->codec->extradata = av_malloc(fst->codec->extradata_size);

+                    if (!fst->codec->extradata)

+                        goto fail;

+                    memcpy(fst->codec->extradata, st->codec->extradata,

+                           fst->codec->extradata_size);

+                }

             }

 

             av_close_input_stream(s);

@@ -2782,7 +2780,7 @@

 {

     const char *str;

     time_t ti;

-    struct tm *tm;

+    char *p;

     char buf2[32];

 

     switch(error_number) {

@@ -2829,8 +2827,11 @@

 

     /* output GMT time */

     ti = time(NULL);

-    tm = gmtime(&ti);

-    strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);

+    p = ctime(&ti);

+    strcpy(buf2, p);

+    p = buf2 + strlen(p) - 1;

+    if (*p == '/n')

+        *p = '/0';

     url_fprintf(c->pb, "Date: %s GMT/r/n", buf2);

 }

 

@@ -2895,7 +2896,7 @@

             len = sizeof(line) - 1;

         memcpy(line, p, len);

         line[len] = '/0';

-        ff_rtsp_parse_line(header, line, NULL, NULL);

+        ff_rtsp_parse_line(header, line, NULL);

         p = p1 + 1;

     }

 

@@ -2934,7 +2935,7 @@

                                    struct in_addr my_ip)

 {

     AVFormatContext *avc;

-    AVStream *avs = NULL;

+    AVStream avs[MAX_STREAMS];

     int i;

 

     avc =  avformat_alloc_context();

@@ -2952,29 +2953,14 @@

         snprintf(avc->filename, 1024, "rtp://0.0.0.0");

     }

 

-#if !FF_API_MAX_STREAMS

-    if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||

-        !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))

-        goto sdp_done;

-#endif

-    if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||

-        !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))

-        goto sdp_done;

-

     for(i = 0; i < stream->nb_streams; i++) {

         avc->streams[i] = &avs[i];

         avc->streams[i]->codec = stream->streams[i]->codec;

     }

     *pbuffer = av_mallocz(2048);

     avf_sdp_create(&avc, 1, *pbuffer, 2048);

-

- sdp_done:

-#if !FF_API_MAX_STREAMS

-    av_free(avc->streams);

-#endif

     av_metadata_free(&avc->metadata);

     av_free(avc);

-    av_free(avs);

 

     return strlen(*pbuffer);

 }

@@ -2998,7 +2984,7 @@

     struct sockaddr_in my_addr;

 

     /* find which url is asked */

-    av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

+    ff_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

     path = path1;

     if (*path == '/')

         path++;

@@ -3075,7 +3061,7 @@

     RTSPActionServerSetup setup;

 

     /* find which url is asked */

-    av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

+    ff_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

     path = path1;

     if (*path == '/')

         path++;

@@ -3218,7 +3204,7 @@

         return NULL;

 

     /* find which url is asked */

-    av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

+    ff_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);

     path = path1;

     if (*path == '/')

         path++;

@@ -3497,7 +3483,6 @@

     fst->priv_data = av_mallocz(sizeof(FeedData));

     fst->index = stream->nb_streams;

     av_set_pts_info(fst, 33, 1, 90000);

-    fst->sample_aspect_ratio = (AVRational){0,1};

     stream->streams[stream->nb_streams++] = fst;

     return fst;

 }

@@ -3878,8 +3863,7 @@

             av->nsse_weight = 8;

 

         av->frame_skip_cmp = FF_CMP_DCTMAX;

-        if (!av->me_method)

-            av->me_method = ME_EPZS;

+        av->me_method = ME_EPZS;

         av->rc_buffer_aggressivity = 1.0;

 

         if (!av->rc_eq)

@@ -3967,49 +3951,6 @@

     return ret;

 }

 

-static int ffserver_opt_preset(const char *arg,

-                       AVCodecContext *avctx, int type,

-                       enum CodecID *audio_id, enum CodecID *video_id)

-{

-    FILE *f=NULL;

-    char filename[1000], tmp[1000], tmp2[1000], line[1000];

-    int ret = 0;

-    AVCodec *codec = avcodec_find_encoder(avctx->codec_id);

-

-    if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,

-                              codec ? codec->name : NULL))) {

-        fprintf(stderr, "File for preset '%s' not found/n", arg);

-        return 1;

-    }

-

-    while(!feof(f)){

-        int e= fscanf(f, "%999[^/n]/n", line) - 1;

-        if(line[0] == '#' && !e)

-            continue;

-        e|= sscanf(line, "%999[^=]=%999[^/n]/n", tmp, tmp2) - 2;

-        if(e){

-            fprintf(stderr, "%s: Invalid syntax: '%s'/n", filename, line);

-            ret = 1;

-            break;

-        }

-        if(!strcmp(tmp, "acodec")){

-            *audio_id = opt_audio_codec(tmp2);

-        }else if(!strcmp(tmp, "vcodec")){

-            *video_id = opt_video_codec(tmp2);

-        }else if(!strcmp(tmp, "scodec")){

-            /* opt_subtitle_codec(tmp2); */

-        }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){

-            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'/n", filename, line, tmp, tmp2);

-            ret = 1;

-            break;

-        }

-    }

-

-    fclose(f);

-

-    return ret;

-}

-

 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,

                                              const char *mime_type)

 {

@@ -4360,7 +4301,7 @@

         } else if (!strcasecmp(cmd, "AudioBitRate")) {

             get_arg(arg, sizeof(arg), &p);

             if (stream)

-                audio_enc.bit_rate = lrintf(atof(arg) * 1000);

+                audio_enc.bit_rate = atoi(arg) * 1000;

         } else if (!strcasecmp(cmd, "AudioChannels")) {

             get_arg(arg, sizeof(arg), &p);

             if (stream)

@@ -4415,7 +4356,7 @@

         } else if (!strcasecmp(cmd, "VideoSize")) {

             get_arg(arg, sizeof(arg), &p);

             if (stream) {

-                av_parse_video_size(&video_enc.width, &video_enc.height, arg);

+                av_parse_video_frame_size(&video_enc.width, &video_enc.height, arg);

                 if ((video_enc.width % 16) != 0 ||

                     (video_enc.height % 16) != 0) {

                     ERROR("Image size must be a multiple of 16/n");

@@ -4425,7 +4366,7 @@

             get_arg(arg, sizeof(arg), &p);

             if (stream) {

                 AVRational frame_rate;

-                if (av_parse_video_rate(&frame_rate, arg) < 0) {

+                if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {

                     ERROR("Incorrect frame rate: %s/n", arg);

                 } else {

                     video_enc.time_base.num = frame_rate.den;

@@ -4464,23 +4405,6 @@

             if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {

                 ERROR("AVOption error: %s %s/n", arg, arg2);

             }

-        } else if (!strcasecmp(cmd, "AVPresetVideo") ||

-                   !strcasecmp(cmd, "AVPresetAudio")) {

-            AVCodecContext *avctx;

-            int type;

-            get_arg(arg, sizeof(arg), &p);

-            if (!strcasecmp(cmd, "AVPresetVideo")) {

-                avctx = &video_enc;

-                video_enc.codec_id = video_id;

-                type = AV_OPT_FLAG_VIDEO_PARAM;

-            } else {

-                avctx = &audio_enc;

-                audio_enc.codec_id = audio_id;

-                type = AV_OPT_FLAG_AUDIO_PARAM;

-            }

-            if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {

-                ERROR("AVPreset error: %s/n", arg);

-            }

         } else if (!strcasecmp(cmd, "VideoTag")) {

             get_arg(arg, sizeof(arg), &p);

             if ((strlen(arg) == 4) && stream)

@@ -4706,7 +4630,7 @@

 

     unsetenv("http_proxy");             /* Kill the http_proxy */

 

-    av_lfg_init(&random_state, av_get_random_seed());

+    av_lfg_init(&random_state, ff_random_get_seed());

 

     memset(&sigact, 0, sizeof(sigact));

     sigact.sa_handler = handle_child_exit;

diff -u ffmpeg/ffserver.d ffmpeg-0.6.1/ffserver.d

--- ffmpeg/ffserver.d 2011-01-08 09:20:07.118863384 -0800

+++ ffmpeg-0.6.1/ffserver.d 2011-01-07 06:54:49.366701331 -0800

@@ -1,16 +1,13 @@

 ffserver.o: ffserver.c config.h libavformat/avformat.h /

- libavcodec/avcodec.h libavcore/samplefmt.h libavutil/avutil.h /

- libavutil/common.h libavutil/attributes.h libavutil/avconfig.h /

- libavutil/mem.h libavutil/avutil.h libavutil/error.h /

- libavutil/mathematics.h libavutil/rational.h /

+ libavcodec/avcodec.h libavutil/avutil.h libavutil/common.h /

+ libavutil/attributes.h libavutil/mem.h libavutil/error.h /

+ libavutil/avutil.h libavutil/mathematics.h libavutil/rational.h /

  libavutil/intfloat_readwrite.h libavutil/log.h libavutil/pixfmt.h /

- libavutil/cpu.h libavcore/audioconvert.h libavcore/avcore.h /

- libavformat/avio.h libavutil/common.h libavutil/log.h /

+ libavutil/avconfig.h libavformat/avio.h libavutil/common.h /

  libavformat/network.h config.h libavformat/os_support.h /

  libavformat/rtpdec.h libavformat/avformat.h libavformat/rtp.h /

  libavformat/rtsp.h libavformat/rtspcodes.h libavformat/rtpdec.h /

  libavformat/network.h libavformat/httpauth.h libavutil/avstring.h /

- libavutil/lfg.h libavutil/random_seed.h libavcore/parseutils.h /

- libavutil/rational.h libavcodec/opt.h libavcodec/avcodec.h /

- libavutil/opt.h cmdutils.h libavcodec/avcodec.h libswscale/swscale.h /

- libavfilter/avfilter.h libavcore/avcore.h cmdutils_common_opts.h

+ libavutil/lfg.h libavutil/random_seed.h libavcodec/opt.h /

+ libavutil/rational.h libavcodec/avcodec.h cmdutils.h /

+ libavcodec/avcodec.h libswscale/swscale.h cmdutils_common_opts.h

Binary files ffmpeg/ffserver_g and ffmpeg-0.6.1/ffserver_g differ

Binary files ffmpeg/ffserver.o and ffmpeg-0.6.1/ffserver.o differ

Common subdirectories: ffmpeg/libavcodec and ffmpeg-0.6.1/libavcodec

Only in ffmpeg: libavcore

Common subdirectories: ffmpeg/libavdevice and ffmpeg-0.6.1/libavdevice

Common subdirectories: ffmpeg/libavfilter and ffmpeg-0.6.1/libavfilter

Common subdirectories: ffmpeg/libavformat and ffmpeg-0.6.1/libavformat

Common subdirectories: ffmpeg/libavutil and ffmpeg-0.6.1/libavutil

Common subdirectories: ffmpeg/libpostproc and ffmpeg-0.6.1/libpostproc

Common subdirectories: ffmpeg/libswscale and ffmpeg-0.6.1/libswscale

diff -u ffmpeg/LICENSE ffmpeg-0.6.1/LICENSE

--- ffmpeg/LICENSE 2011-01-08 09:07:51.378864202 -0800

+++ ffmpeg-0.6.1/LICENSE 2010-06-05 06:58:14.000000000 -0700

@@ -14,7 +14,11 @@

 Specifically, the GPL parts of FFmpeg are

 

 - libpostproc

+- optional MMX optimizations for YUV to RGB colorspace conversion in

+  libswscale/x86/yuv2rgb_template.c

 - optional x86 optimizations in the files

+  libavcodec/x86/h264_deblock_sse2.asm

+  libavcodec/x86/h264_idct_sse2.asm

   libavcodec/x86/idct_mmx.c

 - the X11 grabber in libavdevice/x11grab.c

 

diff -u ffmpeg/MAINTAINERS ffmpeg-0.6.1/MAINTAINERS

--- ffmpeg/MAINTAINERS 2011-01-08 09:07:51.387661608 -0800

+++ ffmpeg-0.6.1/MAINTAINERS 2010-04-30 14:43:18.000000000 -0700

@@ -21,9 +21,6 @@

 ffplay:

   ffplay.c                              Michael Niedermayer

 

-ffprobe:

-  ffprobe.c                             Stefano Sabatini

-

 ffserver:

   ffserver.c, ffserver.h                Baptiste Coudurier

 

@@ -37,7 +34,7 @@

 Miscellaneous Areas

 ===================

 

-documentation                           Mike Melanson

+documentation                           Mike Melanson, Diego Biurrun

 website                                 Robert Swain

 build system (configure,Makefiles)      Diego Biurrun, Mans Rullgard

 project server                          Diego Biurrun, Mans Rullgard

@@ -101,8 +98,6 @@

     simple_idct.c, simple_idct.h        Michael Niedermayer

   postprocessing:

     libpostproc/*                       Michael Niedermayer

-  table generation:

-    tableprint.c, tableprint.h          Reimar Doeffinger

 

 Codecs:

   4xm.c                                 Michael Niedermayer

@@ -114,7 +109,6 @@

   alacenc.c                             Jaikrishnan Menon

   alsdec.c                              Thilo Borgmann

   apedec.c                              Kostya Shishkov

-  ass*                                  Aurelien Jacobs

   asv*                                  Michael Niedermayer

   atrac3*                               Benjamin Larsson

   bgmc.c, bgmc.h                        Thilo Borgmann

@@ -137,7 +131,6 @@

   flac*                                 Justin Ruggles

   flashsv*                              Benjamin Larsson

   flicvideo.c                           Mike Melanson

-  g722.c                                Martin Storsjo

   g726.c                                Roman Shaposhnik

   gifdec.c                              Baptiste Coudurier

   h264*                                 Loren Merritt, Michael Niedermayer

@@ -159,8 +152,6 @@

   libschroedinger*                      David Conrad

   libspeexdec.c                         Justin Ruggles

   libtheoraenc.c                        David Conrad

-  libvorbis.c                           David Conrad

-  libxavs.c                             Stefan Gehrer

   libx264.c                             Mans Rullgard, Jason Garrett-Glaser

   loco.c                                Kostya Shishkov

   lzo.h, lzo.c                          Reimar Doeffinger

@@ -178,7 +169,6 @@

   nellymoserdec.c                       Benjamin Larsson

   nuv.c                                 Reimar Doeffinger

   pcx.c                                 Ivo van Poorten

-  pgssubdec.c                           Reimar Doeffinger

   ptx.c                                 Ivo van Poorten

   qcelp*                                Reynaldo H. Verdejo Pinochet

   qdm2.c, qdm2data.h                    Roberto Togni, Benjamin Larsson

@@ -198,7 +188,6 @@

   smc.c                                 Mike Melanson

   snow.c                                Michael Niedermayer, Loren Merritt

   sonic.c                               Alex Beregszaszi

-  srtdec.c                              Aurelien Jacobs

   sunrast.c                             Ivo van Poorten

   svq3.c                                Michael Niedermayer

   targa.c                               Kostya Shishkov

@@ -215,11 +204,10 @@

   vcr1.c                                Michael Niedermayer

   vmnc.c                                Kostya Shishkov

   vorbis_enc.c                          Oded Shimon

-  vorbis_dec.c                          Denes Balatoni, David Conrad

+  vorbis_dec.c                          Denes Balatoni

   vp3*                                  Mike Melanson

   vp5                                   Aurelien Jacobs

   vp6                                   Aurelien Jacobs

-  vp8                                   David Conrad, Jason Garrett-Glaser, Ronald Bultje

   vqavideo.c                            Mike Melanson

   wavpack.c                             Kostya Shishkov

   wmaprodec.c                           Sascha Sommer

@@ -263,10 +251,8 @@

   adtsenc.c                             Robert Swain

   aiff.c                                Baptiste Coudurier

   ape.c                                 Kostya Shishkov

-  ass*                                  Aurelien Jacobs

   avi*                                  Michael Niedermayer

   bink.c                                Peter Ross

-  caf*                                  Peter Ross

   crc.c                                 Michael Niedermayer

   daud.c                                Reimar Doeffinger

   dv.c                                  Roman Shaposhnik

@@ -279,14 +265,13 @@

   gxf.c                                 Reimar Doeffinger

   gxfenc.c                              Baptiste Coudurier

   idcin.c                               Mike Melanson

-  idroqdec.c                            Mike Melanson

+  idroq.c                               Mike Melanson

   iff.c                                 Jaikrishnan Menon

   ipmovie.c                             Mike Melanson

   img2.c                                Michael Niedermayer

   iss.c                                 Stefan Gehrer

   libnut.c                              Oded Shimon

   lmlm4.c                               Ivo van Poorten

-  lxfdec.c                              Tomas H盲rdin

   matroska.c                            Aurelien Jacobs

   matroskadec.c                         Aurelien Jacobs

   matroskaenc.c                         David Conrad

@@ -307,7 +292,6 @@

   oggdec.c, oggdec.h                    David Conrad

   oggenc.c                              Baptiste Coudurier

   oggparse*.c                           David Conrad

-  oma.c                                 Maxim Poliakovski

   psxstr.c                              Mike Melanson

   pva.c                                 Ivo van Poorten

   r3d.c                                 Baptiste Coudurier

@@ -316,15 +300,14 @@

   rl2.c                                 Sascha Sommer

   rmdec.c, rmenc.c                      Ronald S. Bultje, Kostya Shishkov

   rtmp*                                 Kostya Shishkov

-  rtp.c, rtpenc.c                       Martin Storsjo

-  rtpdec_asf.*                          Ronald S. Bultje

-  rtpenc_mpv.*, rtpenc_aac.*            Martin Storsjo

+  rtp.c, rtpenc.c                       Luca Abeni

+  rtp_asf.*                             Ronald S. Bultje

+  rtp_mpv.*, rtp_aac.*                  Luca Abeni

   rtsp.c                                Luca Barbato

-  sdp.c                                 Martin Storsjo

+  sdp.c                                 Luca Abeni

   segafilm.c                            Mike Melanson

   siff.c                                Kostya Shishkov

   smacker.c                             Kostya Shishkov

-  srtdec.c                              Aurelien Jacobs

   swf.c                                 Baptiste Coudurier

   tta.c                                 Alex Beregszaszi

   txd.c                                 Ivo van Poorten

@@ -336,7 +319,6 @@

 

 Protocols:

   http.c                                Ronald S. Bultje

-  mms*.c                                Ronald S. Bultje

   udp.c                                 Luca Abeni

 

 

@@ -347,6 +329,7 @@

 ARM                                     Mans Rullgard

 AVR32                                   Mans Rullgard

 MIPS                                    Mans Rullgard

+BeOS                                    Francois Revol

 Mac OS X / PowerPC                      Romain Dolbeau, Guillaume Poirier

 Amiga / PowerPC                         Colin Ward

 Linux / PowerPC                         Luca Barbato

@@ -360,24 +343,17 @@

 GnuPG Fingerprints of maintainers and others who have svn write access

 ======================================================================

 

-Anton Khirnov                 6D0C 6625 56F8 65D1 E5F5 814B B50A 1241 C067 07AB

 Attila Kinali                 11F0 F9A6 A1D2 11F6 C745 D10C 6520 BCDD F2DF E765

 Baptiste Coudurier            8D77 134D 20CC 9220 201F C5DB 0AC9 325C 5C1A BAAA

-Ben Littler                   3EE3 3723 E560 3214 A8CD 4DEB 2CDB FCE7 768C 8D2C

 Benoit Fouet                  B22A 4F4F 43EF 636B BB66 FCDC 0023 AE1E 2985 49C8

 Daniel Verkamp                78A6 07ED 782C 653E C628 B8B9 F0EB 8DD8 2F0E 21C7

 Diego Biurrun                 8227 1E31 B6D9 4994 7427 E220 9CAE D6CC 4757 FCC5

 Jaikrishnan Menon             61A1 F09F 01C9 2D45 78E1 C862 25DC 8831 AF70 D368

-Justin Ruggles                3136 ECC0 C10D 6C04 5F43 CA29 FCBE CD2A 3787 1EBF

 Loren Merritt                 ABD9 08F4 C920 3F65 D8BE 35D7 1540 DAA7 060F 56DE

-Luca Barbato                  6677 4209 213C 8843 5B67 29E7 E84C 78C2 84E9 0E34

 Michael Niedermayer           9FF2 128B 147E F673 0BAD F133 611E C787 040B 0FAB

 Panagiotis Issaris            515C E262 10A8 FDCE 5481 7B9C 3AD7 D9A5 071D B3A9

 Peter Ross                    A907 E02F A6E5 0CD2 34CD 20D2 6760 79C5 AC40 DD6B

 Reimar D枚ffinger              C61D 16E5 9E2C D10C 8958 38A4 0899 A2B9 06D4 D9C7

 Reinhard Tartler              9300 5DC2 7E87 6C37 ED7B CA9A 9808 3544 9453 48A4

 Reynaldo H. Verdejo Pinochet  6E27 CD34 170C C78E 4D4F 5F40 C18E 077F 3114 452A

-Robert Swain                  EE7A 56EA 4A81 A7B5 2001 A521 67FA 362D A2FC 3E71

 Sascha Sommer                 38A0 F88B 868E 9D3A 97D4 D6A0 E823 706F 1E07 0D3C

-Stefano Sabatini              9A43 10F8 D32C D33C 48E7 C52C 5DF2 8E4D B2EE 066B

-Tomas H盲rdin                  D133 29CA 4EEC 9DB4 7076 F697 B04B 7403 3313 41FD

diff -u ffmpeg/Makefile ffmpeg-0.6.1/Makefile

--- ffmpeg/Makefile 2011-01-08 09:07:51.378864202 -0800

+++ ffmpeg-0.6.1/Makefile 2010-04-19 06:05:26.000000000 -0700

@@ -13,16 +13,13 @@

 PROGS_G     = $(addsuffix _g$(EXESUF), $(PROGS-yes))

 OBJS        = $(addsuffix .o,          $(PROGS-yes)) cmdutils.o

 MANPAGES    = $(addprefix doc/, $(addsuffix .1, $(PROGS-yes)))

-PODPAGES    = $(addprefix doc/, $(addsuffix .pod, $(PROGS-yes)))

-HTMLPAGES   = $(addprefix doc/, $(addsuffix .html, $(PROGS-yes)))

 TOOLS       = $(addprefix tools/, $(addsuffix $(EXESUF), cws2fws pktdumper probetest qt-faststart trasher))

-HOSTPROGS   = $(addprefix tests/, audiogen videogen rotozoom tiny_psnr base64)

+HOSTPROGS   = $(addprefix tests/, audiogen videogen rotozoom tiny_psnr)

 

 BASENAMES   = ffmpeg ffplay ffprobe ffserver

 ALLPROGS    = $(addsuffix   $(EXESUF), $(BASENAMES))

 ALLPROGS_G  = $(addsuffix _g$(EXESUF), $(BASENAMES))

 ALLMANPAGES = $(addsuffix .1, $(BASENAMES))

-ALLHTMLPAGES= $(addsuffix .html, $(BASENAMES))

 

 FFLIBS-$(CONFIG_AVDEVICE) += avdevice

 FFLIBS-$(CONFIG_AVFILTER) += avfilter

@@ -30,7 +27,6 @@

 FFLIBS-$(CONFIG_AVCODEC)  += avcodec

 FFLIBS-$(CONFIG_POSTPROC) += postproc

 FFLIBS-$(CONFIG_SWSCALE)  += swscale

-FFLIBS-$(CONFIG_AVCORE)   += avcore

 

 FFLIBS := avutil

 

@@ -58,12 +54,6 @@

  $(CP) $< $@

  $(STRIP) $@

 

-config.h: .config

-.config: $(wildcard $(FFLIBS:%=$(SRC_DIR)/lib%/all*.c))

- @-tput bold 2>/dev/null

- @-printf '/nWARNING: $(?F) newer than config.h, rerun configure/n/n'

- @-tput sgr0 2>/dev/null

-

 SUBDIR_VARS := OBJS FFLIBS CLEANFILES DIRS TESTPROGS EXAMPLES SKIPHEADERS /

                ALTIVEC-OBJS MMX-OBJS NEON-OBJS X86-OBJS YASM-OBJS-FFT YASM-OBJS /

                HOSTPROGS BUILT_HEADERS TESTOBJS ARCH_HEADERS

@@ -91,9 +81,9 @@

  $(LD) $(FF_LDFLAGS) -o $@ $< $(FF_EXTRALIBS)

 

 tools/%.o: tools/%.c

- $(CC) $(CPPFLAGS) $(CFLAGS) -c $(CC_O) $<

+ $(CC) $(CPPFLAGS) $(CFLAGS) $(CC_O) $<

 

-ffplay.o: CFLAGS += $(SDL_CFLAGS)

+ffplay.o ffplay.d: CFLAGS += $(SDL_CFLAGS)

 

 VERSION_SH  = $(SRC_PATH_BARE)/version.sh

 GIT_LOG     = $(SRC_PATH_BARE)/.git/logs/HEAD

@@ -111,22 +101,16 @@

 

 alltools: $(TOOLS)

 

-documentation: $(addprefix doc/, developer.html faq.html general.html libavfilter.html /

-                                 $(ALLHTMLPAGES) $(ALLMANPAGES))

-

-$(HTMLPAGES) $(PODPAGES): doc/fftools-common-opts.texi

-

-doc/ffmpeg.pod doc/ffmpeg.html: doc/bitstream_filters.texi doc/eval.texi doc/indevs.texi doc/filters.texi doc/outdevs.texi doc/protocols.texi doc/metadata.texi

-doc/ffplay.pod doc/ffplay.html: doc/eval.texi doc/indevs.texi doc/filters.texi doc/outdevs.texi doc/protocols.texi

-doc/ffprobe.pod doc/ffprobe.html: doc/indevs.texi doc/protocols.texi

-doc/libavfilter.html: doc/filters.texi

+documentation: $(addprefix doc/, developer.html faq.html ffmpeg-doc.html /

+                                 ffplay-doc.html ffprobe-doc.html ffserver-doc.html /

+                                 general.html libavfilter.html $(ALLMANPAGES))

 

 doc/%.html: TAG = HTML

 doc/%.html: doc/%.texi

  $(M)cd doc && texi2html -monolithic -number $(<:doc/%=%)

 

 doc/%.pod: TAG = POD

-doc/%.pod: doc/%.texi

+doc/%.pod: doc/%-doc.texi

  $(M)doc/texi2pod.pl $< $@

 

 doc/%.1: TAG = MAN

@@ -162,7 +146,7 @@

  $(RM) -r tests/vsynth1 tests/vsynth2 tests/data

  $(RM) $(addprefix tests/,$(CLEANSUFFIXES))

  $(RM) tests/seek_test$(EXESUF) tests/seek_test.o

- $(RM) $(addprefix tests/,$(addsuffix $(HOSTEXESUF),audiogen videogen rotozoom tiny_psnr base64))

+ $(RM) $(addprefix tests/,$(addsuffix $(HOSTEXESUF),audiogen videogen rotozoom tiny_psnr))

 

 clean:: testclean

  $(RM) $(ALLPROGS) $(ALLPROGS_G)

@@ -181,28 +165,157 @@

 

 check: test checkheaders

 

-fulltest test: codectest lavftest lavfitest seektest

+fulltest test: codectest lavftest seektest

 

 FFSERVER_REFFILE = $(SRC_PATH)/tests/ffserver.regression.ref

 SEEK_REFFILE     = $(SRC_PATH)/tests/seek.regression.ref

 

-codectest: fate-codec

-lavftest:  fate-lavf

-lavfitest: fate-lavfi

-seektest:  fate-seek

-

-AREF = tests/data/acodec.ref.wav

-VREF = tests/data/vsynth1.ref.yuv

-REFS = $(AREF) $(VREF)

-

-$(REFS): TAG = GEN

-

-$(VREF): ffmpeg$(EXESUF) tests/vsynth1/00.pgm tests/vsynth2/00.pgm

- $(M)$(SRC_PATH)/tests/codec-regression.sh vref vsynth1 tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

- $(Q)$(SRC_PATH)/tests/codec-regression.sh vref vsynth2 tests/vsynth2 "$(TARGET_EXEC)" "$(TARGET_PATH)"

+ENCDEC = $(and $(CONFIG_$(1)_ENCODER),$(CONFIG_$(1)_DECODER))

+MUXDEM = $(and $(CONFIG_$(1)_MUXER),$(CONFIG_$(or $(2),$(1))_DEMUXER))

+

+VCODEC_TESTS =

+VCODEC_TESTS-$(call ENCDEC,ASV1)             += asv1

+VCODEC_TESTS-$(call ENCDEC,ASV2)             += asv2

+VCODEC_TESTS-$(call ENCDEC,DNXHD)            += dnxhd_1080i dnxhd_720p dnxhd_720p_rd

+VCODEC_TESTS-$(call ENCDEC,DVVIDEO)          += dv dv50

+VCODEC_TESTS-$(call ENCDEC,FFV1)             += ffv1

+VCODEC_TESTS-$(call ENCDEC,FLASHSV)          += flashsv

+VCODEC_TESTS-$(call ENCDEC,FLV)              += flv

+VCODEC_TESTS-$(call ENCDEC,H261)             += h261

+VCODEC_TESTS-$(call ENCDEC,H263)             += h263 h263p

+VCODEC_TESTS-$(call ENCDEC,HUFFYUV)          += huffyuv

+VCODEC_TESTS-$(call ENCDEC,JPEGLS)           += jpegls

+VCODEC_TESTS-$(call ENCDEC,MJPEG)            += mjpeg ljpeg

+VCODEC_TESTS-$(call ENCDEC,MPEG1VIDEO)       += mpeg mpeg1b

+VCODEC_TESTS-$(call ENCDEC,MPEG2VIDEO)       += mpeg2 mpeg2thread

+VCODEC_TESTS-$(call ENCDEC,MPEG4)            += mpeg4 mpeg4adv mpeg4nr mpeg4thread error rc

+VCODEC_TESTS-$(call ENCDEC,MSMPEG4V1)        += msmpeg4

+VCODEC_TESTS-$(call ENCDEC,MSMPEG4V2)        += msmpeg4v2

+VCODEC_TESTS-$(call ENCDEC,ROQ)              += roq

+VCODEC_TESTS-$(call ENCDEC,RV10)             += rv10

+VCODEC_TESTS-$(call ENCDEC,RV20)             += rv20

+VCODEC_TESTS-$(call ENCDEC,SNOW)             += snow snowll

+VCODEC_TESTS-$(call ENCDEC,SVQ1)             += svq1

+VCODEC_TESTS-$(call ENCDEC,WMV1)             += wmv1

+VCODEC_TESTS-$(call ENCDEC,WMV2)             += wmv2

+

+ACODEC_TESTS =

+ACODEC_TESTS-$(call ENCDEC,AC3)              += ac3

+ACODEC_TESTS-$(call ENCDEC,ADPCM_G726)       += g726

+ACODEC_TESTS-$(call ENCDEC,ADPCM_IMA_QT)     += adpcm_ima_qt

+ACODEC_TESTS-$(call ENCDEC,ADPCM_IMA_WAV)    += adpcm_ima_wav

+ACODEC_TESTS-$(call ENCDEC,ADPCM_MS)         += adpcm_ms

+ACODEC_TESTS-$(call ENCDEC,ADPCM_SWF)        += adpcm_swf

+ACODEC_TESTS-$(call ENCDEC,ADPCM_YAMAHA)     += adpcm_yam

+ACODEC_TESTS-$(call ENCDEC,ALAC)             += alac

+ACODEC_TESTS-$(call ENCDEC,FLAC)             += flac

+ACODEC_TESTS-$(call ENCDEC,MP2)              += mp2

+ACODEC_TESTS-$(call ENCDEC,PCM_S16LE)        += pcm         # fixme

+ACODEC_TESTS-$(call ENCDEC,WMAV1)            += wmav1

+ACODEC_TESTS-$(call ENCDEC,WMAV1)            += wmav2

+

+LAVF_TESTS =

+LAVF_TESTS-$(call MUXDEM,AIFF)               += aiff

+LAVF_TESTS-$(call MUXDEM,PCM_ALAW)           += alaw

+LAVF_TESTS-$(call MUXDEM,ASF)                += asf

+LAVF_TESTS-$(call MUXDEM,AU)                 += au

+LAVF_TESTS-$(call MUXDEM,AVI)                += avi

+LAVF_TESTS-$(call ENCDEC,BMP)                += bmp

+LAVF_TESTS-$(call MUXDEM,DV)                 += dv_fmt

+LAVF_TESTS-$(call MUXDEM,FFM)                += ffm

+LAVF_TESTS-$(call MUXDEM,FLV)                += flv_fmt

+LAVF_TESTS-$(call ENCDEC,GIF)                += gif

+LAVF_TESTS-$(call MUXDEM,GXF)                += gxf

+LAVF_TESTS-$(call ENCDEC,MJPEG)              += jpg

+LAVF_TESTS-$(call MUXDEM,MATROSKA)           += mkv

+LAVF_TESTS-$(call MUXDEM,MMF)                += mmf

+LAVF_TESTS-$(call MUXDEM,MOV)                += mov

+LAVF_TESTS-$(call MUXDEM,MPEG1SYSTEM,MPEGPS) += mpg

+LAVF_TESTS-$(call MUXDEM,PCM_MULAW)          += mulaw

+LAVF_TESTS-$(call MUXDEM,MXF)                += mxf

+LAVF_TESTS-$(call MUXDEM,NUT)                += nut

+LAVF_TESTS-$(call MUXDEM,OGG)                += ogg

+LAVF_TESTS-$(call ENCDEC,PBM)                += pbmpipe

+LAVF_TESTS-$(call ENCDEC,PCX)                += pcx

+LAVF_TESTS-$(call ENCDEC,PGM)                += pgm pgmpipe

+LAVF_TESTS-$(call MUXDEM,RAWVIDEO)           += pixfmt

+LAVF_TESTS-$(call ENCDEC,PPM)                += ppm ppmpipe

+LAVF_TESTS-$(call MUXDEM,RM)                 += rm

+LAVF_TESTS-$(call ENCDEC,SGI)                += sgi

+LAVF_TESTS-$(call MUXDEM,SWF)                += swf

+LAVF_TESTS-$(call ENCDEC,TARGA)              += tga

+LAVF_TESTS-$(call ENCDEC,TIFF)               += tiff

+LAVF_TESTS-$(call MUXDEM,MPEGTS)             += ts

+LAVF_TESTS-$(call MUXDEM,VOC)                += voc

+LAVF_TESTS-$(call MUXDEM,WAV)                += wav

+LAVF_TESTS-$(call MUXDEM,YUV4MPEGPIPE)       += yuv4mpeg

+

+LAVFI_TESTS =           /

+    crop                /

+    crop_scale          /

+    crop_scale_vflip    /

+    crop_vflip          /

+    null                /

+    scale200            /

+    scale500            /

+    vflip               /

+    vflip_crop          /

+    vflip_vflip         /

+

+ACODEC_TESTS := $(addprefix regtest-, $(ACODEC_TESTS) $(ACODEC_TESTS-yes))

+VCODEC_TESTS := $(addprefix regtest-, $(VCODEC_TESTS) $(VCODEC_TESTS-yes))

+LAVF_TESTS  := $(addprefix regtest-, $(LAVF_TESTS)  $(LAVF_TESTS-yes))

+LAVFI_TESTS := $(addprefix regtest-, $(LAVFI_TESTS) $(LAVFI_TESTS-yes))

+

+CODEC_TESTS = $(VCODEC_TESTS) $(ACODEC_TESTS)

+

+codectest: $(CODEC_TESTS)

+lavftest:  $(LAVF_TESTS)

+lavfitest: $(LAVFI_TESTS)

+

+$(ACODEC_TESTS): regtest-aref

+$(VCODEC_TESTS): regtest-vref

+$(LAVF_TESTS) $(LAVFI_TESTS): regtest-ref

+

+REFFILE = $(SRC_PATH)/tests/ref/$(1)/$(2:regtest-%=%)

+RESFILE = tests/data/$(2:regtest-%=%).$(1).regression

+

+define CODECTEST_CMD

+ $(SRC_PATH)/tests/codec-regression.sh $@ vsynth1 tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

+ $(SRC_PATH)/tests/codec-regression.sh $@ vsynth2 tests/vsynth2 "$(TARGET_EXEC)" "$(TARGET_PATH)"

+endef

+

+regtest-ref: regtest-aref regtest-vref

+

+regtest-vref: ffmpeg$(EXESUF) tests/vsynth1/00.pgm tests/vsynth2/00.pgm

+ $(CODECTEST_CMD)

+

+regtest-aref: ffmpeg$(EXESUF) tests/data/asynth1.sw

+ @$(SRC_PATH)/tests/codec-regression.sh $@ acodec tests/acodec "$(TARGET_EXEC)" "$(TARGET_PATH)"

 

-$(AREF): ffmpeg$(EXESUF) tests/data/asynth1.sw

- $(M)$(SRC_PATH)/tests/codec-regression.sh aref acodec tests/acodec "$(TARGET_EXEC)" "$(TARGET_PATH)"

+$(VCODEC_TESTS): tests/tiny_psnr$(HOSTEXESUF)

+ @echo "TEST VCODEC $(@:regtest-%=%)"

+ @$(CODECTEST_CMD)

+ @diff -u -w $(call REFFILE,vsynth1,$@) $(call RESFILE,vsynth1,$@)

+ @diff -u -w $(call REFFILE,vsynth2,$@) $(call RESFILE,vsynth2,$@)

+

+$(ACODEC_TESTS): tests/tiny_psnr$(HOSTEXESUF)

+ @echo "TEST ACODEC $(@:regtest-%=%)"

+ @$(SRC_PATH)/tests/codec-regression.sh $@ acodec tests/acodec "$(TARGET_EXEC)" "$(TARGET_PATH)"

+ @diff -u -w $(call REFFILE,acodec,$@) $(call RESFILE,acodec,$@)

+

+$(LAVF_TESTS):

+ @echo "TEST LAVF  $(@:regtest-%=%)"

+ @$(SRC_PATH)/tests/lavf-regression.sh $@ lavf tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

+ @diff -u -w $(call REFFILE,lavf,$@) $(call RESFILE,lavf,$@)

+

+$(LAVFI_TESTS):

+ @echo "TEST LAVFI $(@:regtest-%=%)"

+ @$(SRC_PATH)/tests/lavfi-regression.sh $@ lavfi tests/vsynth1 "$(TARGET_EXEC)" "$(TARGET_PATH)"

+ @diff -u -w $(call REFFILE,lavfi,$@) $(call RESFILE,lavfi,$@)

+

+seektest: codectest lavftest tests/seek_test$(EXESUF)

+ $(SRC_PATH)/tests/seek-regression.sh $(SRC_PATH) "$(TARGET_EXEC)" "$(TARGET_PATH)"

 

 ffservertest: ffserver$(EXESUF) tests/vsynth1/00.pgm tests/data/asynth1.sw

  @echo

@@ -212,86 +325,29 @@

  $(SRC_PATH)/tests/ffserver-regression.sh $(FFSERVER_REFFILE) $(SRC_PATH)/tests/ffserver.conf

 

 tests/vsynth1/00.pgm: tests/videogen$(HOSTEXESUF)

- @mkdir -p tests/vsynth1

- $(M)$(BUILD_ROOT)/$< 'tests/vsynth1/'

+ mkdir -p tests/vsynth1

+ $(BUILD_ROOT)/$< 'tests/vsynth1/'

 

 tests/vsynth2/00.pgm: tests/rotozoom$(HOSTEXESUF)

- @mkdir -p tests/vsynth2

- $(M)$(BUILD_ROOT)/$< 'tests/vsynth2/' $(SRC_PATH)/tests/lena.pnm

+ mkdir -p tests/vsynth2

+ $(BUILD_ROOT)/$< 'tests/vsynth2/' $(SRC_PATH)/tests/lena.pnm

 

 tests/data/asynth1.sw: tests/audiogen$(HOSTEXESUF)

- @mkdir -p tests/data

- $(M)$(BUILD_ROOT)/$< $@

-

-tests/data/asynth1.sw tests/vsynth%/00.pgm: TAG = GEN

+ mkdir -p tests/data

+ $(BUILD_ROOT)/$< $@

 

 tests/seek_test$(EXESUF): tests/seek_test.o $(FF_DEP_LIBS)

  $(LD) $(FF_LDFLAGS) -o $@ $< $(FF_EXTRALIBS)

 

-tools/lavfi-showfiltfmts$(EXESUF): tools/lavfi-showfiltfmts.o $(FF_DEP_LIBS)

- $(LD) $(FF_LDFLAGS) -o $@ $< $(FF_EXTRALIBS)

-

-include $(SRC_PATH_BARE)/tests/fate.mak

-include $(SRC_PATH_BARE)/tests/fate2.mak

-

-include $(SRC_PATH_BARE)/tests/fate/aac.mak

-include $(SRC_PATH_BARE)/tests/fate/als.mak

-include $(SRC_PATH_BARE)/tests/fate/fft.mak

-include $(SRC_PATH_BARE)/tests/fate/h264.mak

-include $(SRC_PATH_BARE)/tests/fate/mp3.mak

-include $(SRC_PATH_BARE)/tests/fate/vorbis.mak

-include $(SRC_PATH_BARE)/tests/fate/vp8.mak

-

-FATE_ACODEC  = $(ACODEC_TESTS:%=fate-acodec-%)

-FATE_VSYNTH1 = $(VCODEC_TESTS:%=fate-vsynth1-%)

-FATE_VSYNTH2 = $(VCODEC_TESTS:%=fate-vsynth2-%)

-FATE_VCODEC  = $(FATE_VSYNTH1) $(FATE_VSYNTH2)

-FATE_LAVF    = $(LAVF_TESTS:%=fate-lavf-%)

-FATE_LAVFI   = $(LAVFI_TESTS:%=fate-lavfi-%)

-FATE_SEEK    = $(SEEK_TESTS:seek_%=fate-seek-%)

-

-FATE = $(FATE_ACODEC)                                                   /

-       $(FATE_VCODEC)                                                   /

-       $(FATE_LAVF)                                                     /

-       $(FATE_LAVFI)                                                    /

-       $(FATE_SEEK)                                                     /

-

-$(FATE_ACODEC): $(AREF)

-$(FATE_VCODEC): $(VREF)

-$(FATE_LAVF):   $(REFS)

-$(FATE_LAVFI):  $(REFS) tools/lavfi-showfiltfmts$(EXESUF)

-$(FATE_SEEK):   fate-codec fate-lavf tests/seek_test$(EXESUF)

-

-$(FATE_ACODEC):  CMD = codectest acodec

-$(FATE_VSYNTH1): CMD = codectest vsynth1

-$(FATE_VSYNTH2): CMD = codectest vsynth2

-$(FATE_LAVF):    CMD = lavftest

-$(FATE_LAVFI):   CMD = lavfitest

-$(FATE_SEEK):    CMD = seektest

-

-fate-codec:  fate-acodec fate-vcodec

-fate-acodec: $(FATE_ACODEC)

-fate-vcodec: $(FATE_VCODEC)

-fate-lavf:   $(FATE_LAVF)

-fate-lavfi:  $(FATE_LAVFI)

-fate-seek:   $(FATE_SEEK)

-

 ifdef SAMPLES

-FATE += $(FATE_TESTS)

+include $(SRC_PATH_BARE)/tests/fate.mak

+fate: $(FATE_TESTS)

+$(FATE_TESTS): ffmpeg$(EXESUF)

+ @echo "TEST FATE   $(@:fate-%=%)"

+ @$(SRC_PATH)/tests/fate-run.sh $@ "$(SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)" '$(CMD)'

 else

-$(FATE_TESTS):

+fate:

  @echo "SAMPLES not specified, cannot run FATE"

 endif

 

-FATE_UTILS = base64 tiny_psnr

-

-fate: $(FATE)

-

-$(FATE): ffmpeg$(EXESUF) $(FATE_UTILS:%=tests/%$(HOSTEXESUF))

- @echo "TEST    $(@:fate-%=%)"

- $(Q)$(SRC_PATH)/tests/fate-run.sh $@ "$(SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)" '$(CMD)' '$(CMP)' '$(REF)' '$(FUZZ)'

-

-fate-list:

- @printf '%s/n' $(sort $(FATE))

-

-.PHONY: documentation *test regtest-* alltools check config

+.PHONY: documentation *test regtest-* zlib-error alltools check config

Only in ffmpeg-0.6.1: RELEASE

diff -u ffmpeg/subdir.mak ffmpeg-0.6.1/subdir.mak

--- ffmpeg/subdir.mak 2011-01-08 09:07:51.374711421 -0800

+++ ffmpeg-0.6.1/subdir.mak 2010-03-17 07:43:06.000000000 -0700

@@ -10,10 +10,10 @@

 all-$(CONFIG_STATIC): $(SUBDIR)$(LIBNAME)

 all-$(CONFIG_SHARED): $(SUBDIR)$(SLIBNAME)

 

-$(SUBDIR)%-test.o: $(SUBDIR)%-test.c

+$(SUBDIR)%-test.o: $(SUBDIR)%.c

  $(CC) $(CPPFLAGS) $(CFLAGS) -DTEST -c $(CC_O) $^

 

-$(SUBDIR)%-test.o: $(SUBDIR)%.c

+$(SUBDIR)%-test.o: $(SUBDIR)%-test.c

  $(CC) $(CPPFLAGS) $(CFLAGS) -DTEST -c $(CC_O) $^

 

 $(SUBDIR)x86/%.o: $(SUBDIR)x86/%.asm

Only in ffmpeg: .svn

Common subdirectories: ffmpeg/tests and ffmpeg-0.6.1/tests

Common subdirectories: ffmpeg/tools and ffmpeg-0.6.1/tools

Only in ffmpeg-0.6.1: VERSION

diff -u ffmpeg/version.h ffmpeg-0.6.1/version.h

--- ffmpeg/version.h 2011-01-08 09:15:11.993685042 -0800

+++ ffmpeg-0.6.1/version.h 2011-01-07 06:50:39.277718551 -0800

@@ -1 +1 @@

-#define FFMPEG_VERSION "SVN-r26268"

+#define FFMPEG_VERSION "0.6.1"

diff -u ffmpeg/version.sh ffmpeg-0.6.1/version.sh

--- ffmpeg/version.sh 2011-01-08 09:07:51.374711421 -0800

+++ ffmpeg-0.6.1/version.sh 2010-01-16 10:29:52.000000000 -0800

@@ -31,11 +31,6 @@

 

 test -n "$3" && version=$version-$3

 

-if [ -z "$2" ]; then

-    echo "$version"

-    exit

-fi

-

 NEW_REVISION="#define FFMPEG_VERSION /"$version/""

 OLD_REVISION=$(cat version.h 2> /dev/null)

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页