summaryrefslogtreecommitdiff
path: root/community
diff options
context:
space:
mode:
Diffstat (limited to 'community')
-rw-r--r--community/bullet/PKGBUILD8
-rw-r--r--community/dmenu/PKGBUILD6
-rw-r--r--community/dvdstyler/PKGBUILD13
-rw-r--r--community/dvdstyler/dvdstyler-ffmpeg.patch1915
-rw-r--r--community/pcb/PKGBUILD8
-rw-r--r--community/pigeonhole/PKGBUILD4
-rw-r--r--community/vnstat/PKGBUILD5
-rw-r--r--community/wxsvg/PKGBUILD27
8 files changed, 1946 insertions, 40 deletions
diff --git a/community/bullet/PKGBUILD b/community/bullet/PKGBUILD
index f62122878..d847b6037 100644
--- a/community/bullet/PKGBUILD
+++ b/community/bullet/PKGBUILD
@@ -1,10 +1,10 @@
-# $Id: PKGBUILD 45481 2011-04-22 06:49:32Z svenstaro $
+# $Id: PKGBUILD 55766 2011-09-19 23:58:08Z svenstaro $
# Maintainer: Sven-Hendrik Haase <sh@lutzhaase.com>
# Contributor: Christoph Zeiler <archNOSPAM_at_moonblade.dot.org>
pkgbase=bullet
pkgname=('bullet' 'bullet-docs')
-pkgver=2.78
+pkgver=2.79
pkgrel=1
pkgdesc="A 3D Collision Detection and Rigid Body Dynamics Library for games and animation"
arch=('i686' 'x86_64')
@@ -12,9 +12,9 @@ url="http://www.bulletphysics.com/Bullet/"
license=('custom:zlib')
depends=('freeglut')
makedepends=('cmake' 'doxygen' 'graphviz' 'ttf-dejavu')
-source=(http://bullet.googlecode.com/files/${pkgbase}-${pkgver}-r2387.tgz \
+source=(http://bullet.googlecode.com/files/${pkgbase}-${pkgver}-rev2440.tgz \
${pkgbase}.pc)
-md5sums=('3611456232f1c01dea8094213382d0b3'
+md5sums=('29d6f43964d8494f0366cd69e4883dd1'
'd1da06deba3b08b884d2212f6838905c')
build() {
diff --git a/community/dmenu/PKGBUILD b/community/dmenu/PKGBUILD
index a9dc8a15f..db7dc7373 100644
--- a/community/dmenu/PKGBUILD
+++ b/community/dmenu/PKGBUILD
@@ -1,11 +1,11 @@
-# $Id: PKGBUILD 52072 2011-07-19 21:43:36Z spupykin $
+# $Id: PKGBUILD 55762 2011-09-19 13:35:20Z ttopper $
# Maintainer: Sergej Pupykin <pupykin.s+arch@gmail.com>
# Maintainer: Thorsten Töpper <atsutane-tu@freethoughts.de>
# Contributor: Thayer Williams <thayer@archlinux.org>
# Contributor: Jeff 'codemac' Mickey <jeff@archlinux.org>
pkgname=dmenu
-pkgver=4.4
+pkgver=4.4.1
pkgrel=1
pkgdesc="A generic menu for X"
url="http://tools.suckless.org/dmenu/"
@@ -13,7 +13,7 @@ arch=('i686' 'x86_64')
license=('MIT')
depends=('sh' 'libxinerama')
source=("http://dl.suckless.org/tools/$pkgname-$pkgver.tar.gz")
-md5sums=('ae1902fc37716f739836fddce6123ebc')
+md5sums=('d18aaa9ac3265f92ec34a0df0cb6ebd4')
build(){
cd $srcdir/$pkgname-$pkgver
diff --git a/community/dvdstyler/PKGBUILD b/community/dvdstyler/PKGBUILD
index f42f4dcc0..de376ce18 100644
--- a/community/dvdstyler/PKGBUILD
+++ b/community/dvdstyler/PKGBUILD
@@ -1,23 +1,26 @@
-# $Id: PKGBUILD 45103 2011-04-16 14:58:57Z ebelanger $
+# $Id: PKGBUILD 55752 2011-09-19 04:58:47Z ebelanger $
# Contributor: Alexander Fehr <pizzapunk gmail com>
# Maintainer: Daniel J Griffiths <ghost1227@archlinux.us>
pkgname=dvdstyler
-pkgver=1.8.3
+pkgver=1.8.4.3
pkgrel=1
pkgdesc="Cross-platform DVD authoring application"
arch=('i686' 'x86_64')
url="http://www.dvdstyler.de/"
license=('GPL')
-depends=('cdrkit' 'dvdauthor' 'dvd+rw-tools' 'ffmpeg' 'gettext' 'libexif' 'wxgtk' 'wxsvg' 'xine-ui' 'mjpegtools' 'libgnomeui')
+depends=('cdrkit' 'dvdauthor' 'dvd+rw-tools' 'libexif' 'wxsvg' 'xine-ui' 'mjpegtools' 'libgnomeui')
makedepends=('zip' 'xmlto' 'docbook-xsl')
optdepends=('dvdisaster: ECC support')
options=('!makeflags')
-source=("http://downloads.sourceforge.net/dvdstyler/DVDStyler-${pkgver}.tar.bz2")
-md5sums=('69a6d0a920e780bbcf65e94041e58429')
+source=(http://downloads.sourceforge.net/dvdstyler/DVDStyler-${pkgver}.tar.bz2 dvdstyler-ffmpeg.patch)
+md5sums=('418de47c4e09a89a633b905af2a7d4fb'
+ '4f053158965b2be3ae26506470aeda58')
build() {
cd "${srcdir}/DVDStyler-${pkgver}"
+ patch -p1 -i "${srcdir}/dvdstyler-ffmpeg.patch"
+ sed -i 's/rmdir "$$t"//' docs/Makefile.in
./configure --prefix=/usr
make
}
diff --git a/community/dvdstyler/dvdstyler-ffmpeg.patch b/community/dvdstyler/dvdstyler-ffmpeg.patch
new file mode 100644
index 000000000..f2f56f6ff
--- /dev/null
+++ b/community/dvdstyler/dvdstyler-ffmpeg.patch
@@ -0,0 +1,1915 @@
+diff -Naur DVDStyler-1.8.4.3.orig/src/mediatrc_ffmpeg.cpp DVDStyler-1.8.4.3/src/mediatrc_ffmpeg.cpp
+--- DVDStyler-1.8.4.3.orig/src/mediatrc_ffmpeg.cpp 2011-05-15 09:23:34.000000000 -0400
++++ DVDStyler-1.8.4.3/src/mediatrc_ffmpeg.cpp 2011-09-18 18:13:03.000000000 -0400
+@@ -3,7 +3,7 @@
+ // Purpose: FFMPEG Media Transcoder
+ // Author: Alex Thuering
+ // Created: 26.04.2008
+-// RCS-ID: $Id: mediatrc_ffmpeg.cpp,v 1.33 2011/05/15 13:23:34 ntalex Exp $
++// RCS-ID: $Id: mediatrc_ffmpeg.cpp,v 1.34 2011/07/24 07:58:21 ntalex Exp $
+ // Copyright: (c) Alex Thuering
+ // Licence: GPL
+ /////////////////////////////////////////////////////////////////////////////
+@@ -17,21 +17,16 @@
+ #include <math.h>
+ #include <errno.h>
+ extern "C" {
+-#ifdef HAVE_FFMPEG_AVUTIL_H
+-#include <opt.h>
+-#include <swscale.h>
+-#include <avutil.h>
+-#include <fifo.h>
+-#include <avfilter.h>
+-#include <avfiltergraph.h>
+-#else
+-#include <libavcodec/opt.h>
+-#include <libswscale/swscale.h>
++#include <libavutil/opt.h>
+ #include <libavutil/avutil.h>
+ #include <libavutil/fifo.h>
++#include <libavutil/dict.h>
++#include <libavutil/pixdesc.h>
++#include <libswscale/swscale.h>
++#include <libavfilter/avcodec.h>
+ #include <libavfilter/avfilter.h>
+ #include <libavfilter/avfiltergraph.h>
+-#endif
++#include <libavfilter/vsink_buffer.h>
+ }
+
+ #define AUDIO_BUF_SIZE 50000
+@@ -48,101 +43,19 @@
+ #define INT64_MAX INT64_C(9223372036854775807)
+ #endif
+
+-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(52, 45, 0)
+-#define av_guess_format guess_format
+-#endif
+-
+-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52, 64, 0)
+-#define AVMediaType CodecType
+-#define AVMEDIA_TYPE_UNKNOWN CODEC_TYPE_UNKNOWN
+-#define AVMEDIA_TYPE_VIDEO CODEC_TYPE_VIDEO
+-#define AVMEDIA_TYPE_AUDIO CODEC_TYPE_AUDIO
+-#define AVMEDIA_TYPE_DATA CODEC_TYPE_DATA
+-#define AVMEDIA_TYPE_SUBTITLE CODEC_TYPE_SUBTITLE
+-#define AVMEDIA_TYPE_ATTACHMENT CODEC_TYPE_ATTACHMENT
+-#define AVMEDIA_TYPE_NB CODEC_TYPE_NB
++#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(53, 4, 0)
++#define AVIO_FLAG_WRITE AVIO_WRONLY
+ #endif
+
+ //////////////////////////// AVAudioConvert /////////////////////////////////
+-
+-struct AVAudioConvert {
+- int in_channels, out_channels;
+- int fmt_pair;
+-};
+-
+-AVAudioConvert *av_audio_convert_alloc(enum AVSampleFormat out_fmt, int out_channels,
+- enum AVSampleFormat in_fmt, int in_channels,
+- const float *matrix, int flags) {
+- AVAudioConvert *ctx;
+- if (in_channels != out_channels)
+- return NULL;
+- ctx = (AVAudioConvert*) av_malloc(sizeof(AVAudioConvert));
+- if (!ctx)
+- return NULL;
+- ctx->in_channels = in_channels;
+- ctx->out_channels = out_channels;
+- ctx->fmt_pair = out_fmt + AV_SAMPLE_FMT_NB * in_fmt;
+- return ctx;
+-}
+-
+-void av_audio_convert_free(AVAudioConvert *ctx) {
+- av_free(ctx);
+-}
+-
+-int av_audio_convert(AVAudioConvert *ctx,
+- void * const out[6], const int out_stride[6],
+- const void * const in[6], const int in_stride[6], int len) {
+- int ch;
+-
+- //FIXME optimize common cases
+-
+- for (ch = 0; ch < ctx->out_channels; ch++) {
+- const int is = in_stride[ch];
+- const int os = out_stride[ch];
+- const uint8_t *pi = (const uint8_t *) in[ch];
+- uint8_t *po = (uint8_t *) out[ch];
+- uint8_t *end = po + os * len;
+- if (!out[ch])
+- continue;
+-
+-#define CONV(ofmt, otype, ifmt, expr)\
+-if(ctx->fmt_pair == ofmt + AV_SAMPLE_FMT_NB*ifmt){\
+- do{\
+- *(otype*)po = expr; pi += is; po += os;\
+- }while(po < end);\
+-}
+-
+-//FIXME put things below under ifdefs so we do not waste space for cases no codec will need
+-//FIXME rounding ?
+-
+- CONV(AV_SAMPLE_FMT_U8 , uint8_t, AV_SAMPLE_FMT_U8 , *(const uint8_t*)pi)
+- else CONV(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)<<8)
+- else CONV(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)<<24)
+- else CONV(AV_SAMPLE_FMT_FLT, float , AV_SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)*(1.0 / (1<<7)))
+- else CONV(AV_SAMPLE_FMT_DBL, double , AV_SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)*(1.0 / (1<<7)))
+- else CONV(AV_SAMPLE_FMT_U8 , uint8_t, AV_SAMPLE_FMT_S16, (*(const int16_t*)pi>>8) + 0x80)
+- else CONV(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S16, *(const int16_t*)pi)
+- else CONV(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t*)pi<<16)
+- else CONV(AV_SAMPLE_FMT_FLT, float , AV_SAMPLE_FMT_S16, *(const int16_t*)pi*(1.0 / (1<<15)))
+- else CONV(AV_SAMPLE_FMT_DBL, double , AV_SAMPLE_FMT_S16, *(const int16_t*)pi*(1.0 / (1<<15)))
+- else CONV(AV_SAMPLE_FMT_U8 , uint8_t, AV_SAMPLE_FMT_S32, (*(const int32_t*)pi>>24) + 0x80)
+- else CONV(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S32, *(const int32_t*)pi>>16)
+- else CONV(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S32, *(const int32_t*)pi)
+- else CONV(AV_SAMPLE_FMT_FLT, float , AV_SAMPLE_FMT_S32, *(const int32_t*)pi*(1.0 / (1U<<31)))
+- else CONV(AV_SAMPLE_FMT_DBL, double , AV_SAMPLE_FMT_S32, *(const int32_t*)pi*(1.0 / (1U<<31)))
+- else CONV(AV_SAMPLE_FMT_U8 , uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8( lrintf(*(const float*)pi * (1<<7)) + 0x80))
+- else CONV(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16( lrintf(*(const float*)pi * (1<<15))))
+- else CONV(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float*)pi * (1U<<31))))
+- else CONV(AV_SAMPLE_FMT_FLT, float , AV_SAMPLE_FMT_FLT, *(const float*)pi)
+- else CONV(AV_SAMPLE_FMT_DBL, double , AV_SAMPLE_FMT_FLT, *(const float*)pi)
+- else CONV(AV_SAMPLE_FMT_U8 , uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8( lrint(*(const double*)pi * (1<<7)) + 0x80))
+- else CONV(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16( lrint(*(const double*)pi * (1<<15))))
+- else CONV(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double*)pi * (1U<<31))))
+- else CONV(AV_SAMPLE_FMT_FLT, float , AV_SAMPLE_FMT_DBL, *(const double*)pi)
+- else CONV(AV_SAMPLE_FMT_DBL, double , AV_SAMPLE_FMT_DBL, *(const double*)pi)
+- else return -1;
+- }
+- return 0;
++// audioconvert.h
++extern "C" {
++struct AVAudioConvert;
++AVAudioConvert *av_audio_convert_alloc(enum AVSampleFormat out_fmt, int out_channels, enum AVSampleFormat in_fmt,
++ int in_channels, const float *matrix, int flags);
++void av_audio_convert_free(AVAudioConvert *ctx);
++int av_audio_convert(AVAudioConvert *ctx, void * const out[6], const int out_stride[6], const void * const in[6],
++ const int in_stride[6], int len);
+ }
+
+ //////////////////////////// AVOutputStream /////////////////////////////////
+@@ -161,6 +74,8 @@
+ 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;
++ AVCodec *enc;
++
+ /* video only */
+ int video_resample;
+ AVFrame resample_frame; /* temporary frame for image resampling */
+@@ -168,17 +83,19 @@
+ int resample_height;
+ int resample_width;
+ int resample_pix_fmt;
++ AVRational frame_rate;
+
+ float frame_aspect_ratio;
++
+ /* forced key frames */
+-// int64_t *forced_kf_pts;
+-// int forced_kf_count;
+-// int forced_kf_index;
++ int64_t *forced_kf_pts;
++ int forced_kf_count;
++ int forced_kf_index;
+
+ /* audio only */
+ int audio_resample;
+ ReSampleContext *resample; /* for audio resampling */
+- int resample_sample_fmt;
++ AVSampleFormat resample_sample_fmt;
+ int resample_channels;
+ int resample_sample_rate;
+ int reformat_pair;
+@@ -216,94 +133,22 @@
+ } AVInputStream;
+
+ typedef struct AVInputFile {
++ AVFormatContext *ctx;
+ int eof_reached; /* true if eof reached */
+ int ist_index; /* index of first stream in ist_table */
+ int buffer_size; /* current total buffer size */
+- int nb_streams; /* nb streams we are aware of */
+ } AVInputFile;
+
+-//#include <libavfilter/vsrc_buffer.h>
+-extern "C" {
+- int av_vsrc_buffer_add_frame2(AVFilterContext *buffer_filter, AVFrame *frame, int64_t pts,
+- AVRational pixel_aspect, int width, int height, enum PixelFormat pix_fmt, const char *sws_param);
+-}
+-
+-//#include "cmdutils.h"
+-typedef struct {
+- enum PixelFormat pix_fmt;
+-} FFSinkContext;
+-
+-int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
++static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
+ {
+- FFSinkContext *priv = (FFSinkContext*) ctx->priv;
+-
+- if (!opaque)
+- return AVERROR(EINVAL);
+- *priv = *(FFSinkContext *)opaque;
+-
+- return 0;
+-}
+-
+-void null_end_frame(AVFilterLink *inlink) { }
+-
+-int ffsink_query_formats(AVFilterContext *ctx) {
+- FFSinkContext *priv = (FFSinkContext*) ctx->priv;
+- int pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
+-
+- avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
+- return 0;
+-}
+-
+-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;
+-}
+-
+-AVFilter ffsink;
+-AVFilterPad fInputs[2];
+-AVFilterPad fOutputs[1];
+-
+-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;
+- ffsink_ctx.pix_fmt = codec->pix_fmt;
++ enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
+ AVRational sample_aspect_ratio;
+ char args[255];
+ int ret;
+-
+- ffsink.name = "ffsink";
+- ffsink.priv_size = sizeof(FFSinkContext);
+- ffsink.init = ffsink_init;
+- ffsink.query_formats = ffsink_query_formats;
+-
+- fInputs[0].name = "default";
+- fInputs[0].type = AVMEDIA_TYPE_VIDEO;
+- fInputs[0].end_frame = null_end_frame;
+- fInputs[0].min_perms = AV_PERM_READ;
+- fInputs[1].name = NULL;
+- ffsink.inputs = fInputs;
+- fOutputs[0].name = NULL;
+- ffsink.outputs = fOutputs;
+-
+- int sws_flags = SWS_BICUBIC;
+
+ ost->graph = avfilter_graph_alloc();
+
+@@ -320,8 +165,8 @@
+ "src", args, NULL, ost->graph);
+ if (ret < 0)
+ return ret;
+- ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
+- "out", NULL, &ffsink_ctx, ost->graph);
++ ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
++ "out", NULL, pix_fmts, ost->graph);
+ if (ret < 0)
+ return ret;
+ last_filter = ost->input_video_filter;
+@@ -330,7 +175,7 @@
+ snprintf(args, 255, "%d:%d:flags=0x%X",
+ codec->width,
+ codec->height,
+- sws_flags);
++ ost->sws_flags);
+ if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
+ NULL, args, NULL, ost->graph)) < 0)
+ return ret;
+@@ -339,12 +184,12 @@
+ last_filter = filter;
+ }
+
+- snprintf(args, sizeof(args), "flags=0x%X", sws_flags);
++ snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
+ ost->graph->scale_sws_opts = av_strdup(args);
+
+ if (ost->avfilter) {
+- AVFilterInOut* outputs = (AVFilterInOut*) av_malloc(sizeof(AVFilterInOut));
+- AVFilterInOut* inputs = (AVFilterInOut*) av_malloc(sizeof(AVFilterInOut));
++ AVFilterInOut *outputs = avfilter_inout_alloc();
++ AVFilterInOut *inputs = avfilter_inout_alloc();
+
+ outputs->name = av_strdup("in");
+ outputs->filter_ctx = last_filter;
+@@ -356,7 +201,7 @@
+ inputs->pad_idx = 0;
+ inputs->next = NULL;
+
+- if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
++ if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
+ return ret;
+ av_freep(&ost->avfilter);
+ } else {
+@@ -370,8 +215,10 @@
+ codec->width = ost->output_video_filter->inputs[0]->w;
+ codec->height = ost->output_video_filter->inputs[0]->h;
+ codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
++ ost->frame_aspect_ratio ? // overriden by the -aspect cli option
++ av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
+ ost->output_video_filter->inputs[0]->sample_aspect_ratio;
+-
++
+ return 0;
+ }
+
+@@ -412,12 +259,11 @@
+ }
+
+ wxFfmpegMediaTranscoder::wxFfmpegMediaTranscoder(int threadCount) {
+- nb_input_files = 0;
+ input_files_ts_scale[0] = NULL;
+ nb_input_files_ts_scale[0] = 0;
+- output_codecs = NULL;
++ input_codecs = NULL;
++ nb_input_codecs = 0;
+ nb_output_files = 0;
+- nb_output_codecs = 0;
+ stream_maps = NULL;
+ nb_stream_maps = 0;
+ nb_meta_data_maps = 0;
+@@ -429,7 +275,6 @@
+ frame_width = 0;
+ frame_height = 0;
+ frame_aspect_ratio = 0;
+- frame_aspect_ratio_override = 0;
+ frame_pix_fmt = PIX_FMT_NONE;
+ frame_bits_per_raw_sample = 0;
+ audio_sample_fmt = SAMPLE_FMT_NONE;
+@@ -476,12 +321,12 @@
+ do_psnr = 0;
+ do_pass = 0;
+ pass_logfilename_prefix = "ffmpeg2pass";
+- video_sync_method= -1;
+- audio_sync_method= 0;
+- audio_drift_threshold= 0.1;
+- copy_ts= 0;
+- opt_shortest = 0; //
+- video_global_header = 0;
++ video_sync_method = -1;
++ audio_sync_method = 0;
++ audio_drift_threshold = 0.1;
++ copy_ts = 0;
++ copy_tb = 0;
++ opt_shortest = 0;
+ vstats_filename = NULL;
+ vstats_file = NULL;
+ opt_programid = 0;
+@@ -519,6 +364,11 @@
+ audio_bitstream_filters = NULL;
+ subtitle_bitstream_filters = NULL;
+
++ input_streams = NULL;
++ nb_input_streams = 0;
++ input_files = NULL;
++ nb_input_files = 0;
++
+ av_log_set_callback(&av_log_wxLog_callback);
+ }
+
+@@ -531,20 +381,39 @@
+ avfilter_register_all();
+ }
+
++// similar to ff_dynarray_add() and av_fast_realloc()
++void* grow_array(void *array, int elem_size, int *size, int new_size) {
++ if (new_size >= INT_MAX / elem_size) {
++ wxLogError(wxT("Array too big."));
++ return NULL;
++ }
++ if (*size < new_size) {
++ uint8_t* tmp = (uint8_t*) av_realloc(array, new_size*elem_size);
++ if (!tmp) {
++ wxLogError(wxT("Could not alloc buffer."));
++ return NULL;
++ }
++ memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
++ *size = new_size;
++ return tmp;
++ }
++ return array;
++}
++
+ bool wxFfmpegMediaTranscoder::AddInputFile(const wxString& fileName, bool disableVideo, bool disableAudio,
+ bool disableSubtitle) {
+ AVFormatContext *ic;
+ int err, i, ret, rfps, rfps_base;
+ int64_t timestamp;
+-
++
+ /* get default parameters from command line */
+ ic = avformat_alloc_context();
+ if (!ic) {
+ PrintError(fileName, AVERROR(ENOMEM));
+ return false;
+ }
+- ic->flags |= AVFMT_FLAG_NONBLOCK;
+-
++ ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
++
+ // open the input file with generic libav function
+ err = av_open_input_file(&ic, (const char*) fileName.mb_str(), NULL, 0, NULL);
+ if (err < 0) {
+@@ -606,39 +475,38 @@
+ for (i=0; i<(int)ic->nb_streams; i++) {
+ AVStream *st = ic->streams[i];
+ AVCodecContext *dec = st->codec;
++ AVInputStream *ist;
++
+ dec->thread_count = thread_count;
++ input_codecs = (AVCodec**) grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
++
++ input_streams = (AVInputStream*) grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
++ ist = &input_streams[nb_input_streams - 1];
++ ist->st = st;
++ ist->file_index = nb_input_files;
++ ist->discard = 1;
++
+ switch (dec->codec_type) {
+ case AVMEDIA_TYPE_AUDIO:
++ input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
+ channel_layout = dec->channel_layout;
+- audio_channels = dec->channels;
+- audio_sample_rate = dec->sample_rate;
+ audio_sample_fmt = dec->sample_fmt;
+ if (disableAudio)
+ 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:
+- frame_height = dec->height;
+- frame_width = dec->width;
++ input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
+ if(st->sample_aspect_ratio.num)
+ frame_aspect_ratio=av_q2d(st->sample_aspect_ratio);
+ else
+ frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
+ frame_aspect_ratio *= (float) dec->width / dec->height;
+- frame_aspect_ratio_override = 0;
+- frame_pix_fmt = dec->pix_fmt;
+ rfps = st->r_frame_rate.num;
+ rfps_base = st->r_frame_rate.den;
+- if(dec->lowres) {
++ 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;
++ dec->height >>= dec->lowres;
++ dec->width >>= dec->lowres;
+ }
+ if (me_threshold)
+ dec->debug |= FF_DEBUG_MV;
+@@ -650,9 +518,6 @@
+ i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
+ (float)rfps / rfps_base, rfps, rfps_base);
+ }
+- /* update the current frame rate to match the stream frame rate */
+- frame_rate.num = rfps;
+- frame_rate.den = rfps_base;
+
+ if (disableVideo)
+ st->discard = AVDISCARD_ALL;
+@@ -660,6 +525,7 @@
+ case AVMEDIA_TYPE_DATA:
+ break;
+ case AVMEDIA_TYPE_SUBTITLE:
++ input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
+ if (disableSubtitle)
+ st->discard = AVDISCARD_ALL;
+ break;
+@@ -672,17 +538,26 @@
+ }
+ }
+
+- input_files[nb_input_files] = ic;
+ input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
+ /* dump the file content */
+ if (verbose >= 0)
+ av_dump_format(ic, nb_input_files, (const char*)fileName.mb_str(), 0);
+
+- nb_input_files++;
++ input_files = (AVInputFile*) grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
++ input_files[nb_input_files - 1].ctx = ic;
++ input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
++
+ input_files_ts_scale[nb_input_files] = NULL;
+ nb_input_files_ts_scale[nb_input_files] = 0;
+-
++
++ top_field_first = -1;
+ video_channel = 0;
++ frame_rate = (AVRational){0, 0};
++ frame_pix_fmt = PIX_FMT_NONE;
++ frame_height = 0;
++ frame_width = 0;
++ audio_sample_rate = 0;
++ audio_channels = 0;
+ return true;
+ }
+
+@@ -742,27 +617,27 @@
+
+ oc->timestamp = recording_timestamp;
+
+- av_metadata_copy(&oc->metadata, metadata, 0);
+- av_metadata_free(&metadata);
+-
++ av_dict_copy(&oc->metadata, metadata, 0);
++ av_dict_free(&metadata);
++
+ output_files[nb_output_files++] = oc;
+
+ /* check filename in case of an image number is expected */
+ if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
+ if (!av_filename_number_test(oc->filename)) {
+- PrintError(fileName, AVERROR_NUMEXPECTED);
++ PrintError(fileName, AVERROR(EINVAL));
+ return false;
+ }
+ }
+
+ /* test if it already exists to avoid loosing precious files */
+- if (url_exist((const char*) fileName.mb_str())) {
++ if (avio_check((const char*) fileName.mb_str(), 0) == 0) {
+ wxLogError(wxT("File '%s' already exists"), fileName.c_str());
+ return false;
+ }
+
+ /* open the file */
+- int err = avio_open(&oc->pb, (const char*) fileName.mb_str(), URL_WRONLY);
++ int err = avio_open(&oc->pb, (const char*) fileName.mb_str(), AVIO_FLAG_WRITE);
+ if (err < 0) {
+ PrintError(fileName, err);
+ return false;
+@@ -777,39 +652,24 @@
+ oc->preload= (int)(mux_preload*AV_TIME_BASE);
+ oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
+ oc->loop_output = loop_output;
+- oc->flags |= AVFMT_FLAG_NONBLOCK;
+-
++
++ frame_rate = (AVRational){0, 0};
++ frame_width = 0;
++ frame_height = 0;
++ audio_sample_rate = 0;
++ audio_channels = 0;
++
+ return true;
+ }
+
+ void wxFfmpegMediaTranscoder::PrintError(const wxString& msg, int err) {
+- switch (err) {
+- case AVERROR_NUMEXPECTED:
+- wxLogError(wxT("%s: Incorrect image filename syntax.\n"
+- "Use '%%d' to specify the image number:\n"
+- " for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
+- " for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'."), msg.c_str());
+- break;
+- case AVERROR_INVALIDDATA:
+- wxLogError(wxT("%s: Error while parsing header"), msg.c_str());
+- break;
+- case AVERROR_NOFMT:
+- wxLogError(wxT("%s: Unknown format"), msg.c_str());
+- break;
+- case AVERROR(EIO):
+- wxLogError(wxT("%s: I/O error occured\n"
+- "Usually that means that input file is truncated and/or corrupted."), msg.c_str());
+- break;
+- case AVERROR(ENOMEM):
+- wxLogError(wxT("%s: memory allocation error occured"), msg.c_str());
+- break;
+- case AVERROR(ENOENT):
+- wxLogError(wxT("%s: no such file or directory"), msg.c_str());
+- break;
+- default:
+- wxLogError(wxT("%s: Error while opening file"), msg.c_str());
+- break;
+- }
++ char errbuf[128];
++ const char *errbuf_ptr = errbuf;
++
++ if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
++ errbuf_ptr = strerror(AVUNERROR(err));
++ wxString errorStr(errbuf_ptr, wxConvUTF8);
++ wxLogError(msg + wxT(": ") + errorStr);
+ }
+
+ void choose_pixel_fmt(AVStream *st, AVCodec *codec) {
+@@ -819,12 +679,15 @@
+ if(*p == st->codec->pix_fmt)
+ break;
+ }
+- 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)))
++ if (*p == -1) {
++ if(st->codec->pix_fmt != PIX_FMT_NONE)
++ av_log(NULL, AV_LOG_WARNING,
++ "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
++ av_pix_fmt_descriptors[st->codec->pix_fmt].name,
++ codec->name,
++ av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
+ st->codec->pix_fmt = codec->pix_fmts[0];
++ }
+ }
+ }
+
+@@ -835,30 +698,20 @@
+ if(*p == st->codec->sample_fmt)
+ break;
+ }
+- if (*p == -1)
++ if (*p == -1) {
++ if ((codec->capabilities & CODEC_CAP_LOSSLESS)
++ && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
++ av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
++ av_log(NULL, AV_LOG_WARNING,
++ "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
++ av_get_sample_fmt_name(st->codec->sample_fmt),
++ codec->name,
++ av_get_sample_fmt_name(codec->sample_fmts[0]));
+ st->codec->sample_fmt = codec->sample_fmts[0];
++ }
+ }
+ }
+
+-// similar to ff_dynarray_add() and av_fast_realloc()
+-void* grow_array(void *array, int elem_size, int *size, int new_size) {
+- if (new_size >= INT_MAX / elem_size) {
+- wxLogError(wxT("Array too big."));
+- return NULL;
+- }
+- if (*size < new_size) {
+- uint8_t* tmp = (uint8_t*) av_realloc(array, new_size*elem_size);
+- if (!tmp) {
+- wxLogError(wxT("Could not alloc buffer."));
+- return NULL;
+- }
+- memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
+- *size = new_size;
+- return tmp;
+- }
+- return array;
+-}
+-
+ void choose_sample_rate(AVStream *st, AVCodec *codec) {
+ if (codec && codec->supported_samplerates){
+ const int *p= codec->supported_samplerates;
+@@ -893,6 +746,8 @@
+ }
+ ost->file_index = fileIdx;
+ ost->index = idx;
++
++ ost->sws_flags = SWS_BICUBIC;
+ return ost;
+ }
+
+@@ -913,8 +768,6 @@
+ if (!ost)
+ return false;
+
+- output_codecs = (AVCodec**)
+- grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if (videoFormat != vfCOPY) {
+ wxSize frameSize = GetFrameSize(videoFormat);
+ frame_width = frameSize.GetWidth();
+@@ -929,21 +782,13 @@
+ frame_rate.den = 1001;
+ }
+ codec = avcodec_find_encoder(codecId);
+- output_codecs[nb_output_codecs-1] = codec;
++ ost->enc = codec;
+
+ char* vfilters = NULL;
+ if (m_videoFilters.length()) {
+ vfilters = (char*) av_realloc(vfilters, m_videoFilters.length() + 1);
+ snprintf(vfilters, m_videoFilters.length() + 1, "%s", (const char*) m_videoFilters.mb_str());
+ }
+- if (frame_aspect_ratio_override) {
+- int i = vfilters ? strlen(vfilters) : 0;
+- vfilters = (char*) av_realloc(vfilters, i + 100);
+- snprintf(vfilters + i, 100, "%csetdar=%f", i ? ',' : ' ', frame_aspect_ratio);
+- frame_aspect_ratio = 0;
+- frame_aspect_ratio_override = 0;
+- }
+-
+ ost->avfilter = vfilters;
+ }
+
+@@ -954,17 +799,14 @@
+ st->codec->thread_count = thread_count;
+
+ video_enc = st->codec;
+-
++
+ if (video_codec_tag)
+ video_enc->codec_tag= video_codec_tag;
+-
+- if ((video_global_header&1) || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))) {
++
++ if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
+ video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
+ }
+- if (video_global_header&2) {
+- video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
+- }
+-
++
+ if (videoFormat == vfCOPY) {
+ st->stream_copy = 1;
+ video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
+@@ -974,8 +816,6 @@
+ const char *p;
+ int i;
+
+- AVRational fps= frame_rate.num ? frame_rate : (AVRational) {25,1};
+-
+ av_set_int(video_enc, "gop", isNTSC(videoFormat) ? 15 : 12);
+ av_set_int(video_enc, "b", bitrate * 1000);
+ av_set_int(video_enc, "maxrate", vbr ? 9000000 : bitrate * 1000);
+@@ -985,20 +825,16 @@
+ av_set_int(video_enc, "packetsize", 2048);
+ av_set_int(video_enc, "muxrate", 10080000);
+
++ if (frame_rate.num)
++ ost->frame_rate = frame_rate;
+ video_enc->codec_id = codecId;
+
+- 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->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
+ video_enc->pix_fmt = frame_pix_fmt;
+ st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
+-
+- choose_pixel_fmt(st, codec);
+-
++
+ if (intra_only)
+ video_enc->gop_size = 0;
+ if (video_qscale || same_quality) {
+@@ -1059,7 +895,7 @@
+ // parse_forced_key_frames(forced_key_frames, ost, video_enc);
+ }
+ if (video_language) {
+- av_metadata_set2(&st->metadata, "language", video_language, 0);
++ av_dict_set(&st->metadata, "language", video_language, 0);
+ av_freep(&video_language);
+ }
+
+@@ -1084,12 +920,10 @@
+ if (!ost)
+ return false;
+
+- output_codecs = (AVCodec**)
+- grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if (audioFormat != afNONE && audioFormat != afCOPY) {
+ codecId = audioFormat == afMP2 ? CODEC_ID_MP2 : CODEC_ID_AC3;
+ codec = avcodec_find_encoder(codecId);
+- output_codecs[nb_output_codecs-1] = codec;
++ ost->enc = codec;
+ }
+
+ audio_sample_rate = 48000;
+@@ -1110,8 +944,6 @@
+ }
+ if (audioFormat == afCOPY) {
+ st->stream_copy = 1;
+- audio_enc->channels = audio_channels;
+- audio_enc->sample_rate = audio_sample_rate;
+ } else {
+ av_set_int(audio_enc, "ab", bitrate*1000);
+ codec = avcodec_find_encoder(codecId);
+@@ -1122,19 +954,16 @@
+ st->quality = FF_QP2LAMBDA * audio_qscale;
+ audio_enc->global_quality = (int) st->quality;
+ }
+- audio_enc->channels = audio_channels;
++ if (audio_channels)
++ audio_enc->channels = audio_channels;
+ audio_enc->sample_fmt = audio_sample_fmt;
+- audio_enc->sample_rate = audio_sample_rate;
++ if (audio_sample_rate)
++ audio_enc->sample_rate = audio_sample_rate;
+ audio_enc->channel_layout = channel_layout;
+- if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
+- audio_enc->channel_layout = 0;
+ choose_sample_fmt(st, codec);
+- choose_sample_rate(st, codec);
+ }
+- audio_enc->sample_rate = audio_sample_rate;
+- audio_enc->time_base= (AVRational) {1, audio_sample_rate};
+ if (audio_language) {
+- av_metadata_set2(&st->metadata, "language", audio_language, 0);
++ av_dict_set(&st->metadata, "language", audio_language, 0);
+ av_freep(&audio_language);
+ }
+
+@@ -1158,11 +987,10 @@
+ return false;
+ subtitle_enc = st->codec;
+
+- output_codecs = (AVCodec**)
+- grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if (subtitleFormat != sfNONE) {
+ codecId = CODEC_ID_DVD_SUBTITLE;
+- codec = output_codecs[nb_output_codecs-1] = avcodec_find_encoder(codecId);
++ codec = avcodec_find_encoder(codecId);
++ ost->enc = codec;
+ }
+ avcodec_get_context_defaults3(st->codec, codec);
+
+@@ -1181,7 +1009,7 @@
+ }
+
+ if (subtitle_language) {
+- av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
++ av_dict_set(&st->metadata, "language", subtitle_language, 0);
+ av_freep(&subtitle_language);
+ }
+
+@@ -1233,7 +1061,7 @@
+ }
+
+ int wxFfmpegMediaTranscoder::CopyChapters(int infile, int outfile) {
+- AVFormatContext *is = input_files[infile];
++ AVFormatContext *is = input_files[infile].ctx;
+ AVFormatContext *os = output_files[outfile];
+
+ for (unsigned int i = 0; i < is->nb_chapters; i++) {
+@@ -1259,7 +1087,7 @@
+ out_ch->end = FFMIN(rt, in_ch->end - ts_off);
+
+ if (metadata_chapters_autocopy)
+- av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
++ av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
+
+ os->nb_chapters++;
+ os->chapters = (AVChapter**) av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
+@@ -1272,11 +1100,11 @@
+
+ /** Starts transcoding. */
+ bool wxFfmpegMediaTranscoder::Run(bool& canceled) {
+- int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
++ int ret = 0, i, j, k, n, nb_ostreams = 0, step;
+ AVFormatContext *is, *os;
+ AVCodecContext *codec, *icodec;
+ AVOutputStream *ost, **ost_table= NULL;
+- AVInputStream *ist, **ist_table= NULL;
++ AVInputStream *ist = NULL;
+ wxString error;
+ int want_sdp = 1;
+ int bit_buffer_size = 1024*256;
+@@ -1289,46 +1117,10 @@
+ if (canceled)
+ return false;
+
+- AVInputFile* file_table = (AVInputFile*) av_mallocz(nb_input_files*sizeof(AVInputFile));
+- if (!file_table)
+- goto fail;
+-
+- /* input stream init */
+- j = 0;
+- for (i=0; i<nb_input_files; i++) {
+- is = input_files[i];
+- file_table[i].ist_index = j;
+- file_table[i].nb_streams = is->nb_streams;
+- j += is->nb_streams;;
+- }
+- nb_istreams = j;
+-
+- ist_table = (AVInputStream**) av_mallocz(nb_istreams * sizeof(AVInputStream *));
+- if (!ist_table)
+- goto fail;
+-
+- for (i=0; i<nb_istreams; i++) {
+- ist = (AVInputStream*) av_mallocz(sizeof(AVInputStream));
+- if (!ist)
+- goto fail;
+- ist_table[i] = ist;
+- }
+- j = 0;
+- for (i=0; i<nb_input_files; i++) {
+- is = input_files[i];
+- for (k=0; k<(int)is->nb_streams; k++) {
+- ist = ist_table[j++];
+- ist->st = is->streams[k];
+- ist->file_index = i;
+- ist->index = k;
+- ist->discard = 1; /* the stream is discarded by default (changed later) */
+-
+- if (rate_emu) {
+- ist->start = av_gettime();
+- }
+- }
+- }
+-
++ if (rate_emu)
++ for (i = 0; i < nb_input_streams; i++)
++ input_streams[i].start = av_gettime();
++
+ /* output stream init */
+ nb_ostreams = 0;
+ for (i=0; i<nb_output_files; i++) {
+@@ -1350,15 +1142,15 @@
+ int fi = stream_maps[i].file_index;
+ int si = stream_maps[i].stream_index;
+
+- if (fi < 0 || fi > nb_input_files - 1 ||
+- si < 0 || si > file_table[fi].nb_streams - 1) {
++ if (fi < 0 || fi > (int) nb_input_files - 1 ||
++ si < 0 || si > (int) input_files[fi].ctx->nb_streams - 1) {
+ wxLogError(wxT("Could not find input stream #%d.%d"), fi, si);
+ return false;
+ }
+ 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) {
++ si < 0 || si > (int) input_files[fi].ctx->nb_streams - 1) {
+ wxLogError(wxT("Could not find sync stream #%d.%d"), fi, si);
+ return false;
+ }
+@@ -1379,11 +1171,11 @@
+ for(j=0; j<AVMEDIA_TYPE_NB; j++)
+ nb_frame_threshold[j] += step;
+
+- for(j=0; j<nb_istreams; j++) {
++ for(j=0; j<nb_input_streams; j++) {
+ int skip=0;
+- ist = ist_table[j];
++ ist = &input_streams[j];
+ if(opt_programid){
+- AVFormatContext *f= input_files[ ist->file_index ];
++ AVFormatContext *f= input_files[ist->file_index].ctx;
+ skip=1;
+ for (unsigned int pi=0; pi<f->nb_programs; pi++) {
+ AVProgram *p= f->programs[pi];
+@@ -1411,11 +1203,11 @@
+ ost = ost_table[n] = output_streams_for_file[k][i];
+ ost->st = os->streams[i];
+ if (nb_stream_maps > 0) {
+- ost->source_index = file_table[stream_maps[n].file_index].ist_index +
++ ost->source_index = input_files[stream_maps[n].file_index].ist_index +
+ stream_maps[n].stream_index;
+
+ /* Sanity check that the stream types match */
+- if (ist_table[ost->source_index]->st->codec->codec_type
++ if (input_streams[ost->source_index].st->codec->codec_type
+ != ost->st->codec->codec_type) {
+ wxLogError(wxT("Codec type mismatch for mapping #%d.%d -> #%d.%d"),
+ stream_maps[n].file_index, stream_maps[n].stream_index,
+@@ -1426,12 +1218,12 @@
+ } else {
+ /* get corresponding input stream index : we select the first one with the right type */
+ found = 0;
+- for(j=0;j<nb_istreams;j++) {
++ for (j=0; j < nb_input_streams; j++) {
+ int skip=0;
+- ist = ist_table[j];
++ ist = &input_streams[j];
+ if(opt_programid){
+ unsigned int pi,si;
+- AVFormatContext *f= input_files[ ist->file_index ];
++ AVFormatContext *f = input_files[ist->file_index].ctx;
+ skip=1;
+ for(pi=0; pi<f->nb_programs; pi++){
+ AVProgram *p= f->programs[pi];
+@@ -1453,8 +1245,8 @@
+ if (!found) {
+ if(! opt_programid) {
+ /* try again and reuse existing stream */
+- for(j=0;j<nb_istreams;j++) {
+- ist = ist_table[j];
++ for (j = 0; j < nb_input_streams; j++) {
++ ist = &input_streams[j];
+ if ( ist->st->codec->codec_type == ost->st->codec->codec_type
+ && ist->st->discard != AVDISCARD_ALL) {
+ ost->source_index = j;
+@@ -1471,10 +1263,10 @@
+ }
+ }
+ }
+- ist = ist_table[ost->source_index];
++ ist = &input_streams[ost->source_index];
+ ist->discard = 0;
+ ost->sync_ist = (nb_stream_maps > 0) ?
+- ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
++ &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
+ stream_maps[n].sync_stream_index] : ist;
+ }
+ }
+@@ -1483,13 +1275,13 @@
+ for (i=0; i<nb_ostreams; i++) {
+ ost = ost_table[i];
+ os = output_files[ost->file_index];
+- ist = ist_table[ost->source_index];
++ ist = &input_streams[ost->source_index];
+
+ codec = ost->st->codec;
+ icodec = ist->st->codec;
+
+ if (metadata_streams_autocopy)
+- av_metadata_copy(&ost->st->metadata, ist->st->metadata, AV_METADATA_DONT_OVERWRITE);
++ av_dict_copy(&ost->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
+
+ ost->st->disposition = ist->st->disposition;
+ codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
+@@ -1520,11 +1312,13 @@
+ goto fail;
+ memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
+ 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;
+- } else
+- codec->time_base = ist->st->time_base;
++ if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
++ 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) {
+@@ -1566,12 +1360,25 @@
+ return false;
+ }
+ } else {
++ if (!ost->enc)
++ ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
+ switch (codec->codec_type) {
+ case AVMEDIA_TYPE_AUDIO:
+ 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);
++ if (!codec->sample_rate) {
++ codec->sample_rate = icodec->sample_rate;
++ if (icodec->lowres)
++ codec->sample_rate >>= icodec->lowres;
++ }
++ choose_sample_rate(ost->st, ost->enc);
++ codec->time_base = (AVRational){1, codec->sample_rate};
++ if (!codec->channels)
++ codec->channels = icodec->channels;
++ if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
++ codec->channel_layout = 0;
+ ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
+ icodec->request_channels = codec->channels;
+ ist->decoding_needed = 1;
+@@ -1581,6 +1388,9 @@
+ ost->resample_channels = icodec->channels;
+ break;
+ case AVMEDIA_TYPE_VIDEO:
++ if (codec->pix_fmt == PIX_FMT_NONE)
++ codec->pix_fmt = icodec->pix_fmt;
++ choose_pixel_fmt(ost->st, ost->enc);
+ if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
+ wxLogError(wxT("Video pixel format is unknown, stream cannot be encoded"));
+ return false;
+@@ -1590,13 +1400,30 @@
+ if (ost->video_resample) {
+ codec->bits_per_raw_sample= frame_bits_per_raw_sample;
+ }
++ if (!codec->width || !codec->height) {
++ codec->width = icodec->width;
++ codec->height = icodec->height;
++ }
+ ost->resample_height = icodec->height;
+ ost->resample_width = icodec->width;
+ ost->resample_pix_fmt= icodec->pix_fmt;
+ ost->encoding_needed = 1;
+ ist->decoding_needed = 1;
++
++ if (!ost->frame_rate.num)
++ ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
++ if (ost->enc && ost->enc->supported_framerates && !force_fps) {
++ int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
++ ost->frame_rate = ost->enc->supported_framerates[idx];
++ }
++ codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
++ if( av_q2d(codec->time_base) < 0.001 && video_sync_method
++ && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
++ av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
++ "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
++ }
+
+- if (configure_filters(ist, ost)) {
++ if (configure_video_filters(ist, ost)) {
+ wxLogError(wxT("Error opening filters!"));
+ return false;
+ }
+@@ -1653,10 +1480,8 @@
+ for (i=0; i<nb_ostreams; i++) {
+ ost = ost_table[i];
+ if (ost->encoding_needed) {
+- AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
+- AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
+- if (!codec)
+- codec = avcodec_find_encoder(ost->st->codec->codec_id);
++ AVCodec *codec = ost->enc;
++ AVCodecContext *dec = input_streams[ost->source_index].st->codec;
+ if (!codec) {
+ error = wxString::Format(wxT("Encoder (codec id %d) not found for output stream #%d.%d"),
+ ost->st->codec->codec_id, ost->file_index, ost->index);
+@@ -1683,18 +1508,18 @@
+ }
+
+ /* open each decoder */
+- for (i=0; i<nb_istreams; i++) {
+- ist = ist_table[i];
++ for (i = 0; i < nb_input_streams; i++) {
++ ist = &input_streams[i];
+ if (ist->decoding_needed) {
+ AVCodec *codec = avcodec_find_decoder(ist->st->codec->codec_id);
+ if (!codec) {
+ wxLogError(wxT("Decoder (codec id %d) not found for input stream #%d.%d"),
+- ist->st->codec->codec_id, ist->file_index, ist->index);
++ ist->st->codec->codec_id, ist->file_index, ist->st->index);
+ return false;
+ }
+ if (avcodec_open(ist->st->codec, codec) < 0) {
+ wxLogError(wxT("Error while opening decoder for input stream #%d.%d"),
+- ist->file_index, ist->index);
++ ist->file_index, ist->st->index);
+ return false;
+ }
+ //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
+@@ -1703,20 +1528,68 @@
+ }
+
+ /* init pts */
+- for (i=0; i<nb_istreams; i++) {
++ for (i = 0; i < nb_input_streams; i++) {
+ AVStream *st;
+- ist = ist_table[i];
++ ist = &input_streams[i];
+ 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;
+ ist->is_start = 1;
+ }
++
++ /* set meta data information from input file if required */
++ for (i=0;i<nb_meta_data_maps;i++) {
++ AVFormatContext *files[2];
++ AVDictionary **meta[2];
++ int j;
++
++#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
++ if ((index) < 0 || (index) >= (int) (nb_elems)) {\
++ error = wxString::Format(wxT("Invalid %s index %d while processing metadata maps."), (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].ctx;
++
++ 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;
++ }
++ }
++
++ av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
++ }
++
+ /* copy global metadata by default */
+ if (metadata_global_autocopy) {
+
+ for (i = 0; i < nb_output_files; i++)
+- av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata, AV_METADATA_DONT_OVERWRITE);
++ av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata, AV_DICT_DONT_OVERWRITE);
+ }
+
+ /* copy chapters according to chapter maps */
+@@ -1742,7 +1615,7 @@
+ /* 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)
++ if (!input_files[i].ctx->nb_chapters)
+ continue;
+
+ for (j = 0; j < nb_output_files; j++)
+@@ -1776,10 +1649,10 @@
+ for(i=0;i<nb_ostreams;i++) {
+ ost = ost_table[i];
+ wxString msg = wxString::Format(wxT(" Stream #%d.%d -> #%d.%d"),
+- ist_table[ost->source_index]->file_index, ist_table[ost->source_index]->index,
++ input_streams[ost->source_index].file_index, input_streams[ost->source_index].st->index,
+ ost->file_index, ost->index);
+- if (ost->sync_ist != ist_table[ost->source_index])
+- msg += wxString::Format(wxT(" [sync #%d.%d]"), ost->sync_ist->file_index, ost->sync_ist->index);
++ if (ost->sync_ist != &input_streams[ost->source_index])
++ msg += wxString::Format(wxT(" [sync #%d.%d]"), ost->sync_ist->file_index, ost->sync_ist->st->index);
+ wxLogMessage(msg);
+ }
+ }
+@@ -1815,12 +1688,12 @@
+ double ipts, opts;
+ ost = ost_table[i];
+ os = output_files[ost->file_index];
+- ist = ist_table[ost->source_index];
++ ist = &input_streams[ost->source_index];
+ if (ist->is_past_recording_time || no_packet[ist->file_index])
+ continue;
+ opts = ost->st->pts.val * av_q2d(ost->st->time_base);
+ ipts = (double)ist->pts;
+- if (!file_table[ist->file_index].eof_reached) {
++ if (!input_files[ist->file_index].eof_reached) {
+ if (ipts < ipts_min) {
+ ipts_min = ipts;
+ if (input_sync)
+@@ -1853,7 +1726,7 @@
+ break;
+
+ /* read a frame from it and output it in the fifo */
+- is = input_files[file_index];
++ is = input_files[file_index].ctx;
+ ret= av_read_frame(is, &pkt);
+ if(ret == AVERROR(EAGAIN)){
+ no_packet[file_index]=1;
+@@ -1861,7 +1734,7 @@
+ continue;
+ }
+ if (ret < 0) {
+- file_table[file_index].eof_reached = 1;
++ input_files[file_index].eof_reached = 1;
+ if (opt_shortest)
+ break;
+ else
+@@ -1876,11 +1749,11 @@
+ // }
+
+ /* the following test is needed in case new streams appear
+- dynamically in stream : we ignore them */
+- if (pkt.stream_index >= file_table[file_index].nb_streams)
++ dynamically in stream : we ignore them */
++ if (pkt.stream_index >= (int) input_files[file_index].ctx->nb_streams)
+ goto discard_packet;
+- ist_index = file_table[file_index].ist_index + pkt.stream_index;
+- ist = ist_table[ist_index];
++ ist_index = input_files[file_index].ist_index + pkt.stream_index;
++ ist = &input_streams[ist_index];
+ if (ist->discard)
+ goto discard_packet;
+
+@@ -1926,7 +1799,7 @@
+ //wxLogMessage(wxT("read #%d.%d size=%d"), ist->file_index, ist->index, pkt.size);
+ if (!OutputPacket(ist, ist_index, ost_table, nb_ostreams, &pkt, bit_buffer_size, bit_buffer)) {
+ if (verbose >= 0)
+- wxLogMessage(wxT("Error while decoding stream #%d.%d"), ist->file_index, ist->index);
++ wxLogMessage(wxT("Error while decoding stream #%d.%d"), ist->file_index, ist->st->index);
+ if (exit_on_error)
+ return false;
+ av_free_packet(&pkt);
+@@ -1941,8 +1814,8 @@
+ }
+
+ /* at the end of stream, we must flush the decoder buffers */
+- for (i=0; i<nb_istreams; i++) {
+- ist = ist_table[i];
++ for (i = 0; i < nb_input_streams; i++) {
++ ist = &input_streams[i];
+ if (ist->decoding_needed)
+ OutputPacket(ist, i, ost_table, nb_ostreams, NULL, bit_buffer_size, bit_buffer);
+ }
+@@ -1967,8 +1840,8 @@
+ }
+
+ /* close each decoder */
+- for (i=0; i<nb_istreams; i++) {
+- ist = ist_table[i];
++ for (i = 0; i < nb_input_streams; i++) {
++ ist = &input_streams[i];
+ if (ist->decoding_needed) {
+ avcodec_close(ist->st->codec);
+ }
+@@ -1978,15 +1851,7 @@
+ ret = 0;
+ fail:
+ av_freep(&bit_buffer);
+- av_free(file_table);
+
+- if (ist_table) {
+- for (i=0; i<nb_istreams; i++) {
+- ist = ist_table[i];
+- av_free(ist);
+- }
+- av_free(ist_table);
+- }
+ if (ost_table) {
+ for (i=0; i<nb_ostreams; i++) {
+ ost = ost_table[i];
+@@ -2000,7 +1865,7 @@
+ 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->resample_frame.data[0]);
+-// av_free(ost->forced_kf_pts);
++ av_free(ost->forced_kf_pts);
+ if (ost->video_resample)
+ sws_freeContext(ost->img_resample_ctx);
+ if (ost->resample)
+@@ -2029,15 +1894,15 @@
+ AVFormatContext *os;
+ AVOutputStream *ost;
+ int ret, i;
+- int got_picture;
++ int got_output;
+ AVFrame picture;
+- void *buffer_to_free;
++ void *buffer_to_free = NULL;
+ unsigned int samples_size = 0;
+ AVSubtitle subtitle, *subtitle_to_free;
+ int frame_available;
+
+ AVPacket avpkt;
+- int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
++ int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
+
+ if(ist->next_pts == (int64_t) AV_NOPTS_VALUE)
+ ist->next_pts= ist->pts;
+@@ -2056,7 +1921,7 @@
+ ist->next_pts = ist->pts = av_rescale_q(pkt->dts, 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)) {
++ while (avpkt.size > 0 || (!pkt && got_output)) {
+ uint8_t *data_buf, *decoded_data_buf;
+ int data_size, decoded_data_size;
+ handle_eof:
+@@ -2090,9 +1955,10 @@
+ avpkt.data += ret;
+ avpkt.size -= ret;
+ data_size = ret;
++ got_output = decoded_data_size > 0;
+ // Some bug in mpeg audio decoder gives
+ // decoded_data_size < 0, it seems they are overflows
+- if (decoded_data_size <= 0) {
++ if (!got_output) {
+ // no audio frame
+ continue;
+ }
+@@ -2106,11 +1972,11 @@
+ // XXX: allocate picture correctly
+ avcodec_get_frame_defaults(&picture);
+
+- ret = avcodec_decode_video2(ist->st->codec, &picture, &got_picture, &avpkt);
++ ret = avcodec_decode_video2(ist->st->codec, &picture, &got_output, &avpkt);
+ ist->st->quality= picture.quality;
+ if (ret < 0)
+ goto fail_decode;
+- if (!got_picture) {
++ if (!got_output) {
+ // no picture yet
+ goto discard_packet;
+ }
+@@ -2121,12 +1987,14 @@
+ / ist->st->codec->time_base.den;
+ }
+ avpkt.size = 0;
++ buffer_to_free = NULL;
++ pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
+ break;
+ case AVMEDIA_TYPE_SUBTITLE:
+- ret = avcodec_decode_subtitle2(ist->st->codec, &subtitle, &got_picture, &avpkt);
++ ret = avcodec_decode_subtitle2(ist->st->codec, &subtitle, &got_output, &avpkt);
+ if (ret < 0)
+ goto fail_decode;
+- if (!got_picture) {
++ if (!got_output) {
+ goto discard_packet;
+ }
+ subtitle_to_free = &subtitle;
+@@ -2157,26 +2025,19 @@
+ avpkt.size = 0;
+ }
+
+- buffer_to_free = NULL;
+- if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+- pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
+- }
+-
+- if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
+- for(i=0;i<nb_ostreams;i++) {
+- ost = ost_table[i];
+- if (ost->input_video_filter && ost->source_index == ist_index) {
+- AVRational sar;
+- if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
+- else sar = ist->st->codec->sample_aspect_ratio;
+- // add it to be filtered
+- av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
+- ist->pts,
+- sar, ist->st->codec->width, ist->st->codec->height,
+- ist->st->codec->pix_fmt, "0:0");
+- }
+- }
+- }
++ if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
++ if (start_time == 0 || ist->pts >= start_time) {
++ for(i=0;i<nb_ostreams;i++) {
++ ost = ost_table[i];
++ if (ost->input_video_filter && ost->source_index == ist_index) {
++ if (!picture.sample_aspect_ratio.num)
++ picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
++ picture.pts = ist->pts;
++
++ av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
++ }
++ }
++ }
+
+ // preprocess audio (volume)
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+@@ -2209,14 +2070,18 @@
+
+ ost = ost_table[i];
+ if (ost->source_index == ist_index) {
+- frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
+- !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
+- while (frame_available) {
+- AVRational ist_pts_tb;
+- if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
+- get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
+- if (ost->picref)
+- ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
++ frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
++ !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
++ while (frame_available) {
++ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
++ AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
++ if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
++ goto cont;
++ if (ost->picref) {
++ avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
++ ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
++ }
++ }
+ os = output_files[ost->file_index];
+
+ // set the input output pts pairs
+@@ -2232,7 +2097,7 @@
+ break;
+ case AVMEDIA_TYPE_VIDEO:
+ if (ost->picref->video)
+- ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
++ ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
+ if (!DoVideoOut(os, ost, ist, &picture, &frame_size, bit_buffer_size, bit_buffer))
+ return false;
+ // if (vstats_filename && frame_size)
+@@ -2249,6 +2114,7 @@
+ }
+ } else {
+ AVFrame avframe; //FIXME/XXX remove this
++ AVPicture pict;
+ AVPacket opkt;
+ int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
+
+@@ -2298,6 +2164,14 @@
+ opkt.size = data_size;
+ }
+
++ if (os->oformat->flags & AVFMT_RAWPICTURE) {
++ /* store AVPicture in AVPacket, as expected by the output format */
++ avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
++ opkt.data = (uint8_t *)&pict;
++ opkt.size = sizeof(AVPicture);
++ opkt.flags |= AV_PKT_FLAG_KEY;
++ }
++
+ if (!WriteFrame(os, &opkt, ost->st->codec, ost->bitstream_filters))
+ return false;
+
+@@ -2308,8 +2182,7 @@
+ cont:
+ frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
+ ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
+- if(ost->picref)
+- avfilter_unref_buffer(ost->picref);
++ avfilter_unref_buffer(ost->picref);
+ }
+ }
+ }
+@@ -2348,7 +2221,7 @@
+ 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_bytes_per_sample(enc->sample_fmt);
+ int fs_tmp = enc->frame_size;
+ av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
+ if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
+@@ -2447,11 +2320,11 @@
+ int64_t audio_out_size, audio_buf_size;
+ int64_t allocated_for_size= size;
+
+- int size_out, frame_bytes, ret;
++ int size_out, frame_bytes, ret, resample_changed;
+ 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_bytes_per_sample(enc->sample_fmt);
++ int isize= av_get_bytes_per_sample(dec->sample_fmt);
+ const int coded_bps = av_get_bits_per_sample(enc->codec->id);
+
+ need_realloc:
+@@ -2481,18 +2354,42 @@
+ if (enc->channels != dec->channels)
+ ost->audio_resample = 1;
+
+- if (ost->audio_resample && !ost->resample) {
+- if (dec->sample_fmt != SAMPLE_FMT_S16)
+- wxLogWarning(wxT("Warning, using s16 intermediate sample format for resampling"));
+- 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) {
+- wxLogError(wxT("Can not resample %d channels @ %d Hz to %d channels @ %d Hz"),
+- dec->channels, dec->sample_rate,
+- enc->channels, enc->sample_rate);
+- return false;
++ 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->st->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 audio_sync_method is >1 the resampler is needed for audio drift compensation */
++ if (audio_sync_method <= 1 &&
++ 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 != SAMPLE_FMT_S16)
++ wxLogWarning(wxT("Warning, using s16 intermediate sample format for resampling"));
++ 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) {
++ wxLogError(wxT("Can not resample %d channels @ %d Hz to %d channels @ %d Hz"),
++ dec->channels, dec->sample_rate,
++ enc->channels, enc->sample_rate);
++ return false;
++ }
+ }
+ }
+
+@@ -2619,7 +2516,7 @@
+ pkt.size= ret;
+ if(enc->coded_frame && enc->coded_frame->pts != (int64_t) AV_NOPTS_VALUE)
+ pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
+- pkt.flags |= PKT_FLAG_KEY;
++ pkt.flags |= AV_PKT_FLAG_KEY;
+ if (!WriteFrame(s, &pkt, ost->st->codec, ost->bitstream_filters))
+ return false;
+
+@@ -2704,7 +2601,7 @@
+ bool wxFfmpegMediaTranscoder::DoVideoOut(AVFormatContext *s, AVOutputStream *ost,
+ AVInputStream *ist, AVFrame *in_picture, int *frame_size,
+ int bit_buffer_size, uint8_t* bit_buffer) {
+- int nb_frames, i, ret, av_unused resample_changed;
++ int nb_frames, i, ret;
+ AVFrame *final_picture, *formatted_picture;
+ AVCodecContext *enc, *dec;
+ double sync_ipts;
+@@ -2787,15 +2684,13 @@
+ // handles sameq here. This is not correct because it may not be a global option
+ big_picture.quality = same_quality ? (int) ist->st->quality : (int) ost->st->quality;
+ if (!me_threshold)
+- big_picture.pict_type = 0;
+-// big_picture.pts = AV_NOPTS_VALUE;
++ big_picture.pict_type = (AVPictureType) 0;
+ 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);
+-// if (ost->forced_kf_index < ost->forced_kf_count &&
+-// big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
+-// big_picture.pict_type = AV_PICTURE_TYPE_I;
+-// ost->forced_kf_index++;
+-// }
++ if (ost->forced_kf_index < ost->forced_kf_count &&
++ big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
++ big_picture.pict_type = AV_PICTURE_TYPE_I;
++ ost->forced_kf_index++;
++ }
+ ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, &big_picture);
+ if (ret < 0) {
+ wxLogError(wxT("Video encoding failed"));
+@@ -2806,17 +2701,12 @@
+ pkt.size= ret;
+ if(enc->coded_frame->pts != (int64_t) AV_NOPTS_VALUE)
+ pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
+- //av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
+- //pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
+- //pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);
+-
++
+ if(enc->coded_frame->key_frame)
+ pkt.flags |= AV_PKT_FLAG_KEY;
+ WriteFrame(s, &pkt, ost->st->codec, ost->bitstream_filters);
+ *frame_size = ret;
+ video_size += ret;
+- //wxLogError(wxT("Frame: %3d size: %5d type: %d"),
+- // enc->frame_number-1, ret, enc->pict_type);
+ // if two pass, output log
+ if (ost->logfile && enc->stats_out) {
+ fprintf(ost->logfile, "%s", enc->stats_out);
+@@ -2896,7 +2786,8 @@
+ int64_t total_size;
+ AVCodecContext *enc;
+ int frame_number, vid, i;
+- double bitrate, ti1, pts;
++ double bitrate;
++ int64_t pts = INT64_MAX;
+ static int64_t last_time = -1;
+ static int qp_histogram[52];
+
+@@ -2920,11 +2811,13 @@
+ total_size= avio_tell(oc->pb);
+
+ wxString msg;
+- ti1 = 1e10;
+ vid = 0;
+ for (i=0; i<nb_ostreams; i++) {
++ float q = -1;
+ ost = ost_table[i];
+ enc = ost->st->codec;
++ if (!ost->st->stream_copy && enc->coded_frame)
++ q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
+ if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
+ msg += wxString::Format(wxT("q=%2.1f "),
+ !ost->st->stream_copy ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
+@@ -2940,7 +2833,7 @@
+ msg += wxString::Format(wxT("L"));
+ if (qp_hist) {
+ int j;
+- int qp = (int) rint(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
++ int qp = lrintf(q);
+ if (qp>=0 && qp < (int) (FF_ARRAY_ELEMS(qp_histogram)))
+ qp_histogram[qp]++;
+ for (j=0; j<32; j++)
+@@ -2971,18 +2864,22 @@
+ vid = 1;
+ }
+ // compute min output value
+- pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
+- if ((pts < ti1) && (pts > 0))
+- ti1 = pts;
++ pts = FFMIN(pts, av_rescale_q(ost->st->pts.val, ost->st->time_base, AV_TIME_BASE_Q));
+ }
+- if (ti1 < 0.01)
+- ti1 = 0.01;
+
+ if (verbose || is_last_report) {
+- bitrate = (double)(total_size * 8) / ti1 / 1000.0;
++ int hours, mins, secs, us;
++ secs = pts / AV_TIME_BASE;
++ us = pts % AV_TIME_BASE;
++ mins = secs / 60;
++ secs %= 60;
++ hours = mins / 60;
++ mins %= 60;
++
++ bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
+
+- msg += wxString::Format(wxT("size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s"),
+- (double)total_size / 1024, ti1, bitrate);
++ msg += wxString::Format(wxT("size=%8.0fkB time=%02d:%02d:%02d.%02d bitrate=%6.1fkbits/s"),
++ (double) total_size / 1024, hours, mins, secs, (100 * us) / AV_TIME_BASE, bitrate);
+
+ if (nb_frames_dup || nb_frames_drop)
+ msg += wxString::Format(wxT(" dup=%d drop=%d"), nb_frames_dup, nb_frames_drop);
+@@ -3013,10 +2910,9 @@
+ }
+ nb_output_files = 0;
+ for (int i=0; i<nb_input_files; i++) {
+- av_close_input_file(input_files[i]);
++ av_close_input_file(input_files[i].ctx);
+ av_free(input_files_ts_scale[i]);
+ }
+- nb_input_files = 0;
+
+ av_freep(&intra_matrix);
+ av_freep(&inter_matrix);
+@@ -3025,11 +2921,14 @@
+ fclose(vstats_file);
+ av_freep(&vstats_filename);
+
+- av_freep(&output_codecs);
+- nb_output_codecs = 0;
+ av_freep(&stream_maps);
+ nb_stream_maps = 0;
+
++ av_freep(&input_streams);
++ nb_input_streams = 0;
++ av_freep(&input_files);
++ nb_input_files = 0;
++
+ av_freep(&video_standard);
+ av_freep(&audio_buf);
+ av_freep(&audio_out);
+diff -Naur DVDStyler-1.8.4.3.orig/src/mediatrc_ffmpeg.h DVDStyler-1.8.4.3/src/mediatrc_ffmpeg.h
+--- DVDStyler-1.8.4.3.orig/src/mediatrc_ffmpeg.h 2011-05-15 09:23:34.000000000 -0400
++++ DVDStyler-1.8.4.3/src/mediatrc_ffmpeg.h 2011-09-18 18:13:29.000000000 -0400
+@@ -3,7 +3,7 @@
+ // Purpose: FFMPEG Media Transcoder
+ // Author: Alex Thuering
+ // Created: 26.04.2008
+-// RCS-ID: $Id: mediatrc_ffmpeg.h,v 1.19 2011/05/15 13:23:34 ntalex Exp $
++// RCS-ID: $Id: mediatrc_ffmpeg.h,v 1.20 2011/07/24 07:58:21 ntalex Exp $
+ // Copyright: (c) Alex Thuering
+ // Licence: GPL
+ /////////////////////////////////////////////////////////////////////////////
+@@ -20,13 +20,8 @@
+ extern "C" {
+ #define __STDC_CONSTANT_MACROS
+ #define __STDC_LIMIT_MACROS
+-#ifdef HAVE_FFMPEG_AVUTIL_H
+-#include <avformat.h>
+-#include <swscale.h>
+-#else
+ #include <libavformat/avformat.h>
+ #include <libswscale/swscale.h>
+-#endif
+ }
+
+ // select an input stream for an output stream
+@@ -39,8 +34,9 @@
+
+ // select an input file for an output file
+ typedef struct AVMetaDataMap {
+- int out_file;
+- int in_file;
++ 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 {
+@@ -50,6 +46,8 @@
+
+ struct AVInputStream;
+ struct AVOutputStream;
++struct AVDictionary;
++struct AVInputFile;
+
+ #define MAX_FILES 50
+ #define MAX_STREAMS_ 20
+@@ -108,21 +106,20 @@
+ void PrintReport(AVFormatContext **output_files, AVOutputStream **ost_table,
+ int nb_ostreams, int is_last_report);
+ int CopyChapters(int infile, int outfile);
+- AVFormatContext *input_files[MAX_FILES];
+- int nb_input_files;
+ int64_t input_files_ts_offset[MAX_FILES];
+ double* input_files_ts_scale[MAX_FILES];
+ int nb_input_files_ts_scale[MAX_FILES];
++
++ AVCodec **input_codecs;
++ int nb_input_codecs;
+
+ AVFormatContext* output_files[MAX_FILES];
+- AVCodec** output_codecs;
+ int nb_output_files;
+- int nb_output_codecs;
+
+ AVStreamMap* stream_maps;
+ int nb_stream_maps;
+
+- AVMetaDataMap meta_data_maps[MAX_FILES];
++ AVMetaDataMap (*meta_data_maps)[2];
+ int nb_meta_data_maps;
+ int metadata_global_autocopy;
+ int metadata_streams_autocopy;
+@@ -134,7 +131,6 @@
+ int frame_width;
+ int frame_height;
+ float frame_aspect_ratio;
+- int frame_aspect_ratio_override;
+ PixelFormat frame_pix_fmt;
+ int frame_bits_per_raw_sample;
+ SampleFormat audio_sample_fmt;
+@@ -163,10 +159,10 @@
+ int audio_channels;
+ unsigned int audio_codec_tag;
+ char *audio_language;
+-
++
+ char *subtitle_language;
+ unsigned int subtitle_codec_tag;
+-
++
+ float mux_preload;
+ float mux_max_delay;
+
+@@ -174,7 +170,7 @@
+ int64_t start_time;
+ int64_t recording_timestamp;
+ int64_t input_ts_offset;
+- AVMetadata* metadata;
++ AVDictionary *metadata;
+ int do_psnr;
+ int do_pass;
+ const char *pass_logfilename_prefix;
+@@ -182,8 +178,8 @@
+ int audio_sync_method;
+ float audio_drift_threshold;
+ int copy_ts;
+- int opt_shortest; //
+- int video_global_header;
++ int copy_tb;
++ int opt_shortest;
+ char *vstats_filename;
+ FILE *vstats_file;
+ int opt_programid;
+@@ -222,6 +218,12 @@
+ AVBitStreamFilterContext *video_bitstream_filters;
+ AVBitStreamFilterContext *audio_bitstream_filters;
+ AVBitStreamFilterContext *subtitle_bitstream_filters;
++
++ AVInputStream *input_streams;
++ int nb_input_streams;
++ AVInputFile *input_files;
++ int nb_input_files;
++
+ AVOutputStream** output_streams_for_file[MAX_FILES];
+ int nb_output_streams_for_file[MAX_FILES];
+ };
diff --git a/community/pcb/PKGBUILD b/community/pcb/PKGBUILD
index e7a7fcf0c..57651f7d7 100644
--- a/community/pcb/PKGBUILD
+++ b/community/pcb/PKGBUILD
@@ -2,18 +2,18 @@
# Maintainer: Stefan Husmann <stefan-husmann@t-online.de>
pkgname=pcb
-pkgver=20100929
-pkgrel=2
+pkgver=20110918
+pkgrel=1
pkgdesc="An interactive printed circuit board editor for the X11 window system."
url="http://pcb.gpleda.org/"
license=('GPL')
arch=('i686' 'x86_64')
-depends=('tcl' 'gtk2' 'gd' 'perlxml' 'hicolor-icon-theme' 'shared-mime-info')
+depends=('tcl' 'gtkglext' 'gd' 'perlxml' 'hicolor-icon-theme' 'desktop-file-utils')
optdepends=('tk: for the graphical QFP footprint builder')
install=$pkgname.install
changelog=Changelog
source=(http://downloads.sourceforge.net/pcb/$pkgname-$pkgver.tar.gz)
-md5sums=('4c71f5d1c40ad65539957748b88eb863')
+md5sums=('54bbc997eeb22b85cf21fed54cb8e181')
build() {
cd $srcdir/$pkgname-$pkgver/
diff --git a/community/pigeonhole/PKGBUILD b/community/pigeonhole/PKGBUILD
index 144788233..fc1bc0fd8 100644
--- a/community/pigeonhole/PKGBUILD
+++ b/community/pigeonhole/PKGBUILD
@@ -4,12 +4,12 @@
# This must be built against the version of dovecot being used,
# else mail delivery will fail.
# Specify the version of dovecot to be used here:
-_dcpkgver=2.0.14
+_dcpkgver=2.0.15
# Make sure to bump pkgrel if changing this.
pkgname=pigeonhole
pkgver=0.2.4
-pkgrel=1
+pkgrel=2
pkgdesc="Fully rewritten Sieve implementation for Dovecot v2.0"
arch=('i686' 'x86_64')
url="http://pigeonhole.dovecot.org/"
diff --git a/community/vnstat/PKGBUILD b/community/vnstat/PKGBUILD
index 2fd7788ae..310adf3a1 100644
--- a/community/vnstat/PKGBUILD
+++ b/community/vnstat/PKGBUILD
@@ -1,10 +1,10 @@
-# $Id: PKGBUILD 48601 2011-06-03 09:15:53Z ttopper $
+# $Id: PKGBUILD 55756 2011-09-19 06:41:29Z ttopper $
# Maintainer: Sergej Pupykin <pupykin.s+arch@gmail.com>
# Maintainer: Thorsten Töpper <atsutane-tu@freethoughts.de>
pkgname=vnstat
pkgver=1.11
-pkgrel=1
+pkgrel=2
pkgdesc="A console-based network traffic monitor"
arch=('i686' 'x86_64')
url="http://humdi.net/vnstat/"
@@ -13,7 +13,6 @@ depends=('bash')
makedepends=('gd')
optdepends=('gd: image output')
backup=(etc/vnstat.conf)
-install=vnstat.install
source=(http://humdi.net/vnstat/$pkgname-$pkgver.tar.gz
http://humdi.net/vnstat/init.d/arch/vnstat)
md5sums=('a5a113f9176cd61fb954f2ba297f5fdb'
diff --git a/community/wxsvg/PKGBUILD b/community/wxsvg/PKGBUILD
index f4520f9be..28bcc240d 100644
--- a/community/wxsvg/PKGBUILD
+++ b/community/wxsvg/PKGBUILD
@@ -1,9 +1,9 @@
-# $Id: PKGBUILD 43527 2011-03-27 08:14:30Z ebelanger $
+# $Id: PKGBUILD 55754 2011-09-19 05:09:05Z ebelanger $
# Contributor: Alexander Fehr <pizzapunk gmail com>
# Maintainer: Daniel J Griffiths <ghost1227@archlinux.us>
pkgname=wxsvg
-pkgver=1.0.8
+pkgver=1.1.2
pkgrel=1
pkgdesc="C++ library to create, manipulate and render SVG files"
arch=('i686' 'x86_64')
@@ -11,28 +11,17 @@ url="http://wxsvg.sourceforge.net/"
license=('custom:wxWindows')
depends=('wxgtk' 'libart-lgpl' 'ffmpeg')
options=('!libtool')
-source=("http://downloads.sourceforge.net/project/wxsvg/wxsvg/${pkgver}/wxsvg-${pkgver}-1.tar.bz2")
-md5sums=('81b1b4e9f86b74850d56df6cc3a44faa')
+source=("http://downloads.sourceforge.net/project/wxsvg/wxsvg/${pkgver}/wxsvg-${pkgver}.tar.bz2")
+md5sums=('d88b0a68334df157fa560413681c3264')
build() {
- cd "${srcdir}/${pkgname}-${pkgver}-1"
-
- #sed -i 's|avformat.h|libavformat/avformat.h|' src/mediadec_ffmpeg.cpp
- #sed -i 's|swscale.h|libswscale/swscale.h|' src/mediadec_ffmpeg.cpp
-
- ./autogen.sh
-
- ./configure \
- --prefix=/usr
-
+ cd "${srcdir}/${pkgname}-${pkgver}"
+ ./configure --prefix=/usr
make
}
package() {
- cd "${srcdir}/${pkgname}-${pkgver}-1"
-
+ cd "${srcdir}/${pkgname}-${pkgver}"
make DESTDIR="${pkgdir}" install
-
- install -D -m644 COPYING \
- "${pkgdir}/usr/share/licenses/wxsvg/COPYING"
+ install -D -m644 COPYING "${pkgdir}/usr/share/licenses/wxsvg/COPYING"
}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-10 19:01:02 +0000