等风来不如迎风去

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 :

< - 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= 0; type++){

---

> for(type=0; type= 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: - []

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

---

> 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

< }

< 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

---

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 <

> #include

> #ifndef FAAD2_VERSION

> ok faad1

> #endif

> int main(void) { return 0; }

> EOF

> test $? = 0 && enable libfaad2

> else

> die "FAAD test failed."

> 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 <

< 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 , where is the value of

< # the FILE_VERSION_FILTER tag, and 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

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

---

> for(i=0;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

> 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

> 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

< 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; pinb_programs; pi++){

< AVProgram *p= f->programs[pi];

< if(p->id == opt_programid)

< for(si=0; sinb_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

> 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; pinb_programs; pi++){

> AVProgram *p= f->programs[pi];

> if(p->id == opt_programid)

> for(si=0; sinb_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

> 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

< 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_ptsfaulty_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

> 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

> 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 :

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

@@ -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 )

@@ -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= 0; type++){

+ for(type=0; type= 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

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: - []

* @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 <

@@ -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

+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

-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'

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

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 <

@@ -2455,12 +2316,28 @@

disabled static && LIBNAME=""

+if enabled_any libfaad libfaadbin ; then

+ if check_header faad.h; then

+ check_cc <

+#include

+#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 <

__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 " ; } ||

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 <

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

@@ -2654,12 +2513,6 @@

-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"

@@ -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

+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}"

if enabled sparc; then

echo "VIS enabled ${vis-no}"

+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 <

# 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 <

/* 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

-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 <

-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 <

/* 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 < $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 , where is the value of

-# the FILE_VERSION_FILTER tag, and 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 , where

# is the value of the INPUT_FILTER tag, and 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

@@ -81,7 +71,8 @@

#include "cmdutils.h"

-#include "libavutil/avassert.h"

+#undef NDEBUG

+#include

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;jnb_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;jnb_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

+ for(i=0;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

+ 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;inb_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

@@ -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

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

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

+ ost = av_mallocz(sizeof(AVOutputStream));

+ if (!ost)

+ goto fail;

+ ost_table[i] = ost;

+ }

n = 0;

for(k=0;k

os = output_files[k];

for(i=0;inb_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

- 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; pinb_programs; pi++){

- AVProgram *p= f->programs[pi];

- if(p->id == opt_programid)

- for(si=0; sinb_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

+ 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; pinb_programs; pi++){

+ AVProgram *p= f->programs[pi];

+ if(p->id == opt_programid)

+ for(si=0; sinb_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

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

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

- 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

@@ -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

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;inb_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

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

你可能感兴趣的:(linux菜鸟手记)