Move avcodec module files to modules/codec/avcodec. (The 3 shared
authorAntoine Cellerier <dionoea@videolan.org>
Sat, 7 Jun 2008 22:59:51 +0000 (00:59 +0200)
committerAntoine Cellerier <dionoea@videolan.org>
Mon, 9 Jun 2008 08:05:35 +0000 (10:05 +0200)
headers, avutil.h, chroma.h and fourcc.h are also located in that
directory.) This should be the last commit in the "Move all the old
ffmpeg modules source code files around to make it seem like you're
working while you're not".

26 files changed:
configure.ac
modules/codec/Modules.am
modules/codec/avcodec/Modules.am [new file with mode: 0644]
modules/codec/avcodec/audio.c [new file with mode: 0644]
modules/codec/avcodec/avcodec.c [new file with mode: 0644]
modules/codec/avcodec/avcodec.h [new file with mode: 0644]
modules/codec/avcodec/avutil.h [new file with mode: 0644]
modules/codec/avcodec/chroma.h [new file with mode: 0644]
modules/codec/avcodec/deinterlace.c [new file with mode: 0644]
modules/codec/avcodec/encoder.c [new file with mode: 0644]
modules/codec/avcodec/fourcc.h [new file with mode: 0644]
modules/codec/avcodec/video.c [new file with mode: 0644]
modules/codec/ffmpeg/Modules.am [deleted file]
modules/codec/ffmpeg/audio.c [deleted file]
modules/codec/ffmpeg/avcodec.c [deleted file]
modules/codec/ffmpeg/avcodec.h [deleted file]
modules/codec/ffmpeg/avutil.h [deleted file]
modules/codec/ffmpeg/chroma.h [deleted file]
modules/codec/ffmpeg/deinterlace.c [deleted file]
modules/codec/ffmpeg/encoder.c [deleted file]
modules/codec/ffmpeg/fourcc.h [deleted file]
modules/codec/ffmpeg/video.c [deleted file]
modules/demux/avformat/demux.c
modules/demux/avformat/mux.c
modules/video_filter/imgresample.c
modules/video_filter/swscale.c

index 73ec183..6cadc18 100644 (file)
@@ -5869,9 +5869,9 @@ AC_CONFIG_FILES([
   modules/audio_mixer/Makefile
   modules/audio_output/Makefile
   modules/codec/Makefile
+  modules/codec/avcodec/Makefile
   modules/codec/cmml/Makefile
   modules/codec/dmo/Makefile
-  modules/codec/ffmpeg/Makefile
   modules/codec/subtitles/Makefile
   modules/codec/spudec/Makefile
   modules/codec/xvmc/Makefile
index b3cf15c..7b530e5 100644 (file)
@@ -1,4 +1,4 @@
-SUBDIRS = cmml dmo ffmpeg subtitles spudec xvmc
+SUBDIRS = cmml dmo avcodec subtitles spudec xvmc
 # Disabled modules
 SOURCES_a52 = a52.c
 SOURCES_cinepak = cinepak.c
diff --git a/modules/codec/avcodec/Modules.am b/modules/codec/avcodec/Modules.am
new file mode 100644 (file)
index 0000000..67cfb8a
--- /dev/null
@@ -0,0 +1,40 @@
+SOURCES_avcodec = \
+       avcodec.c \
+       avcodec.h \
+       video.c \
+       audio.c \
+       deinterlace.c \
+       avutil.h \
+       fourcc.h \
+       chroma.h \
+       $(NULL)
+
+if ENABLE_SOUT
+SOURCES_avcodec += encoder.c
+endif
+
+EXTRA_libavcodec_plugin_la_SOURCES = \
+       encoder.c \
+       $(NULL)
+
+libvlc_LTLIBRARIES += \
+       $(LTLIBavcodec)
+
+EXTRA_LTLIBRARIES += \
+       libavcodec_plugin.la
+
+# FIXME SOURCES_ffmpegaltivec = \
+# FIXME        ffmpeg.c \
+# FIXME        ffmpeg.h \
+# FIXME        video.c \
+# FIXME        audio.c \
+# FIXME        video_filter.c \
+# FIXME        deinterlace.c \
+# FIXME        chroma.c \
+# FIXME        encoder.c \
+# FIXME        postprocess.c \
+# FIXME        demux.c \
+# FIXME        mux.c \
+# FIXME        scale.c \
+# FIXME        $(NULL)
+
diff --git a/modules/codec/avcodec/audio.c b/modules/codec/avcodec/audio.c
new file mode 100644 (file)
index 0000000..ca48b90
--- /dev/null
@@ -0,0 +1,360 @@
+/*****************************************************************************
+ * audio.c: audio decoder using ffmpeg library
+ *****************************************************************************
+ * Copyright (C) 1999-2003 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_aout.h>
+#include <vlc_codec.h>
+#include <vlc_input.h>
+
+/* ffmpeg header */
+#ifdef HAVE_LIBAVCODEC_AVCODEC_H
+#   include <libavcodec/avcodec.h>
+#elif defined(HAVE_FFMPEG_AVCODEC_H)
+#   include <ffmpeg/avcodec.h>
+#else
+#   include <avcodec.h>
+#endif
+
+#include "avcodec.h"
+
+static unsigned int pi_channels_maps[7] =
+{
+    0,
+    AOUT_CHAN_CENTER,   AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
+    AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
+    AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
+     | AOUT_CHAN_REARRIGHT,
+    AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
+     | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
+    AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
+     | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
+};
+
+/*****************************************************************************
+ * decoder_sys_t : decoder descriptor
+ *****************************************************************************/
+struct decoder_sys_t
+{
+    FFMPEG_COMMON_MEMBERS
+
+    /* Temporary buffer for libavcodec */
+    uint8_t *p_output;
+
+    /*
+     * Output properties
+     */
+    audio_sample_format_t aout_format;
+    audio_date_t          end_date;
+
+    /*
+     *
+     */
+    uint8_t *p_samples;
+    int     i_samples;
+
+    /* */
+    int     i_reject_count;
+
+    int i_input_rate;
+};
+
+/*****************************************************************************
+ * InitAudioDec: initialize audio decoder
+ *****************************************************************************
+ * The ffmpeg codec will be opened, some memory allocated.
+ *****************************************************************************/
+int InitAudioDec( decoder_t *p_dec, AVCodecContext *p_context,
+                      AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
+{
+    decoder_sys_t *p_sys;
+
+    /* Allocate the memory needed to store the decoder's structure */
+    if( ( p_dec->p_sys = p_sys =
+          (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
+    {
+        msg_Err( p_dec, "out of memory" );
+        return VLC_ENOMEM;
+    }
+
+    p_sys->p_context = p_context;
+    p_sys->p_codec = p_codec;
+    p_sys->i_codec_id = i_codec_id;
+    p_sys->psz_namecodec = psz_namecodec;
+
+    /* ***** Fill p_context with init values ***** */
+    p_sys->p_context->sample_rate = p_dec->fmt_in.audio.i_rate;
+    p_sys->p_context->channels = p_dec->fmt_in.audio.i_channels;
+    if( !p_dec->fmt_in.audio.i_physical_channels )
+    {
+        msg_Warn( p_dec, "Physical channel configuration not set : guessing" );
+        p_dec->fmt_in.audio.i_original_channels =
+            p_dec->fmt_in.audio.i_physical_channels =
+                pi_channels_maps[p_sys->p_context->channels];
+    }
+
+    p_dec->fmt_out.audio.i_physical_channels =
+        p_dec->fmt_out.audio.i_original_channels =
+        p_dec->fmt_in.audio.i_physical_channels;
+
+    p_sys->p_context->block_align = p_dec->fmt_in.audio.i_blockalign;
+    p_sys->p_context->bit_rate = p_dec->fmt_in.i_bitrate;
+    p_sys->p_context->bits_per_sample = p_dec->fmt_in.audio.i_bitspersample;
+
+    if( ( p_sys->p_context->extradata_size = p_dec->fmt_in.i_extra ) > 0 )
+    {
+        int i_offset = 0;
+
+        if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'f', 'l', 'a', 'c' ) )
+            i_offset = 8;
+
+        p_sys->p_context->extradata_size -= i_offset;
+        p_sys->p_context->extradata =
+            malloc( p_sys->p_context->extradata_size +
+                    FF_INPUT_BUFFER_PADDING_SIZE );
+        memcpy( p_sys->p_context->extradata,
+                (char*)p_dec->fmt_in.p_extra + i_offset,
+                p_sys->p_context->extradata_size );
+        memset( (char*)p_sys->p_context->extradata +
+                p_sys->p_context->extradata_size, 0,
+                FF_INPUT_BUFFER_PADDING_SIZE );
+    }
+    else
+        p_sys->p_context->extradata = NULL;
+
+    /* ***** Open the codec ***** */
+    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
+    if( lock == NULL )
+    {
+        free( p_sys->p_context->extradata );
+        free( p_sys );
+        return VLC_ENOMEM;
+    }
+
+    if (avcodec_open( p_sys->p_context, p_sys->p_codec ) < 0)
+    {
+        vlc_mutex_unlock( lock );
+        msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
+        free( p_sys->p_context->extradata );
+        free( p_sys );
+        return VLC_EGENERIC;
+    }
+    vlc_mutex_unlock( lock );
+
+    msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
+
+    p_sys->p_output = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
+    p_sys->p_samples = NULL;
+    p_sys->i_samples = 0;
+    p_sys->i_reject_count = 0;
+    p_sys->i_input_rate = INPUT_RATE_DEFAULT;
+
+    aout_DateSet( &p_sys->end_date, 0 );
+    if( p_dec->fmt_in.audio.i_rate )
+        aout_DateInit( &p_sys->end_date, p_dec->fmt_in.audio.i_rate );
+
+    /* Set output properties */
+    p_dec->fmt_out.i_cat = AUDIO_ES;
+    p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
+    p_dec->fmt_out.audio.i_bitspersample = 16;
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * SplitBuffer: Needed because aout really doesn't like big audio chunk and
+ * wma produces easily > 30000 samples...
+ *****************************************************************************/
+static aout_buffer_t *SplitBuffer( decoder_t *p_dec )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    int i_samples = __MIN( p_sys->i_samples, 4096 );
+    aout_buffer_t *p_buffer;
+
+    if( i_samples == 0 ) return NULL;
+
+    if( ( p_buffer = p_dec->pf_aout_buffer_new( p_dec, i_samples ) ) == NULL )
+    {
+        msg_Err( p_dec, "cannot get aout buffer" );
+        return NULL;
+    }
+
+    p_buffer->start_date = aout_DateGet( &p_sys->end_date );
+    p_buffer->end_date = aout_DateIncrement( &p_sys->end_date,
+                                             i_samples * p_sys->i_input_rate / INPUT_RATE_DEFAULT );
+
+    memcpy( p_buffer->p_buffer, p_sys->p_samples, p_buffer->i_nb_bytes );
+
+    p_sys->p_samples += p_buffer->i_nb_bytes;
+    p_sys->i_samples -= i_samples;
+
+    return p_buffer;
+}
+
+/*****************************************************************************
+ * DecodeAudio: Called to decode one frame
+ *****************************************************************************/
+aout_buffer_t * DecodeAudio ( decoder_t *p_dec, block_t **pp_block )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    int i_used, i_output;
+    aout_buffer_t *p_buffer;
+    block_t *p_block;
+
+    if( !pp_block || !*pp_block ) return NULL;
+
+    p_block = *pp_block;
+
+    if( p_block->i_rate > 0 )
+        p_sys->i_input_rate = p_block->i_rate;
+
+    if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
+    {
+        block_Release( p_block );
+        avcodec_flush_buffers( p_sys->p_context );
+
+        if( p_sys->i_codec_id == CODEC_ID_MP2 || p_sys->i_codec_id == CODEC_ID_MP3 )
+            p_sys->i_reject_count = 3;
+        return NULL;
+    }
+
+    if( p_sys->i_samples > 0 )
+    {
+        /* More data */
+        p_buffer = SplitBuffer( p_dec );
+        if( !p_buffer ) block_Release( p_block );
+        return p_buffer;
+    }
+
+    if( !aout_DateGet( &p_sys->end_date ) && !p_block->i_pts )
+    {
+        /* We've just started the stream, wait for the first PTS. */
+        block_Release( p_block );
+        return NULL;
+    }
+
+    if( p_block->i_buffer <= 0 )
+    {
+        block_Release( p_block );
+        return NULL;
+    }
+    if( p_block->i_buffer > AVCODEC_MAX_AUDIO_FRAME_SIZE )
+    {
+        /* Grow output buffer if necessary (eg. for PCM data) */
+        p_sys->p_output = realloc(p_sys->p_output, p_block->i_buffer);
+    }
+
+    *pp_block = p_block = block_Realloc( p_block, 0, p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE );
+    if( !p_block )
+        return NULL;
+    p_block->i_buffer -= FF_INPUT_BUFFER_PADDING_SIZE;
+    memset( &p_block->p_buffer[p_block->i_buffer], 0, FF_INPUT_BUFFER_PADDING_SIZE );
+
+#if LIBAVCODEC_VERSION_INT >= ((52<<16)+(0<<8)+0)
+    i_output = __MAX( AVCODEC_MAX_AUDIO_FRAME_SIZE, p_block->i_buffer );
+    i_used = avcodec_decode_audio2( p_sys->p_context,
+                                   (int16_t*)p_sys->p_output, &i_output,
+                                   p_block->p_buffer, p_block->i_buffer );
+#else
+    i_used = avcodec_decode_audio( p_sys->p_context,
+                                   (int16_t*)p_sys->p_output, &i_output,
+                                   p_block->p_buffer, p_block->i_buffer );
+#endif
+
+    if( i_used < 0 || i_output < 0 )
+    {
+        if( i_used < 0 )
+            msg_Warn( p_dec, "cannot decode one frame (%d bytes)",
+                      p_block->i_buffer );
+
+        block_Release( p_block );
+        return NULL;
+    }
+    else if( (size_t)i_used > p_block->i_buffer )
+    {
+        i_used = p_block->i_buffer;
+    }
+
+    p_block->i_buffer -= i_used;
+    p_block->p_buffer += i_used;
+
+    if( p_sys->p_context->channels <= 0 || p_sys->p_context->channels > 6 )
+    {
+        msg_Warn( p_dec, "invalid channels count %d",
+                  p_sys->p_context->channels );
+        block_Release( p_block );
+        return NULL;
+    }
+
+    if( p_dec->fmt_out.audio.i_rate != (unsigned int)p_sys->p_context->sample_rate )
+    {
+        aout_DateInit( &p_sys->end_date, p_sys->p_context->sample_rate );
+        aout_DateSet( &p_sys->end_date, p_block->i_pts );
+    }
+
+    /* **** Set audio output parameters **** */
+    p_dec->fmt_out.audio.i_rate     = p_sys->p_context->sample_rate;
+    p_dec->fmt_out.audio.i_channels = p_sys->p_context->channels;
+    p_dec->fmt_out.audio.i_original_channels =
+        p_dec->fmt_out.audio.i_physical_channels =
+            pi_channels_maps[p_sys->p_context->channels];
+
+    if( p_block->i_pts != 0 &&
+        p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
+    {
+        aout_DateSet( &p_sys->end_date, p_block->i_pts );
+    }
+    p_block->i_pts = 0;
+
+    /* **** Now we can output these samples **** */
+    p_sys->i_samples = i_output / sizeof(int16_t) / p_sys->p_context->channels;
+    p_sys->p_samples = p_sys->p_output;
+
+    /* Silent unwanted samples */
+    if( p_sys->i_reject_count > 0 )
+    {
+        memset( p_sys->p_output, 0, i_output );
+        p_sys->i_reject_count--;
+    }
+
+    p_buffer = SplitBuffer( p_dec );
+    if( !p_buffer ) block_Release( p_block );
+    return p_buffer;
+}
+
+/*****************************************************************************
+ * EndAudioDec: audio decoder destruction
+ *****************************************************************************/
+void EndAudioDec( decoder_t *p_dec )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+
+    free( p_sys->p_output );
+}
diff --git a/modules/codec/avcodec/avcodec.c b/modules/codec/avcodec/avcodec.c
new file mode 100644 (file)
index 0000000..0e554da
--- /dev/null
@@ -0,0 +1,356 @@
+/*****************************************************************************
+ * avcodec.c: video and audio decoder and encoder using libavcodec
+ *****************************************************************************
+ * Copyright (C) 1999-2008 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_codec.h>
+
+/* ffmpeg header */
+#define HAVE_MMX 1
+#ifdef HAVE_LIBAVCODEC_AVCODEC_H
+#   include <libavcodec/avcodec.h>
+#elif defined(HAVE_FFMPEG_AVCODEC_H)
+#   include <ffmpeg/avcodec.h>
+#else
+#   include <avcodec.h>
+#endif
+
+#if LIBAVCODEC_BUILD < 5000
+#   error You must have a libavcodec >= 5000 (get svn)
+#endif
+
+#include "avcodec.h"
+#include "fourcc.h"
+#include "avutil.h"
+
+/*****************************************************************************
+ * decoder_sys_t: decoder descriptor
+ *****************************************************************************/
+struct decoder_sys_t
+{
+    /* Common part between video and audio decoder */
+    FFMPEG_COMMON_MEMBERS
+};
+
+/****************************************************************************
+ * Local prototypes
+ ****************************************************************************/
+static int OpenDecoder( vlc_object_t * );
+static void CloseDecoder( vlc_object_t * );
+
+static const int  nloopf_list[] = { 0, 1, 2, 3, 4 };
+static const char *const nloopf_list_text[] =
+  { N_("None"), N_("Non-ref"), N_("Bidir"), N_("Non-key"), N_("All") };
+
+#ifdef ENABLE_SOUT
+static const char *const enc_hq_list[] = { "rd", "bits", "simple" };
+static const char *const enc_hq_list_text[] = {
+    N_("rd"), N_("bits"), N_("simple") };
+#endif
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+#define MODULE_DESCRIPTION N_( "Various audio and video decoders/encoders" \
+        "delivered by the FFmpeg library. This includes (MS)MPEG4, DivX, SV1,"\
+        "H261, H263, H264, WMV, WMA, AAC, AMR, DV, MJPEG and other codecs")
+
+vlc_module_begin();
+    set_shortname( "FFmpeg");
+    add_shortcut( "ffmpeg" );
+    set_category( CAT_INPUT );
+    set_subcategory( SUBCAT_INPUT_SCODEC );
+    /* decoder main module */
+#if defined(MODULE_NAME_is_ffmpegaltivec) \
+     || (defined(CAN_COMPILE_ALTIVEC) && !defined(NO_ALTIVEC_IN_FFMPEG))
+    set_description( N_("AltiVec FFmpeg audio/video decoder ((MS)MPEG4,SVQ1,H263,WMV,WMA)") );
+    /*add_requirement( ALTIVEC );*/
+    set_capability( "decoder", 71 );
+#else
+    set_description( N_("FFmpeg audio/video decoder") );
+    set_help( MODULE_DESCRIPTION );
+    set_capability( "decoder", 70 );
+#endif
+    set_section( N_("Decoding") , NULL );
+    set_callbacks( OpenDecoder, CloseDecoder );
+
+
+    add_bool( "ffmpeg-dr", 1, NULL, DR_TEXT, DR_TEXT, true );
+    add_integer ( "ffmpeg-error-resilience", 1, NULL, ERROR_TEXT,
+        ERROR_LONGTEXT, true );
+    add_integer ( "ffmpeg-workaround-bugs", 1, NULL, BUGS_TEXT, BUGS_LONGTEXT,
+        false );
+    add_bool( "ffmpeg-hurry-up", 1, NULL, HURRYUP_TEXT, HURRYUP_LONGTEXT,
+        false );
+    add_integer( "ffmpeg-skip-frame", 0, NULL, SKIP_FRAME_TEXT,
+        SKIP_FRAME_LONGTEXT, true );
+        change_integer_range( -1, 4 );
+    add_integer( "ffmpeg-skip-idct", 0, NULL, SKIP_IDCT_TEXT,
+        SKIP_IDCT_LONGTEXT, true );
+        change_integer_range( -1, 4 );
+    add_integer ( "ffmpeg-vismv", 0, NULL, VISMV_TEXT, VISMV_LONGTEXT,
+        true );
+    add_integer ( "ffmpeg-lowres", 0, NULL, LOWRES_TEXT, LOWRES_LONGTEXT,
+        true );
+        change_integer_range( 0, 2 );
+    add_integer ( "ffmpeg-skiploopfilter", 0, NULL, SKIPLOOPF_TEXT,
+                  SKIPLOOPF_LONGTEXT, true );
+        change_integer_list( nloopf_list, nloopf_list_text, 0 );
+
+    add_integer( "ffmpeg-debug", 0, NULL, DEBUG_TEXT, DEBUG_LONGTEXT,
+                 true );
+
+#ifdef ENABLE_SOUT
+    /* encoder submodule */
+    add_submodule();
+    set_section( N_("Encoding") , NULL );
+    set_description( N_("FFmpeg audio/video encoder") );
+    set_capability( "encoder", 100 );
+    set_callbacks( OpenEncoder, CloseEncoder );
+
+    add_string( ENC_CFG_PREFIX "hq", "simple", NULL, ENC_HQ_TEXT,
+                ENC_HQ_LONGTEXT, false );
+        change_string_list( enc_hq_list, enc_hq_list_text, 0 );
+    add_integer( ENC_CFG_PREFIX "keyint", 0, NULL, ENC_KEYINT_TEXT,
+                 ENC_KEYINT_LONGTEXT, false );
+    add_integer( ENC_CFG_PREFIX "bframes", 0, NULL, ENC_BFRAMES_TEXT,
+                 ENC_BFRAMES_LONGTEXT, false );
+    add_bool( ENC_CFG_PREFIX "hurry-up", 0, NULL, ENC_HURRYUP_TEXT,
+              ENC_HURRYUP_LONGTEXT, false );
+    add_bool( ENC_CFG_PREFIX "interlace", 0, NULL, ENC_INTERLACE_TEXT,
+              ENC_INTERLACE_LONGTEXT, true );
+    add_bool( ENC_CFG_PREFIX "interlace-me", 1, NULL, ENC_INTERLACE_ME_TEXT,
+              ENC_INTERLACE_ME_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "vt", 0, NULL, ENC_VT_TEXT,
+                 ENC_VT_LONGTEXT, true );
+    add_bool( ENC_CFG_PREFIX "pre-me", 0, NULL, ENC_PRE_ME_TEXT,
+              ENC_PRE_ME_LONGTEXT, true );
+    add_bool( ENC_CFG_PREFIX "strict-rc", 0, NULL, ENC_RC_STRICT_TEXT,
+              ENC_RC_STRICT_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "rc-buffer-size", 224*1024*8, NULL,
+                 ENC_RC_BUF_TEXT, ENC_RC_BUF_LONGTEXT, true );
+    add_float( ENC_CFG_PREFIX "rc-buffer-aggressivity", 1.0, NULL,
+               ENC_RC_BUF_AGGR_TEXT, ENC_RC_BUF_AGGR_LONGTEXT, true );
+    add_float( ENC_CFG_PREFIX "i-quant-factor", 0, NULL,
+               ENC_IQUANT_FACTOR_TEXT, ENC_IQUANT_FACTOR_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "noise-reduction", 0, NULL,
+                 ENC_NOISE_RED_TEXT, ENC_NOISE_RED_LONGTEXT, true );
+    add_bool( ENC_CFG_PREFIX "mpeg4-matrix", 0, NULL,
+              ENC_MPEG4_MATRIX_TEXT, ENC_MPEG4_MATRIX_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "qmin", 0, NULL,
+                 ENC_QMIN_TEXT, ENC_QMIN_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "qmax", 0, NULL,
+                 ENC_QMAX_TEXT, ENC_QMAX_LONGTEXT, true );
+    add_bool( ENC_CFG_PREFIX "trellis", 0, NULL,
+              ENC_TRELLIS_TEXT, ENC_TRELLIS_LONGTEXT, true );
+    add_float( ENC_CFG_PREFIX "qscale", 0, NULL,
+               ENC_QSCALE_TEXT, ENC_QSCALE_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "strict", 0, NULL,
+                 ENC_STRICT_TEXT, ENC_STRICT_LONGTEXT, true );
+    add_float( ENC_CFG_PREFIX "lumi-masking", 0.0, NULL,
+               ENC_LUMI_MASKING_TEXT, ENC_LUMI_MASKING_LONGTEXT, true );
+    add_float( ENC_CFG_PREFIX "dark-masking", 0.0, NULL,
+               ENC_DARK_MASKING_TEXT, ENC_DARK_MASKING_LONGTEXT, true );
+    add_float( ENC_CFG_PREFIX "p-masking", 0.0, NULL,
+               ENC_P_MASKING_TEXT, ENC_P_MASKING_LONGTEXT, true );
+    add_float( ENC_CFG_PREFIX "border-masking", 0.0, NULL,
+               ENC_BORDER_MASKING_TEXT, ENC_BORDER_MASKING_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "luma-elim-threshold", 0, NULL,
+                 ENC_LUMA_ELIM_TEXT, ENC_LUMA_ELIM_LONGTEXT, true );
+    add_integer( ENC_CFG_PREFIX "chroma-elim-threshold", 0, NULL,
+                 ENC_CHROMA_ELIM_TEXT, ENC_CHROMA_ELIM_LONGTEXT, true );
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
+    /* Audio AAC encoder profile */
+    add_string( ENC_CFG_PREFIX "aac-profile", "main", NULL,
+                ENC_PROFILE_TEXT, ENC_PROFILE_LONGTEXT, true );
+#endif
+#endif /* ENABLE_SOUT */
+
+    /* video filter submodule */
+    add_submodule();
+    set_capability( "video filter2", 0 );
+    set_callbacks( OpenDeinterlace, CloseDeinterlace );
+    set_description( N_("FFmpeg deinterlace video filter") );
+    add_shortcut( "ffmpeg-deinterlace" );
+
+vlc_module_end();
+
+/*****************************************************************************
+ * OpenDecoder: probe the decoder and return score
+ *****************************************************************************/
+static int OpenDecoder( vlc_object_t *p_this )
+{
+    decoder_t *p_dec = (decoder_t*) p_this;
+    int i_cat, i_codec_id, i_result;
+    const char *psz_namecodec;
+
+    AVCodecContext *p_context = NULL;
+    AVCodec        *p_codec = NULL;
+
+    /* *** determine codec type *** */
+    if( !GetFfmpegCodec( p_dec->fmt_in.i_codec, &i_cat, &i_codec_id,
+                             &psz_namecodec ) )
+    {
+        return VLC_EGENERIC;
+    }
+
+    /* Bail out if buggy decoder */
+    if( i_codec_id == CODEC_ID_AAC )
+    {
+        msg_Dbg( p_dec, "refusing to use ffmpeg's (%s) decoder which is buggy",
+                 psz_namecodec );
+        return VLC_EGENERIC;
+    }
+
+    /* Initialization must be done before avcodec_find_decoder() */
+    InitLibavcodec(p_this);
+
+    /* *** ask ffmpeg for a decoder *** */
+    p_codec = avcodec_find_decoder( i_codec_id );
+    if( !p_codec )
+    {
+        msg_Dbg( p_dec, "codec not found (%s)", psz_namecodec );
+        return VLC_EGENERIC;
+    }
+
+    /* *** get a p_context *** */
+    p_context = avcodec_alloc_context();
+    if( !p_context )
+        return VLC_ENOMEM;
+    p_context->debug = config_GetInt( p_dec, "ffmpeg-debug" );
+    p_context->opaque = (void *)p_this;
+
+    /* Set CPU capabilities */
+    unsigned i_cpu = vlc_CPU();
+    p_context->dsp_mask = 0;
+    if( !(i_cpu & CPU_CAPABILITY_MMX) )
+    {
+        p_context->dsp_mask |= FF_MM_MMX;
+    }
+    if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
+    {
+        p_context->dsp_mask |= FF_MM_MMXEXT;
+    }
+    if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
+    {
+        p_context->dsp_mask |= FF_MM_3DNOW;
+    }
+    if( !(i_cpu & CPU_CAPABILITY_SSE) )
+    {
+        p_context->dsp_mask |= FF_MM_SSE;
+    }
+    if( !(i_cpu & CPU_CAPABILITY_SSE2) )
+    {
+        p_context->dsp_mask |= FF_MM_SSE2;
+    }
+
+    p_dec->b_need_packetized = true;
+    switch( i_cat )
+    {
+    case VIDEO_ES:
+        p_dec->pf_decode_video = DecodeVideo;
+        i_result =  InitVideoDec ( p_dec, p_context, p_codec,
+                                       i_codec_id, psz_namecodec );
+        break;
+    case AUDIO_ES:
+        p_dec->pf_decode_audio = DecodeAudio;
+        i_result =  InitAudioDec ( p_dec, p_context, p_codec,
+                                       i_codec_id, psz_namecodec );
+        break;
+    default:
+        i_result = VLC_EGENERIC;
+    }
+
+    if( i_result == VLC_SUCCESS ) p_dec->p_sys->i_cat = i_cat;
+
+    return i_result;
+}
+
+/*****************************************************************************
+ * CloseDecoder: decoder destruction
+ *****************************************************************************/
+static void CloseDecoder( vlc_object_t *p_this )
+{
+    decoder_t *p_dec = (decoder_t *)p_this;
+    decoder_sys_t *p_sys = p_dec->p_sys;
+
+    switch( p_sys->i_cat )
+    {
+    case AUDIO_ES:
+         EndAudioDec ( p_dec );
+        break;
+    case VIDEO_ES:
+         EndVideoDec ( p_dec );
+        break;
+    }
+
+    if( p_sys->p_context )
+    {
+        vlc_mutex_t *lock;
+
+        if( p_sys->p_context->extradata )
+            free( p_sys->p_context->extradata );
+        p_sys->p_context->extradata = NULL;
+
+        lock = var_AcquireMutex( "avcodec" );
+        avcodec_close( p_sys->p_context );
+        vlc_mutex_unlock( lock );
+        msg_Dbg( p_dec, "ffmpeg codec (%s) stopped", p_sys->psz_namecodec );
+        av_free( p_sys->p_context );
+    }
+
+    free( p_sys );
+}
+
+void InitLibavcodec( vlc_object_t *p_object )
+{
+    static int b_ffmpeginit = 0;
+    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
+
+    /* *** init ffmpeg library (libavcodec) *** */
+    if( !b_ffmpeginit )
+    {
+        avcodec_init();
+        avcodec_register_all();
+        av_log_set_callback( LibavutilCallback );
+        b_ffmpeginit = 1;
+
+        msg_Dbg( p_object, "libavcodec initialized (interface %d )",
+                 LIBAVCODEC_VERSION_INT );
+    }
+    else
+    {
+        msg_Dbg( p_object, "libavcodec already initialized" );
+    }
+
+    vlc_mutex_unlock( lock );
+}
diff --git a/modules/codec/avcodec/avcodec.h b/modules/codec/avcodec/avcodec.h
new file mode 100644 (file)
index 0000000..c80aa87
--- /dev/null
@@ -0,0 +1,244 @@
+/*****************************************************************************
+ * avcodec.h: decoder and encoder using libavcodec
+ *****************************************************************************
+ * Copyright (C) 2001-2008 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+picture_t * DecodeVideo    ( decoder_t *, block_t ** );
+aout_buffer_t * DecodeAudio( decoder_t *, block_t ** );
+
+/* Video encoder module */
+int  OpenEncoder ( vlc_object_t * );
+void CloseEncoder( vlc_object_t * );
+
+/* Audio encoder module */
+int  OpenAudioEncoder ( vlc_object_t * );
+void CloseAudioEncoder( vlc_object_t * );
+
+/* Deinterlace video filter module */
+int  OpenDeinterlace( vlc_object_t * );
+void CloseDeinterlace( vlc_object_t * );
+
+void InitLibavcodec( vlc_object_t *p_object );
+
+/* Video Decoder */
+int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,
+                  AVCodec *p_codec, int i_codec_id, const char *psz_namecodec );
+void EndVideoDec( decoder_t *p_dec );
+
+/* Audio Decoder */
+int InitAudioDec( decoder_t *p_dec, AVCodecContext *p_context,
+                  AVCodec *p_codec, int i_codec_id, const char *psz_namecodec );
+void EndAudioDec( decoder_t *p_dec );
+
+/*****************************************************************************
+ * Module descriptor help strings
+ *****************************************************************************/
+#define DR_TEXT N_("Direct rendering")
+/* FIXME Does somebody who knows what it does, explain */
+#define DR_LONGTEXT N_("Direct rendering")
+
+#define ERROR_TEXT N_("Error resilience")
+#define ERROR_LONGTEXT N_( \
+    "Ffmpeg can do error resilience.\n" \
+    "However, with a buggy encoder (such as the ISO MPEG-4 encoder from M$) " \
+    "this can produce a lot of errors.\n" \
+    "Valid values range from 0 to 4 (0 disables all errors resilience).")
+
+#define BUGS_TEXT N_("Workaround bugs")
+#define BUGS_LONGTEXT N_( \
+    "Try to fix some bugs:\n" \
+    "1  autodetect\n" \
+    "2  old msmpeg4\n" \
+    "4  xvid interlaced\n" \
+    "8  ump4 \n" \
+    "16 no padding\n" \
+    "32 ac vlc\n" \
+    "64 Qpel chroma.\n" \
+    "This must be the sum of the values. For example, to fix \"ac vlc\" and " \
+    "\"ump4\", enter 40.")
+
+#define HURRYUP_TEXT N_("Hurry up")
+#define HURRYUP_LONGTEXT N_( \
+    "The decoder can partially decode or skip frame(s) " \
+    "when there is not enough time. It's useful with low CPU power " \
+    "but it can produce distorted pictures.")
+
+#define SKIP_FRAME_TEXT N_("Skip frame (default=0)")
+#define SKIP_FRAME_LONGTEXT N_( \
+    "Force skipping of frames to speed up decoding " \
+    "(-1=None, 0=Default, 1=B-frames, 2=P-frames, 3=B+P frames, 4=all frames)." )
+
+#define SKIP_IDCT_TEXT N_("Skip idct (default=0)")
+#define SKIP_IDCT_LONGTEXT N_( \
+    "Force skipping of idct to speed up decoding for frame types" \
+    "(-1=None, 0=Default, 1=B-frames, 2=P-frames, 3=B+P frames, 4=all frames)." )
+
+#define DEBUG_TEXT N_( "Debug mask" )
+#define DEBUG_LONGTEXT N_( "Set ffmpeg debug mask" )
+
+/* TODO: Use a predefined list, with 0,1,2,4,7 */
+#define VISMV_TEXT N_( "Visualize motion vectors" )
+#define VISMV_LONGTEXT N_( \
+    "You can overlay the motion vectors (arrows showing how the images move) "\
+    "on the image. This value is a mask, based on these values:\n"\
+    "1 - visualize forward predicted MVs of P frames\n" \
+    "2 - visualize forward predicted MVs of B frames\n" \
+    "4 - visualize backward predicted MVs of B frames\n" \
+    "To visualize all vectors, the value should be 7." )
+
+#define LOWRES_TEXT N_( "Low resolution decoding" )
+#define LOWRES_LONGTEXT N_( "Only decode a low resolution version of " \
+    "the video. This requires less processing power" )
+
+#define SKIPLOOPF_TEXT N_( "Skip the loop filter for H.264 decoding" )
+#define SKIPLOOPF_LONGTEXT N_( "Skipping the loop filter (aka deblocking) " \
+    "usually has a detrimental effect on quality. However it provides a big " \
+    "speedup for high definition streams." )
+
+/*
+ * Encoder options
+ */
+#define ENC_CFG_PREFIX "sout-ffmpeg-"
+
+#define ENC_KEYINT_TEXT N_( "Ratio of key frames" )
+#define ENC_KEYINT_LONGTEXT N_( "Number of frames " \
+  "that will be coded for one key frame." )
+
+#define ENC_BFRAMES_TEXT N_( "Ratio of B frames" )
+#define ENC_BFRAMES_LONGTEXT N_( "Number of " \
+  "B frames that will be coded between two reference frames." )
+
+#define ENC_VT_TEXT N_( "Video bitrate tolerance" )
+#define ENC_VT_LONGTEXT N_( "Video bitrate tolerance in kbit/s." )
+
+#define ENC_INTERLACE_TEXT N_( "Interlaced encoding" )
+#define ENC_INTERLACE_LONGTEXT N_( "Enable dedicated " \
+  "algorithms for interlaced frames." )
+
+#define ENC_INTERLACE_ME_TEXT N_( "Interlaced motion estimation" )
+#define ENC_INTERLACE_ME_LONGTEXT N_( "Enable interlaced " \
+  "motion estimation algorithms. This requires more CPU." )
+
+#define ENC_PRE_ME_TEXT N_( "Pre-motion estimation" )
+#define ENC_PRE_ME_LONGTEXT N_( "Enable the pre-motion " \
+  "estimation algorithm.")
+
+#define ENC_RC_STRICT_TEXT N_( "Strict rate control" )
+#define ENC_RC_STRICT_LONGTEXT N_( "Enable the strict rate " \
+  "control algorithm." )
+
+#define ENC_RC_BUF_TEXT N_( "Rate control buffer size" )
+#define ENC_RC_BUF_LONGTEXT N_( "Rate control " \
+  "buffer size (in kbytes). A bigger buffer will allow for better rate " \
+  "control, but will cause a delay in the stream." )
+
+#define ENC_RC_BUF_AGGR_TEXT N_( "Rate control buffer aggressiveness" )
+#define ENC_RC_BUF_AGGR_LONGTEXT N_( "Rate control "\
+  "buffer aggressiveness." )
+
+#define ENC_IQUANT_FACTOR_TEXT N_( "I quantization factor" )
+#define ENC_IQUANT_FACTOR_LONGTEXT N_(  \
+  "Quantization factor of I frames, compared with P frames (for instance " \
+  "1.0 => same qscale for I and P frames)." )
+
+#define ENC_NOISE_RED_TEXT N_( "Noise reduction" )
+#define ENC_NOISE_RED_LONGTEXT N_( "Enable a simple noise " \
+  "reduction algorithm to lower the encoding length and bitrate, at the " \
+  "expense of lower quality frames." )
+
+#define ENC_MPEG4_MATRIX_TEXT N_( "MPEG4 quantization matrix" )
+#define ENC_MPEG4_MATRIX_LONGTEXT N_( "Use the MPEG4 " \
+  "quantization matrix for MPEG2 encoding. This generally yields a " \
+  "better looking picture, while still retaining the compatibility with " \
+  "standard MPEG2 decoders.")
+
+#define ENC_HQ_TEXT N_( "Quality level" )
+#define ENC_HQ_LONGTEXT N_( "Quality level " \
+  "for the encoding of motions vectors (this can slow down the encoding " \
+  "very much)." )
+
+#define ENC_HURRYUP_TEXT N_( "Hurry up" )
+#define ENC_HURRYUP_LONGTEXT N_( "The encoder " \
+  "can make on-the-fly quality tradeoffs if your CPU can't keep up with " \
+  "the encoding rate. It will disable trellis quantization, then the rate " \
+  "distortion of motion vectors (hq), and raise the noise reduction " \
+  "threshold to ease the encoder's task." )
+
+#define ENC_QMIN_TEXT N_( "Minimum video quantizer scale" )
+#define ENC_QMIN_LONGTEXT N_( "Minimum video " \
+  "quantizer scale." )
+
+#define ENC_QMAX_TEXT N_( "Maximum video quantizer scale" )
+#define ENC_QMAX_LONGTEXT N_( "Maximum video " \
+  "quantizer scale." )
+
+#define ENC_TRELLIS_TEXT N_( "Trellis quantization" )
+#define ENC_TRELLIS_LONGTEXT N_( "Enable trellis " \
+  "quantization (rate distortion for block coefficients)." )
+
+#define ENC_QSCALE_TEXT N_( "Fixed quantizer scale" )
+#define ENC_QSCALE_LONGTEXT N_( "A fixed video " \
+  "quantizer scale for VBR encoding (accepted values: 0.01 to 255.0)." )
+
+#define ENC_STRICT_TEXT N_( "Strict standard compliance" )
+#define ENC_STRICT_LONGTEXT N_( "Force a strict standard " \
+  "compliance when encoding (accepted values: -1, 0, 1)." )
+
+#define ENC_LUMI_MASKING_TEXT N_( "Luminance masking" )
+#define ENC_LUMI_MASKING_LONGTEXT N_( "Raise the quantizer for " \
+  "very bright macroblocks (default: 0.0)." )
+
+#define ENC_DARK_MASKING_TEXT N_( "Darkness masking" )
+#define ENC_DARK_MASKING_LONGTEXT N_( "Raise the quantizer for " \
+  "very dark macroblocks (default: 0.0)." )
+
+#define ENC_P_MASKING_TEXT N_( "Motion masking" )
+#define ENC_P_MASKING_LONGTEXT N_( "Raise the quantizer for " \
+  "macroblocks with a high temporal complexity (default: 0.0)." )
+
+#define ENC_BORDER_MASKING_TEXT N_( "Border masking" )
+#define ENC_BORDER_MASKING_LONGTEXT N_( "Raise the quantizer " \
+  "for macroblocks at the border of the frame (default: 0.0)." )
+
+#define ENC_LUMA_ELIM_TEXT N_( "Luminance elimination" )
+#define ENC_LUMA_ELIM_LONGTEXT N_( "Eliminates luminance blocks when " \
+  "the PSNR isn't much changed (default: 0.0). The H264 specification " \
+  "recommends -4." )
+
+#define ENC_CHROMA_ELIM_TEXT N_( "Chrominance elimination" )
+#define ENC_CHROMA_ELIM_LONGTEXT N_( "Eliminates chrominance blocks when " \
+  "the PSNR isn't much changed (default: 0.0). The H264 specification " \
+  "recommends 7." )
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
+#define ENC_PROFILE_TEXT N_( "Specify AAC audio profile to use" )
+#define ENC_PROFILE_LONGTEXT N_( "Specify the AAC audio profile to use " \
+   "for encoding the audio bitstream. It takes the following options: " \
+   "main, low, ssr (not supported) and ltp (default: main)" )
+#endif
+
+#define FFMPEG_COMMON_MEMBERS   \
+    int i_cat;                  \
+    int i_codec_id;             \
+    const char *psz_namecodec;  \
+    AVCodecContext *p_context;  \
+    AVCodec        *p_codec;
+
diff --git a/modules/codec/avcodec/avutil.h b/modules/codec/avcodec/avutil.h
new file mode 100644 (file)
index 0000000..d7e5548
--- /dev/null
@@ -0,0 +1,80 @@
+/*****************************************************************************
+ * avutil.h: avutil helper functions
+ *****************************************************************************
+ * Copyright (C) 1999-2008 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Export libavutil messages to the VLC message system
+ *****************************************************************************/
+void LibavutilCallback( void *p_opaque, int i_level,
+                        const char *psz_format, va_list va )
+{
+    int i_vlc_level;
+    AVCodecContext *p_avctx = (AVCodecContext *)p_opaque;
+    AVClass *p_avc;
+    vlc_object_t *p_this;
+    char *psz_new_format;
+    const char *psz_item_name;
+
+    p_avc = p_avctx ? p_avctx->av_class : 0;
+
+#define cln p_avc->class_name
+    /* Make sure we can get p_this back */
+    if( !p_avctx || !p_avc || !cln ||
+        cln[0]!='A' || cln[1]!='V' || cln[2]!='C' || cln[3]!='o' ||
+        cln[4]!='d' || cln[5]!='e' || cln[6]!='c' )
+    {
+        if( i_level == AV_LOG_ERROR ) vfprintf( stderr, psz_format, va );
+        return;
+    }
+#undef cln
+
+    p_this = (vlc_object_t *)p_avctx->opaque;
+
+    switch( i_level )
+    {
+    case AV_LOG_QUIET:
+        i_vlc_level = VLC_MSG_ERR;
+        break;
+    case AV_LOG_ERROR:
+        i_vlc_level = VLC_MSG_WARN;
+        break;
+    case AV_LOG_INFO:
+        i_vlc_level = VLC_MSG_DBG;
+        break;
+    case AV_LOG_DEBUG:
+        /* Print debug messages if they were requested */
+        if( p_avctx->debug ) vfprintf( stderr, psz_format, va );
+        return;
+    default:
+        return;
+    }
+
+    psz_item_name = p_avc->item_name(p_opaque);
+    psz_new_format = malloc( strlen(psz_format) + strlen(psz_item_name)
+                              + 18 + 5 );
+    snprintf( psz_new_format, strlen(psz_format) + strlen(psz_item_name)
+              + 18 + 5, "%s (%s@%p)", psz_format, p_avc->item_name(p_opaque), p_opaque );
+    msg_GenericVa( p_this, i_vlc_level,
+                    MODULE_STRING, psz_new_format, va );
+    free( psz_new_format );
+}
diff --git a/modules/codec/avcodec/chroma.h b/modules/codec/avcodec/chroma.h
new file mode 100644 (file)
index 0000000..f538761
--- /dev/null
@@ -0,0 +1,99 @@
+/*****************************************************************************
+ * chroma.h: libavutil <-> libvlc conversion routines
+ *****************************************************************************
+ * Copyright (C) 1999-2008 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Chroma fourcc -> ffmpeg_id mapping
+ *****************************************************************************/
+static struct
+{
+    vlc_fourcc_t  i_chroma;
+    int  i_chroma_id;
+
+} chroma_table[] =
+{
+    /* Planar YUV formats */
+    { VLC_FOURCC('Y','U','V','A'), PIX_FMT_YUV444P }, /* Hack */
+    { VLC_FOURCC('I','4','4','4'), PIX_FMT_YUV444P },
+    { VLC_FOURCC('J','4','4','4'), PIX_FMT_YUVJ444P },
+    { VLC_FOURCC('I','4','2','2'), PIX_FMT_YUV422P },
+    { VLC_FOURCC('J','4','2','2'), PIX_FMT_YUVJ422P },
+    { VLC_FOURCC('I','4','2','0'), PIX_FMT_YUV420P },
+    { VLC_FOURCC('Y','V','1','2'), PIX_FMT_YUV420P },
+    { VLC_FOURCC('I','Y','U','V'), PIX_FMT_YUV420P },
+    { VLC_FOURCC('J','4','2','0'), PIX_FMT_YUVJ420P },
+    { VLC_FOURCC('I','4','1','1'), PIX_FMT_YUV411P },
+    { VLC_FOURCC('I','4','1','0'), PIX_FMT_YUV410P },
+    { VLC_FOURCC('Y','V','U','9'), PIX_FMT_YUV410P },
+
+    /* Packed YUV formats */
+    { VLC_FOURCC('Y','U','Y','2'), PIX_FMT_YUV422 },
+    { VLC_FOURCC('Y','U','Y','V'), PIX_FMT_YUV422 },
+    { VLC_FOURCC('U','Y','V','Y'), PIX_FMT_UYVY422 },
+
+    /* Packed RGB formats */
+#if defined(WORDS_BIGENDIAN)
+    { VLC_FOURCC('R','G','B','8'), PIX_FMT_BGR8 },
+    { VLC_FOURCC('R','V','1','5'), PIX_FMT_BGR555 },
+    { VLC_FOURCC('R','V','1','6'), PIX_FMT_BGR565 },
+    { VLC_FOURCC('R','V','2','4'), PIX_FMT_BGR24 },
+#else
+#if defined(PIX_FMT_RGB8)
+    { VLC_FOURCC('R','G','B','8'), PIX_FMT_RGB8 },
+#endif
+    { VLC_FOURCC('R','V','1','5'), PIX_FMT_RGB555 },
+    { VLC_FOURCC('R','V','1','6'), PIX_FMT_RGB565 },
+    { VLC_FOURCC('R','V','2','4'), PIX_FMT_RGB24 },
+#endif
+    { VLC_FOURCC('R','V','3','2'), PIX_FMT_RGBA32 },
+#if defined(PIX_FMT_RGBA)
+    { VLC_FOURCC('R','G','B','A'), PIX_FMT_RGBA },
+#endif
+    { VLC_FOURCC('G','R','E','Y'), PIX_FMT_GRAY8 },
+
+    { 0, 0 }
+};
+
+static int GetFfmpegChroma( vlc_fourcc_t i_chroma )
+{
+    int i;
+
+    for( i = 0; chroma_table[i].i_chroma != 0; i++ )
+    {
+        if( chroma_table[i].i_chroma == i_chroma )
+            return chroma_table[i].i_chroma_id;
+    }
+    return -1;
+}
+
+static vlc_fourcc_t GetVlcChroma( int i_ffmpeg_chroma )
+{
+    int i;
+
+    for( i = 0; chroma_table[i].i_chroma != 0; i++ )
+    {
+        if( chroma_table[i].i_chroma_id == i_ffmpeg_chroma )
+            return chroma_table[i].i_chroma;
+    }
+    return 0;
+}
diff --git a/modules/codec/avcodec/deinterlace.c b/modules/codec/avcodec/deinterlace.c
new file mode 100644 (file)
index 0000000..c9299c2
--- /dev/null
@@ -0,0 +1,159 @@
+/*****************************************************************************
+ * video filter: video filter doing chroma conversion and resizing
+ *               using the ffmpeg library
+ *****************************************************************************
+ * Copyright (C) 1999-2001 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_codec.h>
+#include <vlc_vout.h>
+#include <vlc_filter.h>
+
+/* ffmpeg header */
+#ifdef HAVE_LIBAVCODEC_AVCODEC_H
+#   include <libavcodec/avcodec.h>
+#elif defined(HAVE_FFMPEG_AVCODEC_H)
+#   include <ffmpeg/avcodec.h>
+#else
+#   include <avcodec.h>
+#endif
+
+#include "avcodec.h"
+#include "chroma.h"
+
+static picture_t *Deinterlace( filter_t *p_filter, picture_t *p_pic );
+
+/*****************************************************************************
+ * filter_sys_t : filter descriptor
+ *****************************************************************************/
+struct filter_sys_t
+{
+    bool b_resize;
+    bool b_convert;
+    bool b_resize_first;
+    bool b_enable_croppadd;
+
+    es_format_t fmt_in;
+    int i_src_ffmpeg_chroma;
+    es_format_t fmt_out;
+    int i_dst_ffmpeg_chroma;
+
+    AVPicture tmp_pic;
+};
+
+/*****************************************************************************
+ * OpenDeinterlace: probe the filter and return score
+ *****************************************************************************/
+int OpenDeinterlace( vlc_object_t *p_this )
+{
+    filter_t *p_filter = (filter_t*)p_this;
+    filter_sys_t *p_sys;
+
+    /* Check if we can handle that formats */
+    if( GetFfmpegChroma( p_filter->fmt_in.video.i_chroma ) < 0 )
+    {
+        return VLC_EGENERIC;
+    }
+
+    /* Allocate the memory needed to store the decoder's structure */
+    if( ( p_filter->p_sys = p_sys =
+          (filter_sys_t *)malloc(sizeof(filter_sys_t)) ) == NULL )
+    {
+        msg_Err( p_filter, "out of memory" );
+        return VLC_EGENERIC;
+    }
+
+    /* Misc init */
+    p_sys->i_src_ffmpeg_chroma =
+        GetFfmpegChroma( p_filter->fmt_in.video.i_chroma );
+    p_filter->pf_video_filter = Deinterlace;
+
+    msg_Dbg( p_filter, "deinterlacing" );
+
+    /* libavcodec needs to be initialized for some chroma conversions */
+    InitLibavcodec(p_this);
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * CloseDeinterlace: clean up the filter
+ *****************************************************************************/
+void CloseDeinterlace( vlc_object_t *p_this )
+{
+    filter_t *p_filter = (filter_t*)p_this;
+    filter_sys_t *p_sys = p_filter->p_sys;
+
+    free( p_sys );
+}
+
+/*****************************************************************************
+ * Do the processing here
+ *****************************************************************************/
+static picture_t *Deinterlace( filter_t *p_filter, picture_t *p_pic )
+{
+    filter_sys_t *p_sys = p_filter->p_sys;
+    AVPicture src_pic, dest_pic;
+    picture_t *p_pic_dst;
+    int i, i_res = -1;
+
+    /* Request output picture */
+    p_pic_dst = p_filter->pf_vout_buffer_new( p_filter );
+    if( !p_pic_dst )
+        return NULL;
+
+    /* Prepare the AVPictures for the conversion */
+    for( i = 0; i < p_pic->i_planes; i++ )
+    {
+        src_pic.data[i] = p_pic->p[i].p_pixels;
+        src_pic.linesize[i] = p_pic->p[i].i_pitch;
+    }
+    for( i = 0; i < p_pic_dst->i_planes; i++ )
+    {
+        dest_pic.data[i] = p_pic_dst->p[i].p_pixels;
+        dest_pic.linesize[i] = p_pic_dst->p[i].i_pitch;
+    }
+
+    i_res = avpicture_deinterlace( &dest_pic, &src_pic, p_sys->i_src_ffmpeg_chroma,
+                                   p_filter->fmt_in.video.i_width,
+                                   p_filter->fmt_in.video.i_height );
+    if( i_res == -1 )
+    {
+        msg_Err( p_filter, "deinterlacing picture failed" );
+        p_filter->pf_vout_buffer_del( p_filter, p_pic_dst );
+        return NULL;
+    }
+    p_pic_dst->date = p_pic->date;
+    p_pic_dst->b_force = p_pic->b_force;
+    p_pic_dst->i_nb_fields = p_pic->i_nb_fields;
+    p_pic_dst->b_progressive = true;
+    p_pic_dst->b_top_field_first = p_pic->b_top_field_first;
+
+    p_pic->pf_release( p_pic );
+    return p_pic_dst;
+}
diff --git a/modules/codec/avcodec/encoder.c b/modules/codec/avcodec/encoder.c
new file mode 100644 (file)
index 0000000..7adeb0f
--- /dev/null
@@ -0,0 +1,1103 @@
+/*****************************************************************************
+ * encoder.c: video and audio encoder using the ffmpeg library
+ *****************************************************************************
+ * Copyright (C) 1999-2004 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *          Christophe Massiot <massiot@via.ecp.fr>
+ * Part of the file Copyright (C) FFMPEG Project Developers
+ * (mpeg4_default matrixes)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_vout.h>
+#include <vlc_aout.h>
+#include <vlc_sout.h>
+#include <vlc_codec.h>
+#include <vlc_interface.h>
+
+/* ffmpeg header */
+#define HAVE_MMX 1
+#ifdef HAVE_LIBAVCODEC_AVCODEC_H
+#   include <libavcodec/avcodec.h>
+#elif defined(HAVE_FFMPEG_AVCODEC_H)
+#   include <ffmpeg/avcodec.h>
+#else
+#   include <avcodec.h>
+#endif
+
+#include "avcodec.h"
+#include "chroma.h"
+#include "fourcc.h"
+
+#define HURRY_UP_GUARD1 (450000)
+#define HURRY_UP_GUARD2 (300000)
+#define HURRY_UP_GUARD3 (100000)
+
+#define MAX_FRAME_DELAY (FF_MAX_B_FRAMES + 2)
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+int  OpenEncoder ( vlc_object_t * );
+void CloseEncoder( vlc_object_t * );
+
+static block_t *EncodeVideo( encoder_t *, picture_t * );
+static block_t *EncodeAudio( encoder_t *, aout_buffer_t * );
+
+struct thread_context_t;
+static int FfmpegThread( struct thread_context_t *p_context );
+static int FfmpegExecute( AVCodecContext *s,
+                          int (*pf_func)(AVCodecContext *c2, void *arg2),
+                          void **arg, int *ret, int count );
+
+/*****************************************************************************
+ * thread_context_t : for multithreaded encoding
+ *****************************************************************************/
+struct thread_context_t
+{
+    VLC_COMMON_MEMBERS
+
+    AVCodecContext  *p_context;
+    int             (* pf_func)(AVCodecContext *c, void *arg);
+    void            *arg;
+    int             i_ret;
+
+    vlc_mutex_t     lock;
+    vlc_cond_t      cond;
+    bool            b_work, b_done;
+};
+
+/*****************************************************************************
+ * encoder_sys_t : ffmpeg encoder descriptor
+ *****************************************************************************/
+struct encoder_sys_t
+{
+    /*
+     * Ffmpeg properties
+     */
+    AVCodec         *p_codec;
+    AVCodecContext  *p_context;
+
+    /*
+     * Common properties
+     */
+    char *p_buffer;
+    char *p_buffer_out;
+
+    /*
+     * Video properties
+     */
+    mtime_t i_last_ref_pts;
+    mtime_t i_buggy_pts_detect;
+    mtime_t i_last_pts;
+    bool    b_inited;
+
+    /*
+     * Audio properties
+     */
+    int i_frame_size;
+    int i_samples_delay;
+    mtime_t i_pts;
+
+    /* Encoding settings */
+    int        i_key_int;
+    int        i_b_frames;
+    int        i_vtolerance;
+    int        i_qmin;
+    int        i_qmax;
+    int        i_hq;
+    bool       b_strict_rc;
+    int        i_rc_buffer_size;
+    float      f_rc_buffer_aggressivity;
+    bool       b_pre_me;
+    bool       b_hurry_up;
+    bool       b_interlace, b_interlace_me;
+    float      f_i_quant_factor;
+    int        i_noise_reduction;
+    bool       b_mpeg4_matrix;
+    bool       b_trellis;
+    int        i_quality; /* for VBR */
+    float      f_lumi_masking, f_dark_masking, f_p_masking, f_border_masking;
+    int        i_luma_elim, i_chroma_elim;
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
+    int        i_aac_profile; /* AAC profile to use.*/
+#endif
+    /* Used to work around stupid timestamping behaviour in libavcodec */
+    uint64_t i_framenum;
+    mtime_t  pi_delay_pts[MAX_FRAME_DELAY];
+};
+
+static const char *const ppsz_enc_options[] = {
+    "keyint", "bframes", "vt", "qmin", "qmax", "hq", "strict-rc",
+    "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
+    "interlace", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
+    "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
+    "p-masking", "border-masking", "luma-elim-threshold",
+    "chroma-elim-threshold",
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
+     "aac-profile",
+#endif
+     NULL
+};
+
+static const uint16_t mpa_bitrate_tab[2][15] =
+{
+    {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
+    {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
+};
+
+static const uint16_t mpa_freq_tab[6] =
+{ 44100, 48000, 32000, 22050, 24000, 16000 };
+
+static const uint16_t mpeg4_default_intra_matrix[64] = {
+  8, 17, 18, 19, 21, 23, 25, 27,
+ 17, 18, 19, 21, 23, 25, 27, 28,
+ 20, 21, 22, 23, 24, 26, 28, 30,
+ 21, 22, 23, 24, 26, 28, 30, 32,
+ 22, 23, 24, 26, 28, 30, 32, 35,
+ 23, 24, 26, 28, 30, 32, 35, 38,
+ 25, 26, 28, 30, 32, 35, 38, 41,
+ 27, 28, 30, 32, 35, 38, 41, 45,
+};
+
+static const uint16_t mpeg4_default_non_intra_matrix[64] = {
+ 16, 17, 18, 19, 20, 21, 22, 23,
+ 17, 18, 19, 20, 21, 22, 23, 24,
+ 18, 19, 20, 21, 22, 23, 24, 25,
+ 19, 20, 21, 22, 23, 24, 26, 27,
+ 20, 21, 22, 23, 25, 26, 27, 28,
+ 21, 22, 23, 24, 26, 27, 28, 30,
+ 22, 23, 24, 26, 27, 28, 30, 31,
+ 23, 24, 25, 27, 28, 30, 31, 33,
+};
+
+/*****************************************************************************
+ * OpenEncoder: probe the encoder
+ *****************************************************************************/
+
+int OpenEncoder( vlc_object_t *p_this )
+{
+    encoder_t *p_enc = (encoder_t *)p_this;
+    encoder_sys_t *p_sys = p_enc->p_sys;
+    AVCodecContext *p_context;
+    AVCodec *p_codec;
+    int i_codec_id, i_cat;
+    const char *psz_namecodec;
+    vlc_value_t val;
+
+    if( !GetFfmpegCodec( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
+                             &psz_namecodec ) )
+    {
+        if( GetFfmpegChroma( p_enc->fmt_out.i_codec ) < 0 )
+        {
+            /* handed chroma output */
+            return VLC_EGENERIC;
+        }
+        i_cat      = VIDEO_ES;
+        i_codec_id = CODEC_ID_RAWVIDEO;
+        psz_namecodec = "Raw video";
+    }
+
+    if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
+    {
+        msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
+        intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
+                        _("\"%s\" is no video encoder."), psz_namecodec );
+        return VLC_EGENERIC;
+    }
+
+    if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
+    {
+        msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
+        intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
+                        _("\"%s\" is no audio encoder."), psz_namecodec );
+        return VLC_EGENERIC;
+    }
+
+    /* Initialization must be done before avcodec_find_encoder() */
+    InitLibavcodec( p_this );
+
+    p_codec = avcodec_find_encoder( i_codec_id );
+    if( !p_codec )
+    {
+        msg_Err( p_enc, "cannot find encoder %s", psz_namecodec );
+        intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
+                        _("VLC could not find encoder \"%s\"."), psz_namecodec );
+        return VLC_EGENERIC;
+    }
+
+    /* Allocate the memory needed to store the encoder's structure */
+    if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
+    {
+        msg_Err( p_enc, "out of memory" );
+        return VLC_EGENERIC;
+    }
+    memset( p_sys, 0, sizeof(encoder_sys_t) );
+    p_enc->p_sys = p_sys;
+    p_sys->p_codec = p_codec;
+
+    p_enc->pf_encode_video = EncodeVideo;
+    p_enc->pf_encode_audio = EncodeAudio;
+
+    p_sys->p_buffer_out = NULL;
+    p_sys->p_buffer = NULL;
+
+    p_sys->p_context = p_context = avcodec_alloc_context();
+    p_context->debug = config_GetInt( p_enc, "ffmpeg-debug" );
+    p_context->opaque = (void *)p_this;
+
+    /* Set CPU capabilities */
+    unsigned i_cpu = vlc_CPU();
+    p_context->dsp_mask = 0;
+    if( !(i_cpu & CPU_CAPABILITY_MMX) )
+    {
+        p_context->dsp_mask |= FF_MM_MMX;
+    }
+    if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
+    {
+        p_context->dsp_mask |= FF_MM_MMXEXT;
+    }
+    if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
+    {
+        p_context->dsp_mask |= FF_MM_3DNOW;
+    }
+    if( !(i_cpu & CPU_CAPABILITY_SSE) )
+    {
+        p_context->dsp_mask |= FF_MM_SSE;
+        p_context->dsp_mask |= FF_MM_SSE2;
+    }
+
+    config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
+
+    var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
+    p_sys->i_key_int = val.i_int;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
+    p_sys->i_b_frames = val.i_int;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
+    p_sys->i_vtolerance = val.i_int * 1000;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
+    p_sys->b_interlace = val.b_bool;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "interlace-me", &val );
+    p_sys->b_interlace_me = val.b_bool;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
+    p_sys->b_pre_me = val.b_bool;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
+    p_sys->b_hurry_up = val.b_bool;
+    if( p_sys->b_hurry_up )
+    {
+        /* hurry up mode needs noise reduction, even small */
+        p_sys->i_noise_reduction = 1;
+    }
+
+    var_Get( p_enc, ENC_CFG_PREFIX "strict-rc", &val );
+    p_sys->b_strict_rc = val.b_bool;
+    var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
+    p_sys->i_rc_buffer_size = val.i_int;
+    var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
+    p_sys->f_rc_buffer_aggressivity = val.f_float;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
+    p_sys->f_i_quant_factor = val.f_float;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
+    p_sys->i_noise_reduction = val.i_int;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
+    p_sys->b_mpeg4_matrix = val.b_bool;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
+    if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
+    p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
+
+    var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
+    p_sys->i_hq = FF_MB_DECISION_RD;
+    if( val.psz_string && *val.psz_string )
+    {
+        if( !strcmp( val.psz_string, "rd" ) )
+            p_sys->i_hq = FF_MB_DECISION_RD;
+        else if( !strcmp( val.psz_string, "bits" ) )
+            p_sys->i_hq = FF_MB_DECISION_BITS;
+        else if( !strcmp( val.psz_string, "simple" ) )
+            p_sys->i_hq = FF_MB_DECISION_SIMPLE;
+        else
+            p_sys->i_hq = FF_MB_DECISION_RD;
+    }
+    else
+        p_sys->i_hq = FF_MB_DECISION_RD;
+    free( val.psz_string );
+
+    var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
+    p_sys->i_qmin = val.i_int;
+    var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
+    p_sys->i_qmax = val.i_int;
+    var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
+    p_sys->b_trellis = val.b_bool;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
+    if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
+    p_context->strict_std_compliance = val.i_int;
+
+    var_Get( p_enc, ENC_CFG_PREFIX "lumi-masking", &val );
+    p_sys->f_lumi_masking = val.f_float;
+    var_Get( p_enc, ENC_CFG_PREFIX "dark-masking", &val );
+    p_sys->f_dark_masking = val.f_float;
+    var_Get( p_enc, ENC_CFG_PREFIX "p-masking", &val );
+    p_sys->f_p_masking = val.f_float;
+    var_Get( p_enc, ENC_CFG_PREFIX "border-masking", &val );
+    p_sys->f_border_masking = val.f_float;
+    var_Get( p_enc, ENC_CFG_PREFIX "luma-elim-threshold", &val );
+    p_sys->i_luma_elim = val.i_int;
+    var_Get( p_enc, ENC_CFG_PREFIX "chroma-elim-threshold", &val );
+    p_sys->i_chroma_elim = val.i_int;
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
+    var_Get( p_enc, ENC_CFG_PREFIX "aac-profile", &val );
+    p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
+    if( val.psz_string && *val.psz_string )
+    {
+        if( !strncmp( val.psz_string, "main", 4 ) )
+            p_sys->i_aac_profile = FF_PROFILE_AAC_MAIN;
+        else if( !strncmp( val.psz_string, "low", 3 ) )
+            p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
+#if 0    /* Not supported by FAAC encoder */
+        else if( !strncmp( val.psz_string, "ssr", 3 ) )
+            p_sys->i_aac_profile = FF_PROFILE_AAC_SSR;
+#endif
+        else  if( !strncmp( val.psz_string, "ltp", 3 ) )
+            p_sys->i_aac_profile = FF_PROFILE_AAC_LTP;
+        else
+        {
+            msg_Warn( p_enc, "unknown AAC profile requested" );
+            p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
+        }
+    }
+    free( val.psz_string );
+#endif
+
+    if( p_enc->fmt_in.i_cat == VIDEO_ES )
+    {
+        int i_aspect_num, i_aspect_den;
+
+        if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
+        {
+            msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
+                      p_enc->fmt_in.video.i_height );
+            free( p_sys );
+            return VLC_EGENERIC;
+        }
+
+        p_context->width = p_enc->fmt_in.video.i_width;
+        p_context->height = p_enc->fmt_in.video.i_height;
+        if( p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v')
+             && (p_context->width > 720 || p_context->height > 576) )
+            p_context->level = 4; /* High level */
+
+        p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
+        p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
+
+        /* Defaults from ffmpeg.c */
+        p_context->qblur = 0.5;
+        p_context->qcompress = 0.5;
+        p_context->b_quant_offset = 1.25;
+        p_context->b_quant_factor = 1.25;
+        p_context->i_quant_offset = 0.0;
+        p_context->i_quant_factor = -0.8;
+
+        p_context->lumi_masking = p_sys->f_lumi_masking;
+        p_context->dark_masking = p_sys->f_dark_masking;
+        p_context->p_masking = p_sys->f_p_masking;
+        p_context->border_masking = p_sys->f_border_masking;
+        p_context->luma_elim_threshold = p_sys->i_luma_elim;
+        p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
+
+        if( p_sys->i_key_int > 0 )
+            p_context->gop_size = p_sys->i_key_int;
+        p_context->max_b_frames =
+            __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
+        p_context->b_frame_strategy = 0;
+        if( !p_context->max_b_frames  &&
+            (  p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v') ||
+               p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
+            p_context->flags |= CODEC_FLAG_LOW_DELAY;
+
+        av_reduce( &i_aspect_num, &i_aspect_den,
+                   p_enc->fmt_in.video.i_aspect,
+                   VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
+        av_reduce( &p_context->sample_aspect_ratio.num,
+                   &p_context->sample_aspect_ratio.den,
+                   i_aspect_num * (int64_t)p_context->height,
+                   i_aspect_den * (int64_t)p_context->width, 1 << 30 );
+
+        p_sys->p_buffer_out = malloc( p_context->height * p_context->width * 3 );
+
+        p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
+        p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
+        if( p_codec->pix_fmts )
+        {
+            const enum PixelFormat *p = p_codec->pix_fmts;
+            for( ; *p != -1; p++ )
+            {
+                if( *p == p_context->pix_fmt ) break;
+            }
+            if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
+            p_enc->fmt_in.i_codec = GetVlcChroma( p_context->pix_fmt );
+        }
+
+        if ( p_sys->b_strict_rc )
+        {
+            p_context->rc_qsquish = 1.0;
+            p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
+            p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
+            p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
+            /* This is from ffmpeg's ffmpeg.c : */
+            p_context->rc_initial_buffer_occupancy
+                = p_sys->i_rc_buffer_size * 3/4;
+            p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
+        }
+
+        if ( p_sys->f_i_quant_factor != 0.0 )
+            p_context->i_quant_factor = p_sys->f_i_quant_factor;
+
+        p_context->noise_reduction = p_sys->i_noise_reduction;
+
+        if ( p_sys->b_mpeg4_matrix )
+        {
+            p_context->intra_matrix = mpeg4_default_intra_matrix;
+            p_context->inter_matrix = mpeg4_default_non_intra_matrix;
+        }
+
+        if ( p_sys->b_pre_me )
+        {
+            p_context->pre_me = 1;
+            p_context->me_pre_cmp = FF_CMP_CHROMA;
+        }
+
+        if ( p_sys->b_interlace )
+        {
+            if ( p_context->height <= 280 )
+            {
+                if ( p_context->height != 16 || p_context->width != 16 )
+                    msg_Warn( p_enc,
+                        "disabling interlaced video because height=%d <= 280",
+                        p_context->height );
+            }
+            else
+            {
+                p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
+                if ( p_sys->b_interlace_me )
+                    p_context->flags |= CODEC_FLAG_INTERLACED_ME;
+            }
+        }
+
+        if ( p_sys->b_trellis )
+            p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
+
+        if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
+            p_context->flags |= CODEC_FLAG_QSCALE;
+
+        if ( p_enc->i_threads >= 1 )
+            p_context->thread_count = p_enc->i_threads;
+
+        if( p_sys->i_vtolerance > 0 )
+            p_context->bit_rate_tolerance = p_sys->i_vtolerance;
+
+        /* usually if someone sets bitrate, he likes more to get that bitrate
+         * over quality should help 'normal' user to get asked bitrate
+         */
+        if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
+        {
+            p_sys->i_qmax = 51;
+            p_sys->i_qmin = 3;
+        }
+
+        if( p_sys->i_qmin > 0 )
+        {
+            p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
+            p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
+        }
+        if( p_sys->i_qmax > 0 )
+        {
+            p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
+            p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
+        }
+        p_context->max_qdiff = 3;
+
+        p_context->mb_decision = p_sys->i_hq;
+
+        if( p_sys->i_quality )
+        {
+            p_context->flags |= CODEC_FLAG_QSCALE;
+            p_context->global_quality = p_sys->i_quality;
+        }
+    }
+    else if( p_enc->fmt_in.i_cat == AUDIO_ES )
+    {
+        /* work around bug in libmp3lame encoding */
+        if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
+            p_enc->fmt_in.audio.i_channels = 2;
+
+        p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
+        p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
+        p_context->channels    = p_enc->fmt_out.audio.i_channels;
+
+        if ( p_enc->fmt_out.i_codec == VLC_FOURCC('m','p','4','a') )
+        {
+            /* XXX: FAAC does resample only when setting the INPUT samplerate
+             * to the desired value (-R option of the faac frontend) */
+            p_enc->fmt_in.audio.i_rate = p_context->sample_rate;
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
+        /* Ignore FF_PROFILE_UNKNOWN */
+        if( p_sys->i_aac_profile >= FF_PROFILE_AAC_MAIN )
+            p_context->profile = p_sys->i_aac_profile;
+#endif
+        }
+    }
+
+    /* Misc parameters */
+    p_context->bit_rate = p_enc->fmt_out.i_bitrate;
+
+    if( i_codec_id == CODEC_ID_RAWVIDEO )
+    {
+        /* XXX: hack: Force same codec (will be handled by transcode) */
+        p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
+        p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
+    }
+
+    /* Make sure we get extradata filled by the encoder */
+    p_context->extradata_size = 0;
+    p_context->extradata = NULL;
+    p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
+
+    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
+
+    if( avcodec_open( p_context, p_codec ) )
+    {
+        vlc_mutex_unlock( lock );
+        if( p_enc->fmt_in.i_cat == AUDIO_ES &&
+             (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
+               || i_codec_id == CODEC_ID_MP3) )
+        {
+            if( p_context->channels > 2 )
+            {
+                p_context->channels = 2;
+                p_enc->fmt_in.audio.i_channels = 2; // FIXME
+                msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
+            }
+
+            if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
+            {
+                int i_frequency, i;
+
+                for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
+                {
+                    if ( p_enc->fmt_out.audio.i_rate
+                            == mpa_freq_tab[i_frequency] )
+                        break;
+                }
+                if ( i_frequency == 6 )
+                {
+                    msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
+                             p_enc->fmt_out.audio.i_rate );
+                    free( p_sys );
+                    return VLC_EGENERIC;
+                }
+
+                for ( i = 1; i < 14; i++ )
+                {
+                    if ( p_enc->fmt_out.i_bitrate / 1000
+                          <= mpa_bitrate_tab[i_frequency / 3][i] )
+                        break;
+                }
+                if ( p_enc->fmt_out.i_bitrate / 1000
+                      != mpa_bitrate_tab[i_frequency / 3][i] )
+                {
+                    msg_Warn( p_enc,
+                              "MPEG audio doesn't support bitrate=%d, using %d",
+                              p_enc->fmt_out.i_bitrate,
+                              mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
+                    p_enc->fmt_out.i_bitrate =
+                        mpa_bitrate_tab[i_frequency / 3][i] * 1000;
+                    p_context->bit_rate = p_enc->fmt_out.i_bitrate;
+                }
+            }
+
+            p_context->codec = NULL;
+            vlc_mutex_lock( lock );
+            if( avcodec_open( p_context, p_codec ) )
+            {
+                vlc_mutex_unlock( lock );
+                msg_Err( p_enc, "cannot open encoder" );
+                intf_UserFatal( p_enc, false,
+                                _("Streaming / Transcoding failed"),
+                                _("VLC could not open the encoder.") );
+                free( p_sys );
+                return VLC_EGENERIC;
+            }
+        }
+        else
+        {
+            msg_Err( p_enc, "cannot open encoder" );
+            intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
+                            _("VLC could not open the encoder.") );
+            free( p_sys );
+            return VLC_EGENERIC;
+        }
+    }
+    vlc_mutex_unlock( lock);
+
+    p_enc->fmt_out.i_extra = p_context->extradata_size;
+    if( p_enc->fmt_out.i_extra )
+    {
+        p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
+        memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
+                p_enc->fmt_out.i_extra );
+    }
+    p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
+
+    if( p_enc->fmt_in.i_cat == AUDIO_ES )
+    {
+        p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
+        p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
+        p_sys->p_buffer = malloc( p_sys->i_frame_size );
+        p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
+    }
+
+    msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
+
+    return VLC_SUCCESS;
+}
+
+/****************************************************************************
+ * Ffmpeg threading system
+ ****************************************************************************/
+static int FfmpegThread( struct thread_context_t *p_context )
+{
+    while ( !p_context->b_die && !p_context->b_error )
+    {
+        vlc_mutex_lock( &p_context->lock );
+        while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
+        {
+            vlc_cond_wait( &p_context->cond, &p_context->lock );
+        }
+        p_context->b_work = 0;
+        vlc_mutex_unlock( &p_context->lock );
+        if ( p_context->b_die || p_context->b_error )
+            break;
+
+        if ( p_context->pf_func )
+        {
+            p_context->i_ret = p_context->pf_func( p_context->p_context,
+                                                   p_context->arg );
+        }
+
+        vlc_mutex_lock( &p_context->lock );
+        p_context->b_done = 1;
+        vlc_cond_signal( &p_context->cond );
+        vlc_mutex_unlock( &p_context->lock );
+    }
+
+    return 0;
+}
+
+static int FfmpegExecute( AVCodecContext *s,
+                          int (*pf_func)(AVCodecContext *c2, void *arg2),
+                          void **arg, int *ret, int count )
+{
+    struct thread_context_t ** pp_contexts =
+                         (struct thread_context_t **)s->thread_opaque;
+    int i;
+
+    /* Note, we can be certain that this is not called with the same
+     * AVCodecContext by different threads at the same time */
+    for ( i = 0; i < count; i++ )
+    {
+        vlc_mutex_lock( &pp_contexts[i]->lock );
+        pp_contexts[i]->arg = arg[i];
+        pp_contexts[i]->pf_func = pf_func;
+        pp_contexts[i]->i_ret = 12345;
+        pp_contexts[i]->b_work = 1;
+        vlc_cond_signal( &pp_contexts[i]->cond );
+        vlc_mutex_unlock( &pp_contexts[i]->lock );
+    }
+    for ( i = 0; i < count; i++ )
+    {
+        vlc_mutex_lock( &pp_contexts[i]->lock );
+        while ( !pp_contexts[i]->b_done )
+        {
+            vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
+        }
+        pp_contexts[i]->b_done = 0;
+        pp_contexts[i]->pf_func = NULL;
+        vlc_mutex_unlock( &pp_contexts[i]->lock );
+
+        if ( ret )
+        {
+            ret[i] = pp_contexts[i]->i_ret;
+        }
+    }
+
+    return 0;
+}
+
+/****************************************************************************
+ * EncodeVideo: the whole thing
+ ****************************************************************************/
+static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
+{
+    encoder_sys_t *p_sys = p_enc->p_sys;
+    AVFrame frame;
+    int i_out, i_plane;
+
+    if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
+    {
+        struct thread_context_t ** pp_contexts;
+        int i;
+
+        p_sys->b_inited = 1;
+        pp_contexts = malloc( sizeof(struct thread_context_t *)
+                                 * p_enc->i_threads );
+        p_sys->p_context->thread_opaque = (void *)pp_contexts;
+
+        for ( i = 0; i < p_enc->i_threads; i++ )
+        {
+            pp_contexts[i] = vlc_object_create( p_enc,
+                                     sizeof(struct thread_context_t) );
+            pp_contexts[i]->p_context = p_sys->p_context;
+            vlc_mutex_init( &pp_contexts[i]->lock );
+            vlc_cond_init( p_enc, &pp_contexts[i]->cond );
+            pp_contexts[i]->b_work = 0;
+            pp_contexts[i]->b_done = 0;
+            if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
+                                    VLC_THREAD_PRIORITY_VIDEO, false ) )
+            {
+                msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
+                return NULL;
+            }
+        }
+
+        p_sys->p_context->execute = FfmpegExecute;
+    }
+
+    memset( &frame, 0, sizeof( AVFrame ) );
+    for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
+    {
+        frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
+        frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
+    }
+
+    /* Let ffmpeg select the frame type */
+    frame.pict_type = 0;
+
+    frame.repeat_pict = p_pict->i_nb_fields - 2;
+    frame.interlaced_frame = !p_pict->b_progressive;
+    frame.top_field_first = !!p_pict->b_top_field_first;
+
+    /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
+    if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
+    {
+        frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
+
+        if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
+        {
+            mtime_t current_date = mdate();
+
+            if ( current_date + HURRY_UP_GUARD3 > frame.pts )
+            {
+                p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
+                p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
+                msg_Dbg( p_enc, "hurry up mode 3" );
+            }
+            else
+            {
+                p_sys->p_context->mb_decision = p_sys->i_hq;
+
+                if ( current_date + HURRY_UP_GUARD2 > frame.pts )
+                {
+                    p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
+                    p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
+                         + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
+                    msg_Dbg( p_enc, "hurry up mode 2" );
+                }
+                else
+                {
+                    if ( p_sys->b_trellis )
+                        p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
+
+                    p_sys->p_context->noise_reduction =
+                        p_sys->i_noise_reduction;
+                }
+            }
+
+            if ( current_date + HURRY_UP_GUARD1 > frame.pts )
+            {
+                frame.pict_type = FF_P_TYPE;
+                /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
+            }
+        }
+    }
+    else
+    {
+        frame.pts = (int64_t)AV_NOPTS_VALUE;
+    }
+
+    if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
+    {
+        if ( p_sys->i_last_pts == frame.pts )
+        {
+            msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
+                      "same PTS (%"PRId64 ")", frame.pts );
+            return NULL;
+        }
+        else if ( p_sys->i_last_pts > frame.pts )
+        {
+            msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
+                      "past (current: %"PRId64 ", last: %"PRId64")",
+                      frame.pts, p_sys->i_last_pts );
+            return NULL;
+        }
+        else
+        {
+            p_sys->i_last_pts = frame.pts;
+        }
+    }
+
+    frame.quality = p_sys->i_quality;
+
+    /* Ugly work-around for stupid libavcodec behaviour */
+    p_sys->i_framenum++;
+    p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
+    frame.pts = p_sys->i_framenum * AV_TIME_BASE *
+        p_enc->fmt_in.video.i_frame_rate_base;
+    frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
+    frame.pts /= p_enc->fmt_in.video.i_frame_rate;
+    /* End work-around */
+
+    i_out = avcodec_encode_video( p_sys->p_context, (uint8_t*)p_sys->p_buffer_out,
+                                  p_sys->p_context->height * p_sys->p_context->width * 3, &frame );
+
+    if( i_out > 0 )
+    {
+        block_t *p_block = block_New( p_enc, i_out );
+        memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
+
+        /* FIXME, 3-2 pulldown is not handled correctly */
+        p_block->i_length = INT64_C(1000000) *
+            p_enc->fmt_in.video.i_frame_rate_base /
+                p_enc->fmt_in.video.i_frame_rate;
+
+        if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
+        {
+            /* No delay -> output pts == input pts */
+            p_block->i_pts = p_block->i_dts = p_pict->date;
+        }
+        else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
+            p_sys->p_context->coded_frame->pts != 0 &&
+            p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
+        {
+            p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
+            p_block->i_pts = p_sys->p_context->coded_frame->pts;
+
+            /* Ugly work-around for stupid libavcodec behaviour */
+            {
+                int64_t i_framenum = p_block->i_pts *
+                    p_enc->fmt_in.video.i_frame_rate /
+                    p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
+
+                p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
+            }
+            /* End work-around */
+
+            if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
+                p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
+            {
+                p_block->i_dts = p_block->i_pts;
+            }
+            else
+            {
+                if( p_sys->i_last_ref_pts )
+                {
+                    p_block->i_dts = p_sys->i_last_ref_pts;
+                }
+                else
+                {
+                    /* Let's put something sensible */
+                    p_block->i_dts = p_block->i_pts;
+                }
+
+                p_sys->i_last_ref_pts = p_block->i_pts;
+            }
+        }
+        else
+        {
+            /* Buggy libavcodec which doesn't update coded_frame->pts
+             * correctly */
+            p_block->i_dts = p_block->i_pts = p_pict->date;
+        }
+
+        switch ( p_sys->p_context->coded_frame->pict_type )
+        {
+        case FF_I_TYPE:
+            p_block->i_flags |= BLOCK_FLAG_TYPE_I;
+            break;
+        case FF_P_TYPE:
+            p_block->i_flags |= BLOCK_FLAG_TYPE_P;
+            break;
+        case FF_B_TYPE:
+            p_block->i_flags |= BLOCK_FLAG_TYPE_B;
+            break;
+        }
+
+        return p_block;
+    }
+
+    return NULL;
+}
+
+/****************************************************************************
+ * EncodeAudio: the whole thing
+ ****************************************************************************/
+static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
+{
+    encoder_sys_t *p_sys = p_enc->p_sys;
+    block_t *p_block, *p_chain = NULL;
+
+    uint8_t *p_buffer = p_aout_buf->p_buffer;
+    int i_samples = p_aout_buf->i_nb_samples;
+    int i_samples_delay = p_sys->i_samples_delay;
+
+    p_sys->i_pts = p_aout_buf->start_date -
+                (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
+                (mtime_t)p_enc->fmt_in.audio.i_rate;
+
+    p_sys->i_samples_delay += i_samples;
+
+    while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
+    {
+        int16_t *p_samples;
+        int i_out;
+
+        if( i_samples_delay )
+        {
+            /* Take care of the left-over from last time */
+            int i_delay_size = i_samples_delay * 2 *
+                                 p_sys->p_context->channels;
+            int i_size = p_sys->i_frame_size - i_delay_size;
+
+            p_samples = (int16_t *)p_sys->p_buffer;
+            memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
+            p_buffer -= i_delay_size;
+            i_samples += i_samples_delay;
+            i_samples_delay = 0;
+        }
+        else
+        {
+            p_samples = (int16_t *)p_buffer;
+        }
+
+        i_out = avcodec_encode_audio( p_sys->p_context,
+                                      (uint8_t *)p_sys->p_buffer_out,
+                                      2 * AVCODEC_MAX_AUDIO_FRAME_SIZE,
+                                      p_samples );
+
+#if 0
+        msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
+#endif
+        if( i_out < 0 ) break;
+
+        p_buffer += p_sys->i_frame_size;
+        p_sys->i_samples_delay -= p_sys->p_context->frame_size;
+        i_samples -= p_sys->p_context->frame_size;
+
+        if( i_out == 0 ) continue;
+
+        p_block = block_New( p_enc, i_out );
+        memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
+
+        p_block->i_length = (mtime_t)1000000 *
+            (mtime_t)p_sys->p_context->frame_size /
+            (mtime_t)p_sys->p_context->sample_rate;
+
+        p_block->i_dts = p_block->i_pts = p_sys->i_pts;
+
+        /* Update pts */
+        p_sys->i_pts += p_block->i_length;
+        block_ChainAppend( &p_chain, p_block );
+    }
+
+    /* Backup the remaining raw samples */
+    if( i_samples )
+    {
+        memcpy( p_sys->p_buffer + i_samples_delay * 2 *
+                p_sys->p_context->channels, p_buffer,
+                i_samples * 2 * p_sys->p_context->channels );
+    }
+
+    return p_chain;
+}
+
+/*****************************************************************************
+ * CloseEncoder: ffmpeg encoder destruction
+ *****************************************************************************/
+void CloseEncoder( vlc_object_t *p_this )
+{
+    encoder_t *p_enc = (encoder_t *)p_this;
+    encoder_sys_t *p_sys = p_enc->p_sys;
+
+    if ( p_sys->b_inited && p_enc->i_threads >= 1 )
+    {
+        int i;
+        struct thread_context_t ** pp_contexts =
+                (struct thread_context_t **)p_sys->p_context->thread_opaque;
+        for ( i = 0; i < p_enc->i_threads; i++ )
+        {
+            vlc_object_kill( pp_contexts[i] );
+            vlc_cond_signal( &pp_contexts[i]->cond );
+            vlc_thread_join( pp_contexts[i] );
+            vlc_mutex_destroy( &pp_contexts[i]->lock );
+            vlc_cond_destroy( &pp_contexts[i]->cond );
+            vlc_object_release( pp_contexts[i] );
+        }
+
+        free( pp_contexts );
+    }
+
+    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
+    avcodec_close( p_sys->p_context );
+    vlc_mutex_unlock( lock );
+    av_free( p_sys->p_context );
+
+    free( p_sys->p_buffer );
+    free( p_sys->p_buffer_out );
+
+    free( p_sys );
+}
diff --git a/modules/codec/avcodec/fourcc.h b/modules/codec/avcodec/fourcc.h
new file mode 100644 (file)
index 0000000..d879480
--- /dev/null
@@ -0,0 +1,1052 @@
+/*****************************************************************************
+ * fourcc.h: libavcodec <-> libvlc conversion routines
+ *****************************************************************************
+ * Copyright (C) 1999-2008 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Codec fourcc -> ffmpeg_id mapping
+ *****************************************************************************/
+static struct
+{
+    vlc_fourcc_t  i_fourcc;
+    int  i_codec;
+    int  i_cat;
+    const char *psz_name;
+
+} codecs_table[] =
+{
+    /*
+     * Video Codecs
+     */
+
+    /* MPEG-1 Video */
+    { VLC_FOURCC('m','p','1','v'), CODEC_ID_MPEG1VIDEO,
+      VIDEO_ES, "MPEG-1 Video" },
+    { VLC_FOURCC('m','p','e','g'), CODEC_ID_MPEG1VIDEO,
+      VIDEO_ES, "MPEG-1 Video" },
+    { VLC_FOURCC('m','p','g','1'), CODEC_ID_MPEG1VIDEO,
+      VIDEO_ES, "MPEG-1 Video" },
+    { VLC_FOURCC('P','I','M','1'), CODEC_ID_MPEG1VIDEO,
+      VIDEO_ES, "Pinnacle DC1000 (MPEG-1 Video)" },
+
+    /* MPEG-2 Video */
+    { VLC_FOURCC('m','p','2','v'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG-2 Video" },
+    { VLC_FOURCC('M','P','E','G'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG-2 Video" },
+    { VLC_FOURCC('m','p','g','v'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG-2 Video" },
+    { VLC_FOURCC('m','p','g','2'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG-2 Video" },
+    { VLC_FOURCC('h','d','v','1'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "HDV 720p30 (MPEG-2 Video)" },
+    { VLC_FOURCC('h','d','v','2'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "Sony HDV (MPEG-2 Video)" },
+    { VLC_FOURCC('h','d','v','3'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "FCP HDV (MPEG-2 Video)" },
+    { VLC_FOURCC('h','d','v','5'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "HDV 720p25 (MPEG-2 Video)" },
+    { VLC_FOURCC('m','x','5','n'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG2 IMX NTSC 525/60 50mb/s (FCP)" },
+    { VLC_FOURCC('m','x','5','p'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG2 IMX PAL 625/60 50mb/s (FCP)" },
+    { VLC_FOURCC('m','x','4','n'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG2 IMX NTSC 525/60 40mb/s (FCP)" },
+    { VLC_FOURCC('m','x','4','p'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG2 IMX PAL 625/50 40mb/s (FCP)" },
+     { VLC_FOURCC('m','x','3','n'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG2 IMX NTSC 525/60 30mb/s (FCP)" },
+    { VLC_FOURCC('m','x','3','p'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "MPEG2 IMX NTSC 625/50 30mb/s (FCP)" },
+    { VLC_FOURCC('x','d','v','2'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "XDCAM HD 1080i60" },
+    { VLC_FOURCC('A','V','m','p'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "AVID IMX PAL" },
+    /* ATI VCR2 */
+    { VLC_FOURCC('V','C','R','2'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "ATI VCR2 Video" },
+    { VLC_FOURCC('M','M','E','S'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "Matrox MPEG-2" },
+    { VLC_FOURCC('m','m','e','s'), CODEC_ID_MPEG2VIDEO,
+      VIDEO_ES, "Matrox MPEG-2" },
+
+    /* MPEG-4 Video */
+    { VLC_FOURCC('D','I','V','X'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('d','i','v','x'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('M','P','4','S'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('m','p','4','s'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('M','4','S','2'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('m','4','s','2'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    /* XVID flavours */
+    { VLC_FOURCC('x','v','i','d'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('X','V','I','D'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('X','v','i','D'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('X','V','I','X'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('x','v','i','x'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    /* DX50 */
+    { VLC_FOURCC('D','X','5','0'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('d','x','5','0'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('B','L','Z','0'), CODEC_ID_MPEG4,
+      VIDEO_ES, "Blizzard MPEG-4 Video" },
+    { VLC_FOURCC('D','X','G','M'), CODEC_ID_MPEG4,
+      VIDEO_ES, "Electronic Arts Game MPEG-4 Video" },
+    { VLC_FOURCC('m','p','4','v'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('M','P','4','V'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC( 4,  0,  0,  0 ), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('m','4','c','c'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('M','4','C','C'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('F','M','P','4'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('f','m','p','4'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    /* 3ivx delta 3.5 Unsupported
+     * putting it here gives extreme distorted images
+    { VLC_FOURCC('3','I','V','1'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('3','i','v','1'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" }, */
+    /* 3ivx delta 4 */
+    { VLC_FOURCC('3','I','V','2'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('3','i','v','2'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('U','M','P','4'), CODEC_ID_MPEG4,
+      VIDEO_ES, "UB MPEG-4 Video" },
+    { VLC_FOURCC('W','V','1','F'), CODEC_ID_MPEG4,
+      VIDEO_ES, "MPEG-4 Video" },
+    { VLC_FOURCC('S','E','D','G'), CODEC_ID_MPEG4,
+      VIDEO_ES, "Samsung MPEG-4 Video" },
+    { VLC_FOURCC('R','M','P','4'), CODEC_ID_MPEG4,
+      VIDEO_ES, "REALmagic MPEG-4 Video" },
+    { VLC_FOURCC('H','D','X','4'), CODEC_ID_MPEG4,
+      VIDEO_ES, "Jomigo HDX4 (MPEG-4 Video)" },
+    { VLC_FOURCC('h','d','x','4'), CODEC_ID_MPEG4,
+      VIDEO_ES, "Jomigo HDX4 (MPEG-4 Video)" },
+    { VLC_FOURCC('S','M','P','4'), CODEC_ID_MPEG4,
+      VIDEO_ES, "Samsung SMP4 (MPEG-4 Video)" },
+    { VLC_FOURCC('f','v','f','w'), CODEC_ID_MPEG4,
+      VIDEO_ES, "FFmpeg MPEG-4" },
+    { VLC_FOURCC('F','V','F','W'), CODEC_ID_MPEG4,
+      VIDEO_ES, "FFmpeg MPEG-4" },
+
+    /* MSMPEG4 v1 */
+    { VLC_FOURCC('D','I','V','1'), CODEC_ID_MSMPEG4V1,
+      VIDEO_ES, "MS MPEG-4 Video v1" },
+    { VLC_FOURCC('d','i','v','1'), CODEC_ID_MSMPEG4V1,
+      VIDEO_ES, "MS MPEG-4 Video v1" },
+    { VLC_FOURCC('M','P','G','4'), CODEC_ID_MSMPEG4V1,
+      VIDEO_ES, "MS MPEG-4 Video v1" },
+    { VLC_FOURCC('m','p','g','4'), CODEC_ID_MSMPEG4V1,
+      VIDEO_ES, "MS MPEG-4 Video v1" },
+
+    /* MSMPEG4 v2 */
+    { VLC_FOURCC('D','I','V','2'), CODEC_ID_MSMPEG4V2,
+      VIDEO_ES, "MS MPEG-4 Video v2" },
+    { VLC_FOURCC('d','i','v','2'), CODEC_ID_MSMPEG4V2,
+      VIDEO_ES, "MS MPEG-4 Video v2" },
+    { VLC_FOURCC('M','P','4','2'), CODEC_ID_MSMPEG4V2,
+      VIDEO_ES, "MS MPEG-4 Video v2" },
+    { VLC_FOURCC('m','p','4','2'), CODEC_ID_MSMPEG4V2,
+      VIDEO_ES, "MS MPEG-4 Video v2" },
+
+    /* MSMPEG4 v3 / M$ mpeg4 v3 */
+    { VLC_FOURCC('M','P','G','3'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('m','p','g','3'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('d','i','v','3'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('M','P','4','3'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('m','p','4','3'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    /* DivX 3.20 */
+    { VLC_FOURCC('D','I','V','3'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('D','I','V','4'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('d','i','v','4'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('D','I','V','5'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('d','i','v','5'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('D','I','V','6'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('d','i','v','6'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    /* Cool Codec */
+    { VLC_FOURCC('C','O','L','1'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('c','o','l','1'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('C','O','L','0'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('c','o','l','0'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    /* AngelPotion stuff */
+    { VLC_FOURCC('A','P','4','1'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    /* 3ivx doctered divx files */
+    { VLC_FOURCC('3','I','V','D'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('3','i','v','d'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    /* who knows? */
+    { VLC_FOURCC('3','V','I','D'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+    { VLC_FOURCC('3','v','i','d'), CODEC_ID_MSMPEG4V3,
+      VIDEO_ES, "MS MPEG-4 Video v3" },
+
+    /* Sorenson v1 */
+    { VLC_FOURCC('S','V','Q','1'), CODEC_ID_SVQ1,
+      VIDEO_ES, "SVQ-1 (Sorenson Video v1)" },
+    { VLC_FOURCC('s','v','q','1'), CODEC_ID_SVQ1,
+      VIDEO_ES, "SVQ-1 (Sorenson Video v1)" },
+    { VLC_FOURCC('s','v','q','i'), CODEC_ID_SVQ1,
+      VIDEO_ES, "SVQ-1 (Sorenson Video v1)" },
+
+    /* Sorenson v3 */
+    { VLC_FOURCC('S','V','Q','3'), CODEC_ID_SVQ3,
+      VIDEO_ES, "SVQ-3 (Sorenson Video v3)" },
+
+    /* h264 */
+    { VLC_FOURCC('h','2','6','4'), CODEC_ID_H264,
+      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
+    { VLC_FOURCC('H','2','6','4'), CODEC_ID_H264,
+      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
+    { VLC_FOURCC('x','2','6','4'), CODEC_ID_H264,
+      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
+    { VLC_FOURCC('X','2','6','4'), CODEC_ID_H264,
+      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
+    /* avc1: special case h264 */
+    { VLC_FOURCC('a','v','c','1'), CODEC_ID_H264,
+      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
+    { VLC_FOURCC('A','V','C','1'), CODEC_ID_H264,
+      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
+    { VLC_FOURCC('V','S','S','H'), CODEC_ID_H264,
+      VIDEO_ES, "Vanguard VSS H264" },
+    { VLC_FOURCC('V','S','S','W'), CODEC_ID_H264,
+      VIDEO_ES, "Vanguard VSS H264" },
+    { VLC_FOURCC('v','s','s','h'), CODEC_ID_H264,
+      VIDEO_ES, "Vanguard VSS H264" },
+    { VLC_FOURCC('D','A','V','C'), CODEC_ID_H264,
+      VIDEO_ES, "Dicas MPEGable H.264/MPEG-4 AVC" },
+    { VLC_FOURCC('d','a','v','c'), CODEC_ID_H264,
+      VIDEO_ES, "Dicas MPEGable H.264/MPEG-4 AVC" },
+
+/* H263 and H263i */
+/* H263(+) is also known as Real Video 1.0 */
+
+    /* H263 */
+    { VLC_FOURCC('D','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "DEC H263" },
+    { VLC_FOURCC('H','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "H263" },
+    { VLC_FOURCC('h','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "H263" },
+    { VLC_FOURCC('L','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "LEAD H263" },
+    { VLC_FOURCC('s','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "H263" },
+    { VLC_FOURCC('S','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "H263" },
+    { VLC_FOURCC('M','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "Microsoft H263" },
+    { VLC_FOURCC('X','2','6','3'), CODEC_ID_H263,
+      VIDEO_ES, "Xirlink H263" },
+
+    /* Zygo (partial) */
+    { VLC_FOURCC('Z','y','G','o'), CODEC_ID_H263,
+      VIDEO_ES, "ITU H263+" },
+
+    /* H263i */
+    { VLC_FOURCC('I','2','6','3'), CODEC_ID_H263I,
+      VIDEO_ES, "I263.I" },
+    { VLC_FOURCC('i','2','6','3'), CODEC_ID_H263I,
+      VIDEO_ES, "I263.I" },
+
+    /* H263P */
+    { VLC_FOURCC('v','i','v','1'), CODEC_ID_H263P,
+      VIDEO_ES, "H263+" },
+    { VLC_FOURCC('v','i','v','O'), CODEC_ID_H263P,
+      VIDEO_ES, "H263+" },
+    { VLC_FOURCC('v','i','v','2'), CODEC_ID_H263P,
+      VIDEO_ES, "H263+" },
+    { VLC_FOURCC('U','2','6','3'), CODEC_ID_H263P,
+      VIDEO_ES, "UB H263+" },
+    { VLC_FOURCC('I','L','V','R'), CODEC_ID_H263P,
+      VIDEO_ES, "ITU H263+" },
+
+    /* Flash (H263) variant */
+    { VLC_FOURCC('F','L','V','1'), CODEC_ID_FLV1,
+      VIDEO_ES, "Flash Video" },
+
+    /* H261 */
+    { VLC_FOURCC('H','2','6','1'), CODEC_ID_H261,
+      VIDEO_ES, "H.261" },
+    { VLC_FOURCC('h','2','6','1'), CODEC_ID_H261,
+      VIDEO_ES, "H.261" },
+
+    { VLC_FOURCC('F','L','I','C'), CODEC_ID_FLIC,
+      VIDEO_ES, "Flic Video" },
+
+    /* MJPEG */
+    { VLC_FOURCC( 'M','J','P','G' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'm','j','p','g' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'm','j','p','a' ), CODEC_ID_MJPEG, /* for mov file */
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'j','p','e','g' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'J','P','E','G' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'J','F','I','F' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'J','P','G','L' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'A','V','D','J' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG Video" },
+    { VLC_FOURCC( 'm','j','p','b' ), CODEC_ID_MJPEGB, /* for mov file */
+      VIDEO_ES, "Motion JPEG B Video" },
+    { VLC_FOURCC( 'L','J','P','G' ), CODEC_ID_LJPEG,
+      VIDEO_ES, "Lead Motion JPEG Video" },
+    { VLC_FOURCC( 'L','J','P','G' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Lead Motion JPEG Video" },
+    /* AVID MJPEG */
+    { VLC_FOURCC( 'A','V','R','n' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Avid Motion JPEG" },
+    { VLC_FOURCC( 'A','D','J','V' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Avid Motion JPEG" },
+    { VLC_FOURCC( 'd','m','b','1' ), CODEC_ID_MJPEG,
+      VIDEO_ES, "Motion JPEG OpenDML Video" },
+
+    /* SP5x */
+    { VLC_FOURCC( 'S','P','5','X' ), CODEC_ID_SP5X,
+      VIDEO_ES, "Sunplus Motion JPEG Video" },
+    { VLC_FOURCC( 'S','P','5','3' ), CODEC_ID_SP5X,
+      VIDEO_ES, "Sunplus Motion JPEG Video" },
+    { VLC_FOURCC( 'S','P','5','4' ), CODEC_ID_SP5X,
+      VIDEO_ES, "Sunplus Motion JPEG Video" },
+    { VLC_FOURCC( 'S','P','5','5' ), CODEC_ID_SP5X,
+      VIDEO_ES, "Sunplus Motion JPEG Video" },
+    { VLC_FOURCC( 'S','P','5','6' ), CODEC_ID_SP5X,
+      VIDEO_ES, "Sunplus Motion JPEG Video" },
+    { VLC_FOURCC( 'S','P','5','7' ), CODEC_ID_SP5X,
+      VIDEO_ES, "Sunplus Motion JPEG Video" },
+    { VLC_FOURCC( 'S','P','5','8' ), CODEC_ID_SP5X,
+      VIDEO_ES, "Sunplus Motion JPEG Video" },
+
+    /* DV */
+    { VLC_FOURCC('d','v','s','l'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video" },
+    { VLC_FOURCC('d','v','s','d'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video" },
+    { VLC_FOURCC('D','V','S','D'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video" },
+    { VLC_FOURCC('d','v','h','d'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video" },
+    { VLC_FOURCC('d','v','c',' '), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video" },
+    { VLC_FOURCC('d','v','c','p'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video PAL" },
+    { VLC_FOURCC('d','v','p',' '), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video Pro" },
+    { VLC_FOURCC('d','v','p','p'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video Pro PAL" },
+    { VLC_FOURCC('C','D','V','C'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video" },
+    { VLC_FOURCC('c','d','v','c'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video" },
+    { VLC_FOURCC('d','v','5','p'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video C Pro 50 PAL" },
+    { VLC_FOURCC('d','v','5','n'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "DV Video C Pro 50 NTSC" },
+    { VLC_FOURCC('A','V','d','v'), CODEC_ID_DVVIDEO,
+      VIDEO_ES, "AVID DV" },
+
+    /* Windows Media Video */
+    { VLC_FOURCC('W','M','V','1'), CODEC_ID_WMV1,
+      VIDEO_ES, "Windows Media Video 1" },
+    { VLC_FOURCC('w','m','v','1'), CODEC_ID_WMV1,
+      VIDEO_ES, "Windows Media Video 1" },
+    { VLC_FOURCC('W','M','V','2'), CODEC_ID_WMV2,
+      VIDEO_ES, "Windows Media Video 2" },
+    { VLC_FOURCC('w','m','v','2'), CODEC_ID_WMV2,
+      VIDEO_ES, "Windows Media Video 2" },
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(10<<8)+1)
+    { VLC_FOURCC('W','M','V','3'), CODEC_ID_WMV3,
+      VIDEO_ES, "Windows Media Video 3" },
+    { VLC_FOURCC('w','m','v','3'), CODEC_ID_WMV3,
+      VIDEO_ES, "Windows Media Video 3" },
+    { VLC_FOURCC('W','V','C','1'), CODEC_ID_VC1,
+      VIDEO_ES, "Windows Media Video VC1" },
+    { VLC_FOURCC('w','v','c','1'), CODEC_ID_VC1,
+      VIDEO_ES, "Windows Media Video VC1" },
+    /* WMVA is the VC-1 codec before the standardization proces,
+       it is not bitstream compatible and deprecated  */
+    { VLC_FOURCC('W','M','V','A'), CODEC_ID_VC1,
+      VIDEO_ES, "Windows Media Video Advanced Profile" },
+#endif
+
+    /* Microsoft Video 1 */
+    { VLC_FOURCC('M','S','V','C'), CODEC_ID_MSVIDEO1,
+      VIDEO_ES, "Microsoft Video 1" },
+    { VLC_FOURCC('m','s','v','c'), CODEC_ID_MSVIDEO1,
+      VIDEO_ES, "Microsoft Video 1" },
+    { VLC_FOURCC('C','R','A','M'), CODEC_ID_MSVIDEO1,
+      VIDEO_ES, "Microsoft Video 1" },
+    { VLC_FOURCC('c','r','a','m'), CODEC_ID_MSVIDEO1,
+      VIDEO_ES, "Microsoft Video 1" },
+    { VLC_FOURCC('W','H','A','M'), CODEC_ID_MSVIDEO1,
+      VIDEO_ES, "Microsoft Video 1" },
+    { VLC_FOURCC('w','h','a','m'), CODEC_ID_MSVIDEO1,
+      VIDEO_ES, "Microsoft Video 1" },
+
+    /* Microsoft RLE */
+    { VLC_FOURCC('m','r','l','e'), CODEC_ID_MSRLE,
+      VIDEO_ES, "Microsoft RLE Video" },
+    { VLC_FOURCC('W','R','L','E'), CODEC_ID_MSRLE,
+      VIDEO_ES, "Microsoft RLE Video" },
+    { VLC_FOURCC(0x1,0x0,0x0,0x0), CODEC_ID_MSRLE,
+      VIDEO_ES, "Microsoft RLE Video" },
+    { VLC_FOURCC(0x2,0x0,0x0,0x0), CODEC_ID_MSRLE,
+      VIDEO_ES, "Microsoft RLE Video" },
+
+    /* Indeo Video Codecs (Quality of this decoder on ppc is not good) */
+    { VLC_FOURCC('I','V','3','1'), CODEC_ID_INDEO3,
+      VIDEO_ES, "Indeo Video v3" },
+    { VLC_FOURCC('i','v','3','1'), CODEC_ID_INDEO3,
+      VIDEO_ES, "Indeo Video v3" },
+    { VLC_FOURCC('I','V','3','2'), CODEC_ID_INDEO3,
+      VIDEO_ES, "Indeo Video v3" },
+    { VLC_FOURCC('i','v','3','2'), CODEC_ID_INDEO3,
+      VIDEO_ES, "Indeo Video v3" },
+
+    /* Huff YUV */
+    { VLC_FOURCC('H','F','Y','U'), CODEC_ID_HUFFYUV,
+      VIDEO_ES, "Huff YUV Video" },
+    { VLC_FOURCC('F','F','V','H'), CODEC_ID_FFVHUFF,
+      VIDEO_ES, "Huff YUV Video" },
+
+    /* Creative YUV */
+    { VLC_FOURCC('C','Y','U','V'), CODEC_ID_CYUV,
+      VIDEO_ES, "Creative YUV Video" },
+    { VLC_FOURCC('c','y','u','v'), CODEC_ID_CYUV,
+      VIDEO_ES, "Creative YUV Video" },
+
+    /* On2 VP3 Video Codecs */
+    { VLC_FOURCC('V','P','3',' '), CODEC_ID_VP3,
+      VIDEO_ES, "On2's VP3 Video" },
+    { VLC_FOURCC('V','P','3','0'), CODEC_ID_VP3,
+      VIDEO_ES, "On2's VP3 Video" },
+    { VLC_FOURCC('V','P','3','1'), CODEC_ID_VP3,
+      VIDEO_ES, "On2's VP3 Video" },
+    { VLC_FOURCC('v','p','3','1'), CODEC_ID_VP3,
+      VIDEO_ES, "On2's VP3 Video" },
+
+    /* On2  VP5, VP6 codecs */
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(14<<8)+0)
+    { VLC_FOURCC('V','P','5',' '), CODEC_ID_VP5,
+      VIDEO_ES, "On2's VP5 Video" },
+    { VLC_FOURCC('V','P','5','0'), CODEC_ID_VP5,
+      VIDEO_ES, "On2's VP5 Video" },
+    { VLC_FOURCC('V','P','6','2'), CODEC_ID_VP6,
+      VIDEO_ES, "On2's VP6.2 Video" },
+    { VLC_FOURCC('v','p','6','2'), CODEC_ID_VP6,
+      VIDEO_ES, "On2's VP6.2 Video" },
+    { VLC_FOURCC('V','P','6','F'), CODEC_ID_VP6F,
+      VIDEO_ES, "On2's VP6.2 Video (Flash)" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(27<<8)+0)
+    { VLC_FOURCC('V','P','6','0'), CODEC_ID_VP6,
+      VIDEO_ES, "On2's VP6.0 Video" },
+    { VLC_FOURCC('V','P','6','1'), CODEC_ID_VP6,
+      VIDEO_ES, "On2's VP6.1 Video" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(47<<8)+0)
+    { VLC_FOURCC('V','P','6','A'), CODEC_ID_VP6A,
+      VIDEO_ES, "On2's VP6 A Video" },
+#endif
+
+    /* Xiph.org theora */
+    { VLC_FOURCC('t','h','e','o'), CODEC_ID_THEORA,
+      VIDEO_ES, "Xiph.org's Theora Video" },
+    { VLC_FOURCC('T','h','r','a'), CODEC_ID_THEORA,
+      VIDEO_ES, "Xiph.org's Theora Video" },
+
+#if ( !defined( WORDS_BIGENDIAN ) )
+    /* Asus Video (Another thing that doesn't work on PPC) */
+    { VLC_FOURCC('A','S','V','1'), CODEC_ID_ASV1,
+      VIDEO_ES, "Asus V1 Video" },
+    { VLC_FOURCC('A','S','V','2'), CODEC_ID_ASV2,
+      VIDEO_ES, "Asus V2 Video" },
+#endif
+
+    /* FFMPEG Video 1 (lossless codec) */
+    { VLC_FOURCC('F','F','V','1'), CODEC_ID_FFV1,
+      VIDEO_ES, "FFMpeg Video 1" },
+
+    /* ATI VCR1 */
+    { VLC_FOURCC('V','C','R','1'), CODEC_ID_VCR1,
+      VIDEO_ES, "ATI VCR1 Video" },
+
+    /* Cirrus Logic AccuPak */
+    { VLC_FOURCC('C','L','J','R'), CODEC_ID_CLJR,
+      VIDEO_ES, "Creative Logic AccuPak" },
+
+    /* Real Video */
+    { VLC_FOURCC('R','V','1','0'), CODEC_ID_RV10,
+      VIDEO_ES, "Real Video 10" },
+    { VLC_FOURCC('r','v','1','0'), CODEC_ID_RV10,
+      VIDEO_ES, "Real Video 10" },
+    { VLC_FOURCC('R','V','1','3'), CODEC_ID_RV10,
+      VIDEO_ES, "Real Video 13" },
+    { VLC_FOURCC('r','v','1','3'), CODEC_ID_RV10,
+      VIDEO_ES, "Real Video 13" },
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(15<<8)+1)
+    { VLC_FOURCC('R','V','2','0'), CODEC_ID_RV20,
+      VIDEO_ES, "Real Video 20" },
+    { VLC_FOURCC('r','v','2','0'), CODEC_ID_RV20,
+      VIDEO_ES, "Real Video 20" },
+#endif
+
+    /* Apple Video */
+    { VLC_FOURCC('r','p','z','a'), CODEC_ID_RPZA,
+      VIDEO_ES, "Apple Video" },
+    { VLC_FOURCC('a','z','p','r'), CODEC_ID_RPZA,
+      VIDEO_ES, "Apple Video" },
+
+    { VLC_FOURCC('s','m','c',' '), CODEC_ID_SMC,
+      VIDEO_ES, "Apple graphics" },
+
+ /* CINEPAK. We have our own decoder with an higher priority,
+       but this can't harm */
+    { VLC_FOURCC('C','V','I','D'), CODEC_ID_CINEPAK,
+      VIDEO_ES, "Cinepak Video" },
+    { VLC_FOURCC('c','v','i','d'), CODEC_ID_CINEPAK,
+      VIDEO_ES, "Cinepak Video" },
+
+    /* Screen Capture Video Codecs */
+    { VLC_FOURCC('t','s','c','c'), CODEC_ID_TSCC,
+      VIDEO_ES, "TechSmith Camtasia Screen Capture Video" },
+    { VLC_FOURCC('T','S','C','C'), CODEC_ID_TSCC,
+      VIDEO_ES, "TechSmith Camtasia Screen Capture Video" },
+
+    { VLC_FOURCC('C','S','C','D'), CODEC_ID_CSCD,
+      VIDEO_ES, "CamStudio Screen Codec" },
+    { VLC_FOURCC('c','s','c','d'), CODEC_ID_CSCD,
+      VIDEO_ES, "CamStudio Screen Codec" },
+
+    { VLC_FOURCC('Z','M','B','V'), CODEC_ID_ZMBV,
+      VIDEO_ES, "DosBox Capture Codec" },
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(13<<8)+0)
+    { VLC_FOURCC('V','M','n','c'), CODEC_ID_VMNC,
+      VIDEO_ES, "VMware Video" },
+#endif
+    { VLC_FOURCC('F','P','S','1'), CODEC_ID_FRAPS,
+      VIDEO_ES, "FRAPS: Realtime Video Capture" },
+    { VLC_FOURCC('f','p','s','1'), CODEC_ID_FRAPS,
+      VIDEO_ES, "FRAPS: Realtime Video Capture" },
+
+    /* Duck TrueMotion */
+    { VLC_FOURCC('D','U','C','K'), CODEC_ID_TRUEMOTION1,
+      VIDEO_ES, "Duck TrueMotion v1 Video" },
+    { VLC_FOURCC('T','M','2','0'), CODEC_ID_TRUEMOTION2,
+      VIDEO_ES, "Duck TrueMotion v2.0 Video" },
+
+    /* FFMPEG's SNOW wavelet codec */
+    { VLC_FOURCC('S','N','O','W'), CODEC_ID_SNOW,
+      VIDEO_ES, "FFMpeg SNOW wavelet Video" },
+    { VLC_FOURCC('s','n','o','w'), CODEC_ID_SNOW,
+      VIDEO_ES, "FFMpeg SNOW wavelet Video" },
+
+    { VLC_FOURCC('r','l','e',' '), CODEC_ID_QTRLE,
+      VIDEO_ES, "Apple QuickTime RLE Video" },
+
+    { VLC_FOURCC('q','d','r','w'), CODEC_ID_QDRAW,
+      VIDEO_ES, "Apple QuickDraw Video" },
+
+    { VLC_FOURCC('Q','P','E','G'), CODEC_ID_QPEG,
+      VIDEO_ES, "QPEG Video" },
+    { VLC_FOURCC('Q','1','.','0'), CODEC_ID_QPEG,
+      VIDEO_ES, "QPEG Video" },
+    { VLC_FOURCC('Q','1','.','1'), CODEC_ID_QPEG,
+      VIDEO_ES, "QPEG Video" },
+
+    { VLC_FOURCC('U','L','T','I'), CODEC_ID_ULTI,
+      VIDEO_ES, "IBM Ultimotion Video" },
+
+    { VLC_FOURCC('V','I','X','L'), CODEC_ID_VIXL,
+      VIDEO_ES, "Miro/Pinnacle VideoXL Video" },
+    { VLC_FOURCC('P','I','X','L'), CODEC_ID_VIXL,
+      VIDEO_ES, "Pinnacle VideoXL Video" },
+
+    { VLC_FOURCC('L','O','C','O'), CODEC_ID_LOCO,
+      VIDEO_ES, "LOCO Video" },
+
+    { VLC_FOURCC('W','N','V','1'), CODEC_ID_WNV1,
+      VIDEO_ES, "Winnov WNV1 Video" },
+
+    { VLC_FOURCC('A','A','S','C'), CODEC_ID_AASC,
+      VIDEO_ES, "Autodesc RLE Video" },
+
+    { VLC_FOURCC('I','V','2','0'), CODEC_ID_INDEO2,
+      VIDEO_ES, "Indeo Video v2" },
+    { VLC_FOURCC('R','T','2','1'), CODEC_ID_INDEO2,
+      VIDEO_ES, "Indeo Video v2" },
+
+        /* Flash Screen Video */
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(11<<8)+0)
+    { VLC_FOURCC('F','S','V','1'), CODEC_ID_FLASHSV,
+              VIDEO_ES, "Flash Screen Video" },
+#endif
+   { VLC_FOURCC('K','M','V','C'), CODEC_ID_KMVC,
+      VIDEO_ES, "Karl Morton's Video Codec (Worms)" },
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(13<<8)+0)
+    { VLC_FOURCC('N','U','V','1'), CODEC_ID_NUV,
+      VIDEO_ES, "Nuppel Video" },
+    { VLC_FOURCC('R','J','P','G'), CODEC_ID_NUV,
+      VIDEO_ES, "Nuppel Video" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(8<<8)+0)
+    /* CODEC_ID_SMACKVIDEO */
+    { VLC_FOURCC('S','M','K','2'), CODEC_ID_SMACKVIDEO,
+      VIDEO_ES, "Smacker Video" },
+    { VLC_FOURCC('S','M','K','4'), CODEC_ID_SMACKVIDEO,
+      VIDEO_ES, "Smacker Video" },
+#endif
+
+    /* Chinese AVS - Untested */
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(8<<8)+0)
+    { VLC_FOURCC('C','A','V','S'), CODEC_ID_CAVS,
+      VIDEO_ES, "Chinese AVS" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+0)
+    /* Untested yet */
+    { VLC_FOURCC('A','V','d','n'), CODEC_ID_DNXHD,
+      VIDEO_ES, "DNxHD" },
+#endif
+    { VLC_FOURCC('8','B','P','S'), CODEC_ID_8BPS,
+      VIDEO_ES, "8BPS" },
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(52<<8)+0)
+    { VLC_FOURCC('M','L','2','O'), CODEC_ID_MIMIC,
+      VIDEO_ES, "Mimic" },
+#endif
+
+    /* Videogames Codecs */
+
+    /* Interplay MVE */
+    { VLC_FOURCC('i','m','v','e'), CODEC_ID_INTERPLAY_VIDEO,
+      VIDEO_ES, "Interplay MVE Video" },
+    { VLC_FOURCC('I','N','P','V'), CODEC_ID_INTERPLAY_VIDEO,
+      VIDEO_ES, "Interplay MVE Video" },
+
+    /* Id Quake II CIN */
+    { VLC_FOURCC('I','D','C','I'), CODEC_ID_IDCIN,
+      VIDEO_ES, "Id Quake II CIN Video" },
+
+    /* 4X Technologies */
+    { VLC_FOURCC('4','x','m','v'), CODEC_ID_4XM,
+      VIDEO_ES, "4X Technologies Video" },
+    { VLC_FOURCC('4','X','M','V'), CODEC_ID_4XM,
+      VIDEO_ES, "4X Technologies Video" },
+
+    /* Id RoQ */
+    { VLC_FOURCC('R','o','Q','v'), CODEC_ID_ROQ,
+      VIDEO_ES, "Id RoQ Video" },
+
+    /* Sony Playstation MDEC */
+    { VLC_FOURCC('M','D','E','C'), CODEC_ID_MDEC,
+      VIDEO_ES, "PSX MDEC Video" },
+
+    /* Sierra VMD */
+    { VLC_FOURCC('v','m','d','v'), CODEC_ID_VMDVIDEO,
+      VIDEO_ES, "Sierra VMD Video" },
+    { VLC_FOURCC('V','M','D','V'), CODEC_ID_VMDVIDEO,
+      VIDEO_ES, "Sierra VMD Video" },
+
+#if 0
+/*    UNTESTED VideoGames*/
+    { VLC_FOURCC('W','C','3','V'), CODEC_ID_XAN_WC3,
+      VIDEO_ES, "XAN wc3 Video" },
+    { VLC_FOURCC('W','C','4','V'), CODEC_ID_XAN_WC4,
+      VIDEO_ES, "XAN wc4 Video" },
+    { VLC_FOURCC('S','T','3','C'), CODEC_ID_TXD,
+      VIDEO_ES, "Renderware TeXture Dictionary" },
+    { VLC_FOURCC('V','Q','A','V'), CODEC_ID_WS_VQA,
+      VIDEO_ES, "WestWood Vector Quantized Animation" },
+    { VLC_FOURCC('T','S','E','Q'), CODEC_ID_TIERTEXSEQVIDEO,
+      VIDEO_ES, "Tiertex SEQ Video" },
+    { VLC_FOURCC('D','X','A','1'), CODEC_ID_DXA,
+      VIDEO_ES, "Feeble DXA Video" },
+    { VLC_FOURCC('D','C','I','V'), CODEC_ID_DSICINVIDEO,
+      VIDEO_ES, "Delphine CIN Video" },
+    { VLC_FOURCC('T','H','P','V'), CODEC_ID_THP,
+      VIDEO_ES, "THP Video" },
+    { VLC_FOURCC('B','E','T','H'), CODEC_ID_BETHSOFTVID,
+      VIDEO_ES, "THP Video" },
+    { VLC_FOURCC('C','9','3','V'), CODEC_ID_C93,
+      VIDEO_ES, "THP Video" },
+#endif
+
+    /*
+     *  Image codecs
+     */
+    { VLC_FOURCC('p','n','g',' '), CODEC_ID_PNG,
+      VIDEO_ES, "PNG Image" },
+    { VLC_FOURCC('p','p','m',' '), CODEC_ID_PPM,
+      VIDEO_ES, "PPM Image" },
+    { VLC_FOURCC('p','g','m',' '), CODEC_ID_PGM,
+      VIDEO_ES, "PGM Image" },
+    { VLC_FOURCC('p','g','m','y'), CODEC_ID_PGMYUV,
+      VIDEO_ES, "PGM YUV Image" },
+    { VLC_FOURCC('p','a','m',' '), CODEC_ID_PAM,
+      VIDEO_ES, "PAM Image" },
+    { VLC_FOURCC('M','J','L','S'), CODEC_ID_JPEGLS,
+      VIDEO_ES, "PAM Image" },
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(0<<8)+0)
+    { VLC_FOURCC('b','m','p',' '), CODEC_ID_BMP,
+      VIDEO_ES, "BMP Image" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+1)
+    { VLC_FOURCC('t','i','f','f'), CODEC_ID_TIFF,
+      VIDEO_ES, "TIFF Image" },
+    { VLC_FOURCC('g','i','f',' '), CODEC_ID_GIF,
+      VIDEO_ES, "GIF Image" },
+    { VLC_FOURCC('t','g','a',' '), CODEC_ID_TARGA,
+      VIDEO_ES, "Truevision Targa Image" },
+    { VLC_FOURCC('m','t','g','a'), CODEC_ID_TARGA,
+      VIDEO_ES, "Truevision Targa Image" },
+    { VLC_FOURCC('M','T','G','A'), CODEC_ID_TARGA,
+      VIDEO_ES, "Truevision Targa Image" },
+#endif
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+3)
+    { VLC_FOURCC('s','g','i',' '), CODEC_ID_SGI,
+      VIDEO_ES, "SGI Image" },
+#endif
+
+    /*
+     *  Audio Codecs
+     */
+
+    /* Windows Media Audio 1 */
+    { VLC_FOURCC('W','M','A','1'), CODEC_ID_WMAV1,
+      AUDIO_ES, "Windows Media Audio 1" },
+    { VLC_FOURCC('w','m','a','1'), CODEC_ID_WMAV1,
+      AUDIO_ES, "Windows Media Audio 1" },
+
+    /* Windows Media Audio 2 */
+    { VLC_FOURCC('W','M','A','2'), CODEC_ID_WMAV2,
+      AUDIO_ES, "Windows Media Audio 2" },
+    { VLC_FOURCC('w','m','a','2'), CODEC_ID_WMAV2,
+      AUDIO_ES, "Windows Media Audio 2" },
+
+    /* DV Audio */
+    { VLC_FOURCC('d','v','a','u'), CODEC_ID_DVAUDIO,
+      AUDIO_ES, "DV Audio" },
+
+    /* MACE-3 Audio */
+    { VLC_FOURCC('M','A','C','3'), CODEC_ID_MACE3,
+      AUDIO_ES, "MACE-3 Audio" },
+
+    /* MACE-6 Audio */
+    { VLC_FOURCC('M','A','C','6'), CODEC_ID_MACE6,
+      AUDIO_ES, "MACE-6 Audio" },
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(41<<8)+1)
+    /* MUSEPACK7 Audio */
+    { VLC_FOURCC('M','P','C',' '), CODEC_ID_MUSEPACK7,
+      AUDIO_ES, "MUSEPACK7 Audio" },
+#endif
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(48<<8)+0)
+    /* MUSEPACK8 Audio */
+    { VLC_FOURCC('M','P','C','K'), CODEC_ID_MUSEPACK8,
+      AUDIO_ES, "MUSEPACK8 Audio" },
+    { VLC_FOURCC('M','P','C','8'), CODEC_ID_MUSEPACK8,
+      AUDIO_ES, "MUSEPACK8 Audio" },
+#endif
+
+    /* RealAudio 1.0 */
+    { VLC_FOURCC('1','4','_','4'), CODEC_ID_RA_144,
+      AUDIO_ES, "RealAudio 1.0" },
+    { VLC_FOURCC('l','p','c','J'), CODEC_ID_RA_144,
+      AUDIO_ES, "RealAudio 1.0" },
+
+    /* RealAudio 2.0 */
+    { VLC_FOURCC('2','8','_','8'), CODEC_ID_RA_288,
+      AUDIO_ES, "RealAudio 2.0" },
+
+    /* MPEG Audio layer 1/2/3 */
+    { VLC_FOURCC('m','p','g','a'), CODEC_ID_MP2,
+      AUDIO_ES, "MPEG Audio layer 1/2" },
+    { VLC_FOURCC('m','p','3',' '), CODEC_ID_MP3,
+      AUDIO_ES, "MPEG Audio layer 1/2/3" },
+    { VLC_FOURCC('.','m','p','3'), CODEC_ID_MP3,
+      AUDIO_ES, "MPEG Audio layer 1/2/3" },
+    { VLC_FOURCC('M','P','3',' '), CODEC_ID_MP3,
+      AUDIO_ES, "MPEG Audio layer 1/2/3" },
+    { VLC_FOURCC('L','A','M','E'), CODEC_ID_MP3,
+      AUDIO_ES, "MPEG Audio layer 1/2/3" },
+
+    /* A52 Audio (aka AC3) */
+    { VLC_FOURCC('a','5','2',' '), CODEC_ID_AC3,
+      AUDIO_ES, "A52 Audio (aka AC3)" },
+    { VLC_FOURCC('a','5','2','b'), CODEC_ID_AC3, /* VLC specific hack */
+      AUDIO_ES, "A52 Audio (aka AC3)" },
+
+    /* DTS Audio */
+    { VLC_FOURCC('d','t','s',' '), CODEC_ID_DTS,
+      AUDIO_ES, "DTS Audio" },
+
+    /* AAC audio */
+    { VLC_FOURCC('m','p','4','a'), CODEC_ID_AAC,
+      AUDIO_ES, "MPEG AAC Audio" },
+
+    /* AC-3 Audio (Dolby Digital) */
+    { VLC_FOURCC('a','c','-','3'), CODEC_ID_AC3,
+      AUDIO_ES, "AC-3 Audio (Dolby Digital)" },
+
+    /* 4X Technologies */
+    { VLC_FOURCC('4','x','m','a'), CODEC_ID_ADPCM_4XM,
+      AUDIO_ES, "4X Technologies Audio" },
+
+    /* EA ADPCM */
+    { VLC_FOURCC('A','D','E','A'), CODEC_ID_ADPCM_EA,
+      AUDIO_ES, "EA ADPCM Audio" },
+
+    /* Interplay DPCM */
+    { VLC_FOURCC('i','d','p','c'), CODEC_ID_INTERPLAY_DPCM,
+      AUDIO_ES, "Interplay DPCM Audio" },
+
+    /* Id RoQ */
+    { VLC_FOURCC('R','o','Q','a'), CODEC_ID_ROQ_DPCM,
+      AUDIO_ES, "Id RoQ DPCM Audio" },
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(27<<8)+0)
+    /* DCIN Audio */
+    { VLC_FOURCC('D','C','I','A'), CODEC_ID_DSICINAUDIO,
+      AUDIO_ES, "Delphine CIN Audio" },
+#endif
+
+    /* Sony Playstation XA ADPCM */
+    { VLC_FOURCC('x','a',' ',' '), CODEC_ID_ADPCM_XA,
+      AUDIO_ES, "PSX XA ADPCM Audio" },
+
+    /* ADX ADPCM */
+    { VLC_FOURCC('a','d','x',' '), CODEC_ID_ADPCM_ADX,
+      AUDIO_ES, "ADX ADPCM Audio" },
+
+    /* Westwood ADPCM */
+    { VLC_FOURCC('A','I','W','S'), CODEC_ID_ADPCM_IMA_WS,
+      AUDIO_ES, "Westwood IMA ADPCM audio" },
+
+    /* Sierra VMD */
+    { VLC_FOURCC('v','m','d','a'), CODEC_ID_VMDAUDIO,
+      AUDIO_ES, "Sierra VMD Audio" },
+
+    /* G.726 ADPCM */
+    { VLC_FOURCC('g','7','2','6'), CODEC_ID_ADPCM_G726,
+      AUDIO_ES, "G.726 ADPCM Audio" },
+
+    /* AMR */
+    { VLC_FOURCC('s','a','m','r'), CODEC_ID_AMR_NB,
+      AUDIO_ES, "AMR narrow band" },
+    { VLC_FOURCC('s','a','w','b'), CODEC_ID_AMR_WB,
+      AUDIO_ES, "AMR wide band" },
+
+    /* FLAC */
+    { VLC_FOURCC('f','l','a','c'), CODEC_ID_FLAC,
+      AUDIO_ES, "FLAC (Free Lossless Audio Codec)" },
+
+    /* ALAC */
+    { VLC_FOURCC('a','l','a','c'), CODEC_ID_ALAC,
+      AUDIO_ES, "Apple Lossless Audio Codec" },
+
+#if LIBAVCODEC_VERSION_INT >= ((50<<16)+(0<<8)+1)
+    /* QDM2 */
+    { VLC_FOURCC('Q','D','M','2'), CODEC_ID_QDM2,
+      AUDIO_ES, "QDM2 Audio" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(0<<8)+0)
+    /* COOK */
+    { VLC_FOURCC('c','o','o','k'), CODEC_ID_COOK,
+      AUDIO_ES, "Cook Audio" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(4<<8)+0)
+    /* TTA: The Lossless True Audio */
+    { VLC_FOURCC('T','T','A','1'), CODEC_ID_TTA,
+      AUDIO_ES, "The Lossless True Audio" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(8<<8)+0)
+    /* Shorten */
+    { VLC_FOURCC('s','h','n',' '), CODEC_ID_SHORTEN,
+      AUDIO_ES, "Shorten Lossless Audio" },
+    { VLC_FOURCC('s','h','r','n'), CODEC_ID_SHORTEN,
+      AUDIO_ES, "Shorten Lossless Audio" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(16<<8)+0)
+    { VLC_FOURCC('w','v','p','k'), CODEC_ID_WAVPACK,
+      AUDIO_ES, "WavPack" },
+    { VLC_FOURCC('W','V','P','K'), CODEC_ID_WAVPACK,
+      AUDIO_ES, "WavPack" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(34<<8)+0)
+    { VLC_FOURCC('g','s','m',' '), CODEC_ID_GSM,
+      AUDIO_ES, "GSM Audio" },
+    { VLC_FOURCC('g','s','m','s'), CODEC_ID_GSM_MS,
+      AUDIO_ES, "Microsoft GSM Audio" },
+#endif
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
+    { VLC_FOURCC('a','t','r','c'), CODEC_ID_ATRAC3,
+      AUDIO_ES, "atrac 3" },
+    { VLC_FOURCC(0x70,0x2,0x0,0x0), CODEC_ID_ATRAC3,
+      AUDIO_ES, "atrac 3" },
+#endif
+
+    { VLC_FOURCC('S','O','N','C'), CODEC_ID_SONIC,
+      AUDIO_ES, "Sonic" },
+
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(34<<8)+0)
+    { VLC_FOURCC(0x1,0x4,0x0,0x0), CODEC_ID_IMC,
+      AUDIO_ES, "IMC" },
+#endif
+    { VLC_FOURCC(0x22,0x0,0x0,0x0), CODEC_ID_TRUESPEECH,
+      AUDIO_ES, "TrueSpeech" },
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(46<<8)+0)
+    { VLC_FOURCC('N','E','L','L'), CODEC_ID_NELLYMOSER,
+      AUDIO_ES, "NellyMoser ASAO" },
+#endif
+#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(44<<8)+0)
+    { VLC_FOURCC('A','P','E',' '), CODEC_ID_APE,
+      AUDIO_ES, "Monkey's Audio" },
+#endif
+    /* PCM */
+    { VLC_FOURCC('s','8',' ',' '), CODEC_ID_PCM_S8,
+      AUDIO_ES, "PCM S8" },
+    { VLC_FOURCC('u','8',' ',' '), CODEC_ID_PCM_U8,
+      AUDIO_ES, "PCM U8" },
+    { VLC_FOURCC('s','1','6','l'), CODEC_ID_PCM_S16LE,
+      AUDIO_ES, "PCM S16 LE" },
+    { VLC_FOURCC('s','1','6','b'), CODEC_ID_PCM_S16BE,
+      AUDIO_ES, "PCM S16 BE" },
+    { VLC_FOURCC('u','1','6','l'), CODEC_ID_PCM_U16LE,
+      AUDIO_ES, "PCM U16 LE" },
+    { VLC_FOURCC('u','1','6','b'), CODEC_ID_PCM_U16BE,
+      AUDIO_ES, "PCM U16 BE" },
+    { VLC_FOURCC('s','2','4','l'), CODEC_ID_PCM_S24LE,
+      AUDIO_ES, "PCM S24 LE" },
+    { VLC_FOURCC('s','2','4','b'), CODEC_ID_PCM_S24BE,
+      AUDIO_ES, "PCM S24 BE" },
+    { VLC_FOURCC('u','2','4','l'), CODEC_ID_PCM_U24LE,
+      AUDIO_ES, "PCM U24 LE" },
+    { VLC_FOURCC('u','2','4','b'), CODEC_ID_PCM_U24BE,
+      AUDIO_ES, "PCM U24 BE" },
+    { VLC_FOURCC('s','3','2','l'), CODEC_ID_PCM_S32LE,
+      AUDIO_ES, "PCM S32 LE" },
+    { VLC_FOURCC('s','3','2','b'), CODEC_ID_PCM_S32BE,
+      AUDIO_ES, "PCM S32 BE" },
+    { VLC_FOURCC('u','3','2','l'), CODEC_ID_PCM_U32LE,
+      AUDIO_ES, "PCM U32 LE" },
+    { VLC_FOURCC('u','3','2','b'), CODEC_ID_PCM_U32BE,
+      AUDIO_ES, "PCM U32 BE" },
+    { VLC_FOURCC('a','l','a','w'), CODEC_ID_PCM_ALAW,
+      AUDIO_ES, "PCM ALAW" },
+    { VLC_FOURCC('u','l','a','w'), CODEC_ID_PCM_MULAW,
+      AUDIO_ES, "PCM ULAW" },
+    { VLC_FOURCC('d','a','u','d'), CODEC_ID_PCM_S24DAUD,
+      AUDIO_ES, "PCM ULAW" },
+
+    { 0, 0, 0, 0 }
+};
+
+static int GetFfmpegCodec( vlc_fourcc_t i_fourcc, int *pi_cat,
+                           int *pi_ffmpeg_codec, const char **ppsz_name )
+{
+    int i;
+
+    for( i = 0; codecs_table[i].i_fourcc != 0; i++ )
+    {
+        if( codecs_table[i].i_fourcc == i_fourcc )
+        {
+            if( pi_cat ) *pi_cat = codecs_table[i].i_cat;
+            if( pi_ffmpeg_codec ) *pi_ffmpeg_codec = codecs_table[i].i_codec;
+            if( ppsz_name ) *ppsz_name = (char *)codecs_table[i].psz_name;
+
+            return true;
+        }
+    }
+    return false;
+}
+
+static int GetVlcFourcc( int i_ffmpeg_codec, int *pi_cat,
+                         vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
+{
+    int i;
+
+    for( i = 0; codecs_table[i].i_codec != 0; i++ )
+    {
+        if( codecs_table[i].i_codec == i_ffmpeg_codec )
+        {
+            if( pi_cat ) *pi_cat = codecs_table[i].i_cat;
+            if( pi_fourcc ) *pi_fourcc = codecs_table[i].i_fourcc;
+            if( ppsz_name ) *ppsz_name = codecs_table[i].psz_name;
+
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/modules/codec/avcodec/video.c b/modules/codec/avcodec/video.c
new file mode 100644 (file)
index 0000000..12391a0
--- /dev/null
@@ -0,0 +1,1000 @@
+/*****************************************************************************
+ * video.c: video decoder using the ffmpeg library
+ *****************************************************************************
+ * Copyright (C) 1999-2001 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_codec.h>
+#include <vlc_vout.h>
+#include <vlc_input.h>                  /* hmmm, just for INPUT_RATE_DEFAULT */
+#include <vlc_codecs.h>                               /* BITMAPINFOHEADER */
+
+/* ffmpeg header */
+#ifdef HAVE_LIBAVCODEC_AVCODEC_H
+#   include <libavcodec/avcodec.h>
+#elif defined(HAVE_FFMPEG_AVCODEC_H)
+#   include <ffmpeg/avcodec.h>
+#else
+#   include <avcodec.h>
+#endif
+
+#include "avcodec.h"
+
+/*****************************************************************************
+ * decoder_sys_t : decoder descriptor
+ *****************************************************************************/
+struct decoder_sys_t
+{
+    FFMPEG_COMMON_MEMBERS
+
+    /* Video decoder specific part */
+    mtime_t input_pts;
+    mtime_t input_dts;
+    mtime_t i_pts;
+
+    AVFrame          *p_ff_pic;
+    BITMAPINFOHEADER *p_format;
+
+    /* for frame skipping algo */
+    int b_hurry_up;
+    enum AVDiscard i_skip_frame;
+    enum AVDiscard i_skip_idct;
+
+    /* how many decoded frames are late */
+    int     i_late_frames;
+    mtime_t i_late_frames_start;
+
+    /* for direct rendering */
+    int b_direct_rendering;
+
+    bool b_has_b_frames;
+
+    /* Hack to force display of still pictures */
+    bool b_first_frame;
+
+    int i_buffer_orig, i_buffer;
+    char *p_buffer_orig, *p_buffer;
+
+    /* Postprocessing handle */
+    void *p_pp;
+    bool b_pp;
+    bool b_pp_async;
+    bool b_pp_init;
+};
+
+/* FIXME (dummy palette for now) */
+static AVPaletteControl palette_control;
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+static void ffmpeg_InitCodec      ( decoder_t * );
+static void ffmpeg_CopyPicture    ( decoder_t *, picture_t *, AVFrame * );
+static int  ffmpeg_GetFrameBuf    ( struct AVCodecContext *, AVFrame * );
+static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *, AVFrame * );
+
+static uint32_t ffmpeg_CodecTag( vlc_fourcc_t fcc )
+{
+    uint8_t *p = (uint8_t*)&fcc;
+    return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
+}
+
+/*****************************************************************************
+ * Local Functions
+ *****************************************************************************/
+static uint32_t ffmpeg_PixFmtToChroma( int i_ff_chroma )
+{
+    switch( i_ff_chroma )
+    {
+    case PIX_FMT_YUV420P:
+    case PIX_FMT_YUVJ420P: /* Hacky but better then chroma conversion */
+        return VLC_FOURCC('I','4','2','0');
+    case PIX_FMT_YUV422P:
+    case PIX_FMT_YUVJ422P: /* Hacky but better then chroma conversion */
+        return VLC_FOURCC('I','4','2','2');
+    case PIX_FMT_YUV444P:
+    case PIX_FMT_YUVJ444P: /* Hacky but better then chroma conversion */
+        return VLC_FOURCC('I','4','4','4');
+
+    case PIX_FMT_YUV422:
+        return VLC_FOURCC('Y','U','Y','2');
+
+#if defined(WORDS_BIGENDIAN)
+    case PIX_FMT_BGR8:
+        return VLC_FOURCC('R','G','B','8');
+    case PIX_FMT_BGR555:
+        return VLC_FOURCC('R','V','1','5');
+    case PIX_FMT_BGR565:
+        return VLC_FOURCC('R','V','1','6');
+    case PIX_FMT_BGR24:
+        return VLC_FOURCC('R','V','2','4');
+#else
+#if defined(PIX_FMT_RGB8)
+    case PIX_FMT_RGB8:
+        return VLC_FOURCC('R','G','B','8');
+#endif
+    case PIX_FMT_RGB555:
+        return VLC_FOURCC('R','V','1','5');
+    case PIX_FMT_RGB565:
+        return VLC_FOURCC('R','V','1','6');
+    case PIX_FMT_RGB24:
+        return VLC_FOURCC('R','V','2','4');
+#endif
+    case PIX_FMT_RGBA32:
+        return VLC_FOURCC('R','V','3','2');
+#ifdef PIX_FMT_RGBA
+    case PIX_FMT_RGBA:
+        return VLC_FOURCC('R','G','B','A');
+#endif
+    case PIX_FMT_GRAY8:
+        return VLC_FOURCC('G','R','E','Y');
+
+    case PIX_FMT_YUV410P:
+    case PIX_FMT_YUV411P:
+    default:
+        return 0;
+    }
+}
+
+/* Returns a new picture buffer */
+static inline picture_t *ffmpeg_NewPictBuf( decoder_t *p_dec,
+                                            AVCodecContext *p_context )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    picture_t *p_pic;
+
+    p_dec->fmt_out.video.i_width = p_context->width;
+    p_dec->fmt_out.video.i_height = p_context->height;
+    p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt );
+
+    if( !p_context->width || !p_context->height )
+    {
+        return NULL; /* invalid display size */
+    }
+
+    if( !p_dec->fmt_out.i_codec )
+    {
+        /* we make conversion if possible*/
+        p_dec->fmt_out.i_codec = VLC_FOURCC('I','4','2','0');
+    }
+
+    /* If an aspect-ratio was specified in the input format then force it */
+    if( p_dec->fmt_in.video.i_aspect )
+    {
+        p_dec->fmt_out.video.i_aspect = p_dec->fmt_in.video.i_aspect;
+    }
+    else
+    {
+        p_dec->fmt_out.video.i_aspect =
+            VOUT_ASPECT_FACTOR * ( av_q2d(p_context->sample_aspect_ratio) *
+                p_context->width / p_context->height );
+        p_dec->fmt_out.video.i_sar_num = p_context->sample_aspect_ratio.num;
+        p_dec->fmt_out.video.i_sar_den = p_context->sample_aspect_ratio.den;
+
+        if( p_dec->fmt_out.video.i_aspect == 0 )
+        {
+            p_dec->fmt_out.video.i_aspect =
+                VOUT_ASPECT_FACTOR * p_context->width / p_context->height;
+        }
+    }
+
+    if( p_dec->fmt_out.video.i_frame_rate > 0 &&
+        p_dec->fmt_out.video.i_frame_rate_base > 0 )
+    {
+        p_dec->fmt_out.video.i_frame_rate =
+            p_dec->fmt_in.video.i_frame_rate;
+        p_dec->fmt_out.video.i_frame_rate_base =
+            p_dec->fmt_in.video.i_frame_rate_base;
+    }
+    else if( p_context->time_base.num > 0 && p_context->time_base.den > 0 )
+    {
+        p_dec->fmt_out.video.i_frame_rate = p_context->time_base.den;
+        p_dec->fmt_out.video.i_frame_rate_base = p_context->time_base.num;
+    }
+
+    p_pic = p_dec->pf_vout_buffer_new( p_dec );
+
+// FIXME    if( p_sys->p_pp && p_sys->b_pp && !p_sys->b_pp_init )
+// FIXME    {
+// FIXME        InitPostproc( p_sys->p_pp, p_context->width,
+// FIXME                          p_context->height, p_context->pix_fmt );
+// FIXME        p_sys->b_pp_init = true;
+// FIXME    }
+
+    return p_pic;
+}
+
+/*****************************************************************************
+ * InitVideo: initialize the video decoder
+ *****************************************************************************
+ * the ffmpeg codec will be opened, some memory allocated. The vout is not yet
+ * opened (done after the first decoded frame).
+ *****************************************************************************/
+int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,
+                      AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
+{
+    decoder_sys_t *p_sys;
+    vlc_value_t val;
+
+    /* Allocate the memory needed to store the decoder's structure */
+    if( ( p_dec->p_sys = p_sys =
+          (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
+    {
+        msg_Err( p_dec, "out of memory" );
+        return VLC_ENOMEM;
+    }
+    memset( p_sys, 0, sizeof(decoder_sys_t) );
+
+    p_dec->p_sys->p_context = p_context;
+    p_dec->p_sys->p_codec = p_codec;
+    p_dec->p_sys->i_codec_id = i_codec_id;
+    p_dec->p_sys->psz_namecodec = psz_namecodec;
+    p_sys->p_ff_pic = avcodec_alloc_frame();
+
+    /* ***** Fill p_context with init values ***** */
+    p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_codec );
+    p_sys->p_context->width  = p_dec->fmt_in.video.i_width;
+    p_sys->p_context->height = p_dec->fmt_in.video.i_height;
+    p_sys->p_context->bits_per_sample = p_dec->fmt_in.video.i_bits_per_pixel;
+
+    /*  ***** Get configuration of ffmpeg plugin ***** */
+    p_sys->p_context->workaround_bugs =
+        config_GetInt( p_dec, "ffmpeg-workaround-bugs" );
+    p_sys->p_context->error_resilience =
+        config_GetInt( p_dec, "ffmpeg-error-resilience" );
+
+    var_Create( p_dec, "grayscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "grayscale", &val );
+    if( val.b_bool ) p_sys->p_context->flags |= CODEC_FLAG_GRAY;
+
+    var_Create( p_dec, "ffmpeg-vismv", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "ffmpeg-vismv", &val );
+    if( val.i_int ) p_sys->p_context->debug_mv = val.i_int;
+
+    var_Create( p_dec, "ffmpeg-lowres", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "ffmpeg-lowres", &val );
+    if( val.i_int > 0 && val.i_int <= 2 ) p_sys->p_context->lowres = val.i_int;
+
+    var_Create( p_dec, "ffmpeg-skiploopfilter",
+                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "ffmpeg-skiploopfilter", &val );
+    if( val.i_int > 0 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONREF;
+    if( val.i_int > 1 ) p_sys->p_context->skip_loop_filter = AVDISCARD_BIDIR;
+    if( val.i_int > 2 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONKEY;
+    if( val.i_int > 3 ) p_sys->p_context->skip_loop_filter = AVDISCARD_ALL;
+
+    /* ***** ffmpeg frame skipping ***** */
+    var_Create( p_dec, "ffmpeg-hurry-up", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "ffmpeg-hurry-up", &val );
+    p_sys->b_hurry_up = val.b_bool;
+
+    var_Create( p_dec, "ffmpeg-skip-frame", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "ffmpeg-skip-frame", &val );
+    switch( val.i_int )
+    {
+        case -1:
+            p_sys->p_context->skip_frame = AVDISCARD_NONE;
+            break;
+        case 0:
+            p_sys->p_context->skip_frame = AVDISCARD_DEFAULT;
+            break;
+        case 1:
+            p_sys->p_context->skip_frame = AVDISCARD_BIDIR;
+            break;
+        case 2:
+            p_sys->p_context->skip_frame = AVDISCARD_NONKEY;
+            break;
+        case 3:
+            p_sys->p_context->skip_frame = AVDISCARD_ALL;
+            break;
+        default:
+            p_sys->p_context->skip_frame = AVDISCARD_NONE;
+            break;
+    }
+    p_sys->i_skip_frame = p_sys->p_context->skip_frame;
+
+    var_Create( p_dec, "ffmpeg-skip-idct",  VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "ffmpeg-skip-idct", &val );
+    switch( val.i_int )
+    {
+        case -1:
+            p_sys->p_context->skip_idct = AVDISCARD_NONE;
+            break;
+        case 0:
+            p_sys->p_context->skip_idct = AVDISCARD_DEFAULT;
+            break;
+        case 1:
+            p_sys->p_context->skip_idct = AVDISCARD_BIDIR;
+            break;
+        case 2:
+            p_sys->p_context->skip_idct = AVDISCARD_NONKEY;
+            break;
+        case 3:
+            p_sys->p_context->skip_idct = AVDISCARD_ALL;
+            break;
+        default:
+            p_sys->p_context->skip_idct = AVDISCARD_NONE;
+            break;
+    }
+    p_sys->i_skip_idct = p_sys->p_context->skip_idct;
+
+    /* ***** ffmpeg direct rendering ***** */
+    p_sys->b_direct_rendering = 0;
+    var_Create( p_dec, "ffmpeg-dr", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+    var_Get( p_dec, "ffmpeg-dr", &val );
+    if( val.b_bool && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) &&
+        /* Apparently direct rendering doesn't work with YUV422P */
+        p_sys->p_context->pix_fmt != PIX_FMT_YUV422P &&
+        /* H264 uses too many reference frames */
+        p_sys->i_codec_id != CODEC_ID_H264 &&
+        !p_sys->p_context->debug_mv )
+    {
+        /* Some codecs set pix_fmt only after the 1st frame has been decoded,
+         * so we need to do another check in ffmpeg_GetFrameBuf() */
+        p_sys->b_direct_rendering = 1;
+    }
+
+    p_sys->p_pp = NULL;
+    p_sys->b_pp = p_sys->b_pp_async = p_sys->b_pp_init = false;
+    // FIXME p_sys->p_pp = OpenPostproc( p_dec, &p_sys->b_pp_async );
+
+    /* ffmpeg doesn't properly release old pictures when frames are skipped */
+    //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = 0;
+    if( p_sys->b_direct_rendering )
+    {
+        msg_Dbg( p_dec, "using direct rendering" );
+        p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE;
+    }
+
+    /* Always use our get_buffer wrapper so we can calculate the
+     * PTS correctly */
+    p_sys->p_context->get_buffer = ffmpeg_GetFrameBuf;
+    p_sys->p_context->release_buffer = ffmpeg_ReleaseFrameBuf;
+    p_sys->p_context->opaque = p_dec;
+
+    /* ***** init this codec with special data ***** */
+    ffmpeg_InitCodec( p_dec );
+
+    /* ***** misc init ***** */
+    p_sys->input_pts = p_sys->input_dts = 0;
+    p_sys->i_pts = 0;
+    p_sys->b_has_b_frames = false;
+    p_sys->b_first_frame = true;
+    p_sys->i_late_frames = 0;
+    p_sys->i_buffer = 0;
+    p_sys->i_buffer_orig = 1;
+    p_sys->p_buffer_orig = p_sys->p_buffer = malloc( p_sys->i_buffer_orig );
+
+    /* Set output properties */
+    p_dec->fmt_out.i_cat = VIDEO_ES;
+    p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt );
+
+    /* Setup palette */
+    if( p_dec->fmt_in.video.p_palette )
+        p_sys->p_context->palctrl =
+            (AVPaletteControl *)p_dec->fmt_in.video.p_palette;
+    else
+        p_sys->p_context->palctrl = &palette_control;
+
+    /* ***** Open the codec ***** */
+    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
+    if( lock == NULL )
+    {
+        free( p_sys );
+        return VLC_ENOMEM;
+    }
+
+    if( avcodec_open( p_sys->p_context, p_sys->p_codec ) < 0 )
+    {
+        vlc_mutex_unlock( lock );
+        msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
+        free( p_sys );
+        return VLC_EGENERIC;
+    }
+    vlc_mutex_unlock( lock );
+    msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
+
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * DecodeVideo: Called to decode one or more frames
+ *****************************************************************************/
+picture_t *DecodeVideo( decoder_t *p_dec, block_t **pp_block )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    int b_drawpicture;
+    int b_null_size = false;
+    block_t *p_block;
+
+    if( !pp_block || !*pp_block ) return NULL;
+
+    if( !p_sys->p_context->extradata_size && p_dec->fmt_in.i_extra )
+        ffmpeg_InitCodec( p_dec );
+
+    p_block = *pp_block;
+
+    if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
+    {
+        p_sys->i_buffer = 0;
+        p_sys->i_pts = 0; /* To make sure we recover properly */
+
+        p_sys->input_pts = p_sys->input_dts = 0;
+        p_sys->i_late_frames = 0;
+
+        block_Release( p_block );
+
+        //if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
+            //avcodec_flush_buffers( p_sys->p_context );
+        return NULL;
+    }
+
+    if( p_block->i_flags & BLOCK_FLAG_PREROLL )
+    {
+        /* Do not care about late frames when prerolling
+         * TODO avoid decoding of non reference frame
+         * (ie all B except for H264 where it depends only on nal_ref_idc) */
+        p_sys->i_late_frames = 0;
+    }
+
+    if( !p_dec->b_pace_control && (p_sys->i_late_frames > 0) &&
+        (mdate() - p_sys->i_late_frames_start > INT64_C(5000000)) )
+    {
+        if( p_sys->i_pts )
+        {
+            msg_Err( p_dec, "more than 5 seconds of late video -> "
+                     "dropping frame (computer too slow ?)" );
+            p_sys->i_pts = 0; /* To make sure we recover properly */
+        }
+        block_Release( p_block );
+        p_sys->i_late_frames--;
+        return NULL;
+    }
+
+    if( p_block->i_pts > 0 || p_block->i_dts > 0 )
+    {
+        p_sys->input_pts = p_block->i_pts;
+        p_sys->input_dts = p_block->i_dts;
+
+        /* Make sure we don't reuse the same timestamps twice */
+        p_block->i_pts = p_block->i_dts = 0;
+    }
+
+    /* A good idea could be to decode all I pictures and see for the other */
+    if( !p_dec->b_pace_control &&
+        p_sys->b_hurry_up &&
+        (p_sys->i_late_frames > 4) )
+    {
+        b_drawpicture = 0;
+        if( p_sys->i_late_frames < 8 )
+        {
+            p_sys->p_context->skip_frame =
+                    (p_sys->i_skip_frame <= AVDISCARD_BIDIR) ?
+                    AVDISCARD_BIDIR : p_sys->i_skip_frame;
+        }
+        else
+        {
+            /* picture too late, won't decode
+             * but break picture until a new I, and for mpeg4 ...*/
+            p_sys->i_late_frames--; /* needed else it will never be decrease */
+            block_Release( p_block );
+            p_sys->i_buffer = 0;
+            return NULL;
+        }
+    }
+    else
+    {
+        if( p_sys->b_hurry_up )
+            p_sys->p_context->skip_frame = p_sys->i_skip_frame;
+        if( !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
+            b_drawpicture = 1;
+        else
+            b_drawpicture = 0;
+    }
+
+    if( p_sys->p_context->width <= 0 || p_sys->p_context->height <= 0 )
+    {
+        if( p_sys->b_hurry_up )
+            p_sys->p_context->skip_frame = p_sys->i_skip_frame;
+        b_null_size = true;
+    }
+
+    /*
+     * Do the actual decoding now
+     */
+
+    /* Check if post-processing was enabled */
+    p_sys->b_pp = p_sys->b_pp_async;
+
+    /* Don't forget that ffmpeg requires a little more bytes
+     * that the real frame size */
+    if( p_block->i_buffer > 0 )
+    {
+        p_sys->i_buffer = p_block->i_buffer;
+        if( p_sys->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE >
+            p_sys->i_buffer_orig )
+        {
+            free( p_sys->p_buffer_orig );
+            p_sys->i_buffer_orig =
+                p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE;
+            p_sys->p_buffer_orig = malloc( p_sys->i_buffer_orig );
+        }
+        p_sys->p_buffer = p_sys->p_buffer_orig;
+        p_sys->i_buffer = p_block->i_buffer;
+        vlc_memcpy( p_sys->p_buffer, p_block->p_buffer, p_block->i_buffer );
+        memset( p_sys->p_buffer + p_block->i_buffer, 0,
+                FF_INPUT_BUFFER_PADDING_SIZE );
+
+        p_block->i_buffer = 0;
+    }
+
+    while( p_sys->i_buffer > 0 )
+    {
+        int i_used, b_gotpicture;
+        picture_t *p_pic;
+
+        i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
+                                       &b_gotpicture,
+                                       (uint8_t*)p_sys->p_buffer, p_sys->i_buffer );
+        if( b_null_size && p_sys->p_context->width > 0 &&
+            p_sys->p_context->height > 0 )
+        {
+            /* Reparse it to not drop the I frame */
+            b_null_size = false;
+            if( p_sys->b_hurry_up )
+                p_sys->p_context->skip_frame = p_sys->i_skip_frame;
+            i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
+                                           &b_gotpicture,
+                                           (uint8_t*)p_sys->p_buffer, p_sys->i_buffer );
+        }
+
+        if( i_used < 0 )
+        {
+            msg_Warn( p_dec, "cannot decode one frame (%d bytes)",
+                      p_sys->i_buffer );
+            block_Release( p_block );
+            return NULL;
+        }
+        else if( i_used > p_sys->i_buffer )
+        {
+            i_used = p_sys->i_buffer;
+        }
+
+        /* Consumed bytes */
+        p_sys->i_buffer -= i_used;
+        p_sys->p_buffer += i_used;
+
+        /* Nothing to display */
+        if( !b_gotpicture )
+        {
+            if( i_used == 0 ) break;
+            continue;
+        }
+
+        /* Update frame late count (except when doing preroll) */
+        if( p_sys->i_pts && decoder_GetDisplayDate(p_dec, p_sys->i_pts) <= mdate() &&
+            !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
+        {
+            p_sys->i_late_frames++;
+            if( p_sys->i_late_frames == 1 )
+                p_sys->i_late_frames_start = mdate();
+        }
+        else
+        {
+            p_sys->i_late_frames = 0;
+        }
+
+        if( !b_drawpicture || !p_sys->p_ff_pic->linesize[0] )
+        {
+            /* Do not display the picture */
+            p_pic = (picture_t *)p_sys->p_ff_pic->opaque;
+            if( !b_drawpicture && p_pic )
+                p_dec->pf_vout_buffer_del( p_dec, p_pic );
+            continue;
+        }
+
+        if( !p_sys->p_ff_pic->opaque )
+        {
+            /* Get a new picture */
+            p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
+            if( !p_pic )
+            {
+                block_Release( p_block );
+                return NULL;
+            }
+
+            /* Fill p_picture_t from AVVideoFrame and do chroma conversion
+             * if needed */
+            ffmpeg_CopyPicture( p_dec, p_pic, p_sys->p_ff_pic );
+        }
+        else
+        {
+            p_pic = (picture_t *)p_sys->p_ff_pic->opaque;
+        }
+
+        /* Set the PTS */
+        if( p_sys->p_ff_pic->pts ) p_sys->i_pts = p_sys->p_ff_pic->pts;
+
+        /* Sanity check (seems to be needed for some streams) */
+        if( p_sys->p_ff_pic->pict_type == FF_B_TYPE )
+        {
+            p_sys->b_has_b_frames = true;
+        }
+
+        if( !p_dec->fmt_in.video.i_aspect )
+        {
+            /* Fetch again the aspect ratio in case it changed */
+            p_dec->fmt_out.video.i_aspect =
+                VOUT_ASPECT_FACTOR
+                    * ( av_q2d(p_sys->p_context->sample_aspect_ratio)
+                    * p_sys->p_context->width / p_sys->p_context->height );
+            p_dec->fmt_out.video.i_sar_num
+                = p_sys->p_context->sample_aspect_ratio.num;
+            p_dec->fmt_out.video.i_sar_den
+                = p_sys->p_context->sample_aspect_ratio.den;
+
+            if( p_dec->fmt_out.video.i_aspect == 0 )
+            {
+                p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR
+                    * p_sys->p_context->width / p_sys->p_context->height;
+            }
+        }
+
+        /* Send decoded frame to vout */
+        if( p_sys->i_pts )
+        {
+            p_pic->date = p_sys->i_pts;
+
+            /* interpolate the next PTS */
+            if( p_dec->fmt_in.video.i_frame_rate > 0 &&
+                p_dec->fmt_in.video.i_frame_rate_base > 0 )
+            {
+                p_sys->i_pts += INT64_C(1000000) *
+                    (2 + p_sys->p_ff_pic->repeat_pict) *
+                    p_dec->fmt_in.video.i_frame_rate_base *
+                    p_block->i_rate / INPUT_RATE_DEFAULT /
+                    (2 * p_dec->fmt_in.video.i_frame_rate);
+            }
+            else if( p_sys->p_context->time_base.den > 0 )
+            {
+                p_sys->i_pts += INT64_C(1000000) *
+                    (2 + p_sys->p_ff_pic->repeat_pict) *
+                    p_sys->p_context->time_base.num *
+                    p_block->i_rate / INPUT_RATE_DEFAULT /
+                    (2 * p_sys->p_context->time_base.den);
+            }
+
+            if( p_sys->b_first_frame )
+            {
+                /* Hack to force display of still pictures */
+                p_sys->b_first_frame = false;
+                p_pic->b_force = true;
+            }
+
+            p_pic->i_nb_fields = 2 + p_sys->p_ff_pic->repeat_pict;
+            p_pic->b_progressive = !p_sys->p_ff_pic->interlaced_frame;
+            p_pic->b_top_field_first = p_sys->p_ff_pic->top_field_first;
+
+            return p_pic;
+        }
+        else
+        {
+            p_dec->pf_vout_buffer_del( p_dec, p_pic );
+        }
+    }
+
+    block_Release( p_block );
+    return NULL;
+}
+
+/*****************************************************************************
+ * EndVideo: decoder destruction
+ *****************************************************************************
+ * This function is called when the thread ends after a successful
+ * initialization.
+ *****************************************************************************/
+void EndVideoDec( decoder_t *p_dec )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+
+    if( p_sys->p_ff_pic ) av_free( p_sys->p_ff_pic );
+    // FIXME ClosePostproc( p_dec, p_sys->p_pp );
+    free( p_sys->p_buffer_orig );
+}
+
+/*****************************************************************************
+ * ffmpeg_InitCodec: setup codec extra initialization data for ffmpeg
+ *****************************************************************************/
+static void ffmpeg_InitCodec( decoder_t *p_dec )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    int i_size = p_dec->fmt_in.i_extra;
+
+    if( !i_size ) return;
+
+    if( p_sys->i_codec_id == CODEC_ID_SVQ3 )
+    {
+        uint8_t *p;
+
+        p_sys->p_context->extradata_size = i_size + 12;
+        p = p_sys->p_context->extradata  =
+            malloc( p_sys->p_context->extradata_size );
+
+        memcpy( &p[0],  "SVQ3", 4 );
+        memset( &p[4], 0, 8 );
+        memcpy( &p[12], p_dec->fmt_in.p_extra, i_size );
+
+        /* Now remove all atoms before the SMI one */
+        if( p_sys->p_context->extradata_size > 0x5a &&
+            strncmp( (char*)&p[0x56], "SMI ", 4 ) )
+        {
+            uint8_t *psz = &p[0x52];
+
+            while( psz < &p[p_sys->p_context->extradata_size - 8] )
+            {
+                int i_size = GetDWBE( psz );
+                if( i_size <= 1 )
+                {
+                    /* FIXME handle 1 as long size */
+                    break;
+                }
+                if( !strncmp( (char*)&psz[4], "SMI ", 4 ) )
+                {
+                    memmove( &p[0x52], psz,
+                             &p[p_sys->p_context->extradata_size] - psz );
+                    break;
+                }
+
+                psz += i_size;
+            }
+        }
+    }
+    else if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '0' ) ||
+             p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '3' ) ||
+             p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '2', '0' ) )
+    {
+        if( p_dec->fmt_in.i_extra == 8 )
+        {
+            p_sys->p_context->extradata_size = 8;
+            p_sys->p_context->extradata = malloc( 8 );
+
+            memcpy( p_sys->p_context->extradata,
+                    p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
+            p_sys->p_context->sub_id= ((uint32_t*)p_dec->fmt_in.p_extra)[1];
+
+            msg_Warn( p_dec, "using extra data for RV codec sub_id=%08x",
+                      p_sys->p_context->sub_id );
+        }
+    }
+    else
+    {
+        p_sys->p_context->extradata_size = i_size;
+        p_sys->p_context->extradata =
+            malloc( i_size + FF_INPUT_BUFFER_PADDING_SIZE );
+        memcpy( p_sys->p_context->extradata,
+                p_dec->fmt_in.p_extra, i_size );
+        memset( &((uint8_t*)p_sys->p_context->extradata)[i_size],
+                0, FF_INPUT_BUFFER_PADDING_SIZE );
+    }
+}
+
+/*****************************************************************************
+ * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a
+ *                     picture_t structure (when not in direct rendering mode).
+ *****************************************************************************/
+static void ffmpeg_CopyPicture( decoder_t *p_dec,
+                                picture_t *p_pic, AVFrame *p_ff_pic )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+
+    if( ffmpeg_PixFmtToChroma( p_sys->p_context->pix_fmt ) )
+    {
+        int i_plane, i_size, i_line;
+        uint8_t *p_dst, *p_src;
+        int i_src_stride, i_dst_stride;
+
+        // FIXME if( p_sys->p_pp && p_sys->b_pp )
+        // FIXME    PostprocPict( p_sys->p_pp, p_pic, p_ff_pic );
+        // FIXME else
+        {
+            for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
+            {
+                p_src  = p_ff_pic->data[i_plane];
+                p_dst = p_pic->p[i_plane].p_pixels;
+                i_src_stride = p_ff_pic->linesize[i_plane];
+                i_dst_stride = p_pic->p[i_plane].i_pitch;
+
+                i_size = __MIN( i_src_stride, i_dst_stride );
+                for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines;
+                     i_line++ )
+                {
+                    vlc_memcpy( p_dst, p_src, i_size );
+                    p_src += i_src_stride;
+                    p_dst += i_dst_stride;
+                }
+            }
+        }
+    }
+    else
+    {
+        AVPicture dest_pic;
+        int i;
+
+        /* we need to convert to I420 */
+        switch( p_sys->p_context->pix_fmt )
+        {
+        case PIX_FMT_YUV410P:
+        case PIX_FMT_YUV411P:
+        case PIX_FMT_RGB32:
+        case PIX_FMT_RGB24:
+#if defined(PIX_FMT_RGB8)
+        case PIX_FMT_RGB8:
+#endif
+#if defined(PIX_FMT_BRG32)
+        case PIX_FMT_BGR32:
+#endif
+        case PIX_FMT_BGR24:
+#if defined(PIX_FMT_BGR8)
+        case PIX_FMT_BGR8:
+#endif
+        case PIX_FMT_PAL8:
+            for( i = 0; i < p_pic->i_planes; i++ )
+            {
+                dest_pic.data[i] = p_pic->p[i].p_pixels;
+                dest_pic.linesize[i] = p_pic->p[i].i_pitch;
+            }
+#if !defined(HAVE_LIBSWSCALE_SWSCALE_H)  && !defined(HAVE_FFMPEG_SWSCALE_H)
+            img_convert( &dest_pic, PIX_FMT_YUV420P,
+                         (AVPicture *)p_ff_pic,
+                         p_sys->p_context->pix_fmt,
+                         p_sys->p_context->width,
+                         p_sys->p_context->height );
+#endif
+            break;
+        default:
+            msg_Err( p_dec, "don't know how to convert chroma %i",
+                     p_sys->p_context->pix_fmt );
+            p_dec->b_error = 1;
+            break;
+        }
+    }
+}
+
+/*****************************************************************************
+ * ffmpeg_GetFrameBuf: callback used by ffmpeg to get a frame buffer.
+ *****************************************************************************
+ * It is used for direct rendering as well as to get the right PTS for each
+ * decoded picture (even in indirect rendering mode).
+ *****************************************************************************/
+static int ffmpeg_GetFrameBuf( struct AVCodecContext *p_context,
+                               AVFrame *p_ff_pic )
+{
+    decoder_t *p_dec = (decoder_t *)p_context->opaque;
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    picture_t *p_pic;
+
+    /* Set picture PTS */
+    if( p_sys->input_pts )
+    {
+        p_ff_pic->pts = p_sys->input_pts;
+    }
+    else if( p_sys->input_dts )
+    {
+        /* Some demuxers only set the dts so let's try to find a useful
+         * timestamp from this */
+        if( !p_context->has_b_frames || !p_sys->b_has_b_frames ||
+            !p_ff_pic->reference || !p_sys->i_pts )
+        {
+            p_ff_pic->pts = p_sys->input_dts;
+        }
+        else p_ff_pic->pts = 0;
+    }
+    else p_ff_pic->pts = 0;
+
+    if( p_sys->i_pts ) /* make sure 1st frame has a pts > 0 */
+    {
+        p_sys->input_pts = p_sys->input_dts = 0;
+    }
+
+    p_ff_pic->opaque = 0;
+
+    /* Not much to do in indirect rendering mode */
+    if( !p_sys->b_direct_rendering || p_sys->b_pp )
+    {
+        return avcodec_default_get_buffer( p_context, p_ff_pic );
+    }
+
+    /* Some codecs set pix_fmt only after the 1st frame has been decoded,
+     * so this check is necessary. */
+    if( !ffmpeg_PixFmtToChroma( p_context->pix_fmt ) ||
+        p_sys->p_context->width % 16 || p_sys->p_context->height % 16 )
+    {
+        msg_Dbg( p_dec, "disabling direct rendering" );
+        p_sys->b_direct_rendering = 0;
+        return avcodec_default_get_buffer( p_context, p_ff_pic );
+    }
+
+    /* Get a new picture */
+    //p_sys->p_vout->render.b_allow_modify_pics = 0;
+    p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
+    if( !p_pic )
+    {
+        p_sys->b_direct_rendering = 0;
+        return avcodec_default_get_buffer( p_context, p_ff_pic );
+    }
+    p_sys->p_context->draw_horiz_band = NULL;
+
+    p_ff_pic->opaque = (void*)p_pic;
+    p_ff_pic->type = FF_BUFFER_TYPE_USER;
+    p_ff_pic->data[0] = p_pic->p[0].p_pixels;
+    p_ff_pic->data[1] = p_pic->p[1].p_pixels;
+    p_ff_pic->data[2] = p_pic->p[2].p_pixels;
+    p_ff_pic->data[3] = NULL; /* alpha channel but I'm not sure */
+
+    p_ff_pic->linesize[0] = p_pic->p[0].i_pitch;
+    p_ff_pic->linesize[1] = p_pic->p[1].i_pitch;
+    p_ff_pic->linesize[2] = p_pic->p[2].i_pitch;
+    p_ff_pic->linesize[3] = 0;
+
+    if( p_ff_pic->reference != 0 )
+    {
+        p_dec->pf_picture_link( p_dec, p_pic );
+    }
+
+    /* FIXME what is that, should give good value */
+    p_ff_pic->age = 256*256*256*64; // FIXME FIXME from ffmpeg
+
+    return 0;
+}
+
+static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *p_context,
+                                    AVFrame *p_ff_pic )
+{
+    decoder_t *p_dec = (decoder_t *)p_context->opaque;
+    picture_t *p_pic;
+
+    if( !p_ff_pic->opaque )
+    {
+        avcodec_default_release_buffer( p_context, p_ff_pic );
+        return;
+    }
+
+    p_pic = (picture_t*)p_ff_pic->opaque;
+
+    p_ff_pic->data[0] = NULL;
+    p_ff_pic->data[1] = NULL;
+    p_ff_pic->data[2] = NULL;
+    p_ff_pic->data[3] = NULL;
+
+    if( p_ff_pic->reference != 0 )
+    {
+        p_dec->pf_picture_unlink( p_dec, p_pic );
+    }
+}
diff --git a/modules/codec/ffmpeg/Modules.am b/modules/codec/ffmpeg/Modules.am
deleted file mode 100644 (file)
index 67cfb8a..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-SOURCES_avcodec = \
-       avcodec.c \
-       avcodec.h \
-       video.c \
-       audio.c \
-       deinterlace.c \
-       avutil.h \
-       fourcc.h \
-       chroma.h \
-       $(NULL)
-
-if ENABLE_SOUT
-SOURCES_avcodec += encoder.c
-endif
-
-EXTRA_libavcodec_plugin_la_SOURCES = \
-       encoder.c \
-       $(NULL)
-
-libvlc_LTLIBRARIES += \
-       $(LTLIBavcodec)
-
-EXTRA_LTLIBRARIES += \
-       libavcodec_plugin.la
-
-# FIXME SOURCES_ffmpegaltivec = \
-# FIXME        ffmpeg.c \
-# FIXME        ffmpeg.h \
-# FIXME        video.c \
-# FIXME        audio.c \
-# FIXME        video_filter.c \
-# FIXME        deinterlace.c \
-# FIXME        chroma.c \
-# FIXME        encoder.c \
-# FIXME        postprocess.c \
-# FIXME        demux.c \
-# FIXME        mux.c \
-# FIXME        scale.c \
-# FIXME        $(NULL)
-
diff --git a/modules/codec/ffmpeg/audio.c b/modules/codec/ffmpeg/audio.c
deleted file mode 100644 (file)
index ca48b90..0000000
+++ /dev/null
@@ -1,360 +0,0 @@
-/*****************************************************************************
- * audio.c: audio decoder using ffmpeg library
- *****************************************************************************
- * Copyright (C) 1999-2003 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *          Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble
- *****************************************************************************/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <vlc_common.h>
-#include <vlc_aout.h>
-#include <vlc_codec.h>
-#include <vlc_input.h>
-
-/* ffmpeg header */
-#ifdef HAVE_LIBAVCODEC_AVCODEC_H
-#   include <libavcodec/avcodec.h>
-#elif defined(HAVE_FFMPEG_AVCODEC_H)
-#   include <ffmpeg/avcodec.h>
-#else
-#   include <avcodec.h>
-#endif
-
-#include "avcodec.h"
-
-static unsigned int pi_channels_maps[7] =
-{
-    0,
-    AOUT_CHAN_CENTER,   AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
-    AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
-    AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
-     | AOUT_CHAN_REARRIGHT,
-    AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
-     | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
-    AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
-     | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
-};
-
-/*****************************************************************************
- * decoder_sys_t : decoder descriptor
- *****************************************************************************/
-struct decoder_sys_t
-{
-    FFMPEG_COMMON_MEMBERS
-
-    /* Temporary buffer for libavcodec */
-    uint8_t *p_output;
-
-    /*
-     * Output properties
-     */
-    audio_sample_format_t aout_format;
-    audio_date_t          end_date;
-
-    /*
-     *
-     */
-    uint8_t *p_samples;
-    int     i_samples;
-
-    /* */
-    int     i_reject_count;
-
-    int i_input_rate;
-};
-
-/*****************************************************************************
- * InitAudioDec: initialize audio decoder
- *****************************************************************************
- * The ffmpeg codec will be opened, some memory allocated.
- *****************************************************************************/
-int InitAudioDec( decoder_t *p_dec, AVCodecContext *p_context,
-                      AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
-{
-    decoder_sys_t *p_sys;
-
-    /* Allocate the memory needed to store the decoder's structure */
-    if( ( p_dec->p_sys = p_sys =
-          (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
-    {
-        msg_Err( p_dec, "out of memory" );
-        return VLC_ENOMEM;
-    }
-
-    p_sys->p_context = p_context;
-    p_sys->p_codec = p_codec;
-    p_sys->i_codec_id = i_codec_id;
-    p_sys->psz_namecodec = psz_namecodec;
-
-    /* ***** Fill p_context with init values ***** */
-    p_sys->p_context->sample_rate = p_dec->fmt_in.audio.i_rate;
-    p_sys->p_context->channels = p_dec->fmt_in.audio.i_channels;
-    if( !p_dec->fmt_in.audio.i_physical_channels )
-    {
-        msg_Warn( p_dec, "Physical channel configuration not set : guessing" );
-        p_dec->fmt_in.audio.i_original_channels =
-            p_dec->fmt_in.audio.i_physical_channels =
-                pi_channels_maps[p_sys->p_context->channels];
-    }
-
-    p_dec->fmt_out.audio.i_physical_channels =
-        p_dec->fmt_out.audio.i_original_channels =
-        p_dec->fmt_in.audio.i_physical_channels;
-
-    p_sys->p_context->block_align = p_dec->fmt_in.audio.i_blockalign;
-    p_sys->p_context->bit_rate = p_dec->fmt_in.i_bitrate;
-    p_sys->p_context->bits_per_sample = p_dec->fmt_in.audio.i_bitspersample;
-
-    if( ( p_sys->p_context->extradata_size = p_dec->fmt_in.i_extra ) > 0 )
-    {
-        int i_offset = 0;
-
-        if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'f', 'l', 'a', 'c' ) )
-            i_offset = 8;
-
-        p_sys->p_context->extradata_size -= i_offset;
-        p_sys->p_context->extradata =
-            malloc( p_sys->p_context->extradata_size +
-                    FF_INPUT_BUFFER_PADDING_SIZE );
-        memcpy( p_sys->p_context->extradata,
-                (char*)p_dec->fmt_in.p_extra + i_offset,
-                p_sys->p_context->extradata_size );
-        memset( (char*)p_sys->p_context->extradata +
-                p_sys->p_context->extradata_size, 0,
-                FF_INPUT_BUFFER_PADDING_SIZE );
-    }
-    else
-        p_sys->p_context->extradata = NULL;
-
-    /* ***** Open the codec ***** */
-    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
-    if( lock == NULL )
-    {
-        free( p_sys->p_context->extradata );
-        free( p_sys );
-        return VLC_ENOMEM;
-    }
-
-    if (avcodec_open( p_sys->p_context, p_sys->p_codec ) < 0)
-    {
-        vlc_mutex_unlock( lock );
-        msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
-        free( p_sys->p_context->extradata );
-        free( p_sys );
-        return VLC_EGENERIC;
-    }
-    vlc_mutex_unlock( lock );
-
-    msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
-
-    p_sys->p_output = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
-    p_sys->p_samples = NULL;
-    p_sys->i_samples = 0;
-    p_sys->i_reject_count = 0;
-    p_sys->i_input_rate = INPUT_RATE_DEFAULT;
-
-    aout_DateSet( &p_sys->end_date, 0 );
-    if( p_dec->fmt_in.audio.i_rate )
-        aout_DateInit( &p_sys->end_date, p_dec->fmt_in.audio.i_rate );
-
-    /* Set output properties */
-    p_dec->fmt_out.i_cat = AUDIO_ES;
-    p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
-    p_dec->fmt_out.audio.i_bitspersample = 16;
-
-    return VLC_SUCCESS;
-}
-
-/*****************************************************************************
- * SplitBuffer: Needed because aout really doesn't like big audio chunk and
- * wma produces easily > 30000 samples...
- *****************************************************************************/
-static aout_buffer_t *SplitBuffer( decoder_t *p_dec )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-    int i_samples = __MIN( p_sys->i_samples, 4096 );
-    aout_buffer_t *p_buffer;
-
-    if( i_samples == 0 ) return NULL;
-
-    if( ( p_buffer = p_dec->pf_aout_buffer_new( p_dec, i_samples ) ) == NULL )
-    {
-        msg_Err( p_dec, "cannot get aout buffer" );
-        return NULL;
-    }
-
-    p_buffer->start_date = aout_DateGet( &p_sys->end_date );
-    p_buffer->end_date = aout_DateIncrement( &p_sys->end_date,
-                                             i_samples * p_sys->i_input_rate / INPUT_RATE_DEFAULT );
-
-    memcpy( p_buffer->p_buffer, p_sys->p_samples, p_buffer->i_nb_bytes );
-
-    p_sys->p_samples += p_buffer->i_nb_bytes;
-    p_sys->i_samples -= i_samples;
-
-    return p_buffer;
-}
-
-/*****************************************************************************
- * DecodeAudio: Called to decode one frame
- *****************************************************************************/
-aout_buffer_t * DecodeAudio ( decoder_t *p_dec, block_t **pp_block )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-    int i_used, i_output;
-    aout_buffer_t *p_buffer;
-    block_t *p_block;
-
-    if( !pp_block || !*pp_block ) return NULL;
-
-    p_block = *pp_block;
-
-    if( p_block->i_rate > 0 )
-        p_sys->i_input_rate = p_block->i_rate;
-
-    if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
-    {
-        block_Release( p_block );
-        avcodec_flush_buffers( p_sys->p_context );
-
-        if( p_sys->i_codec_id == CODEC_ID_MP2 || p_sys->i_codec_id == CODEC_ID_MP3 )
-            p_sys->i_reject_count = 3;
-        return NULL;
-    }
-
-    if( p_sys->i_samples > 0 )
-    {
-        /* More data */
-        p_buffer = SplitBuffer( p_dec );
-        if( !p_buffer ) block_Release( p_block );
-        return p_buffer;
-    }
-
-    if( !aout_DateGet( &p_sys->end_date ) && !p_block->i_pts )
-    {
-        /* We've just started the stream, wait for the first PTS. */
-        block_Release( p_block );
-        return NULL;
-    }
-
-    if( p_block->i_buffer <= 0 )
-    {
-        block_Release( p_block );
-        return NULL;
-    }
-    if( p_block->i_buffer > AVCODEC_MAX_AUDIO_FRAME_SIZE )
-    {
-        /* Grow output buffer if necessary (eg. for PCM data) */
-        p_sys->p_output = realloc(p_sys->p_output, p_block->i_buffer);
-    }
-
-    *pp_block = p_block = block_Realloc( p_block, 0, p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE );
-    if( !p_block )
-        return NULL;
-    p_block->i_buffer -= FF_INPUT_BUFFER_PADDING_SIZE;
-    memset( &p_block->p_buffer[p_block->i_buffer], 0, FF_INPUT_BUFFER_PADDING_SIZE );
-
-#if LIBAVCODEC_VERSION_INT >= ((52<<16)+(0<<8)+0)
-    i_output = __MAX( AVCODEC_MAX_AUDIO_FRAME_SIZE, p_block->i_buffer );
-    i_used = avcodec_decode_audio2( p_sys->p_context,
-                                   (int16_t*)p_sys->p_output, &i_output,
-                                   p_block->p_buffer, p_block->i_buffer );
-#else
-    i_used = avcodec_decode_audio( p_sys->p_context,
-                                   (int16_t*)p_sys->p_output, &i_output,
-                                   p_block->p_buffer, p_block->i_buffer );
-#endif
-
-    if( i_used < 0 || i_output < 0 )
-    {
-        if( i_used < 0 )
-            msg_Warn( p_dec, "cannot decode one frame (%d bytes)",
-                      p_block->i_buffer );
-
-        block_Release( p_block );
-        return NULL;
-    }
-    else if( (size_t)i_used > p_block->i_buffer )
-    {
-        i_used = p_block->i_buffer;
-    }
-
-    p_block->i_buffer -= i_used;
-    p_block->p_buffer += i_used;
-
-    if( p_sys->p_context->channels <= 0 || p_sys->p_context->channels > 6 )
-    {
-        msg_Warn( p_dec, "invalid channels count %d",
-                  p_sys->p_context->channels );
-        block_Release( p_block );
-        return NULL;
-    }
-
-    if( p_dec->fmt_out.audio.i_rate != (unsigned int)p_sys->p_context->sample_rate )
-    {
-        aout_DateInit( &p_sys->end_date, p_sys->p_context->sample_rate );
-        aout_DateSet( &p_sys->end_date, p_block->i_pts );
-    }
-
-    /* **** Set audio output parameters **** */
-    p_dec->fmt_out.audio.i_rate     = p_sys->p_context->sample_rate;
-    p_dec->fmt_out.audio.i_channels = p_sys->p_context->channels;
-    p_dec->fmt_out.audio.i_original_channels =
-        p_dec->fmt_out.audio.i_physical_channels =
-            pi_channels_maps[p_sys->p_context->channels];
-
-    if( p_block->i_pts != 0 &&
-        p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
-    {
-        aout_DateSet( &p_sys->end_date, p_block->i_pts );
-    }
-    p_block->i_pts = 0;
-
-    /* **** Now we can output these samples **** */
-    p_sys->i_samples = i_output / sizeof(int16_t) / p_sys->p_context->channels;
-    p_sys->p_samples = p_sys->p_output;
-
-    /* Silent unwanted samples */
-    if( p_sys->i_reject_count > 0 )
-    {
-        memset( p_sys->p_output, 0, i_output );
-        p_sys->i_reject_count--;
-    }
-
-    p_buffer = SplitBuffer( p_dec );
-    if( !p_buffer ) block_Release( p_block );
-    return p_buffer;
-}
-
-/*****************************************************************************
- * EndAudioDec: audio decoder destruction
- *****************************************************************************/
-void EndAudioDec( decoder_t *p_dec )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-
-    free( p_sys->p_output );
-}
diff --git a/modules/codec/ffmpeg/avcodec.c b/modules/codec/ffmpeg/avcodec.c
deleted file mode 100644 (file)
index 0e554da..0000000
+++ /dev/null
@@ -1,356 +0,0 @@
-/*****************************************************************************
- * avcodec.c: video and audio decoder and encoder using libavcodec
- *****************************************************************************
- * Copyright (C) 1999-2008 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *          Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble
- *****************************************************************************/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <vlc_common.h>
-#include <vlc_plugin.h>
-#include <vlc_codec.h>
-
-/* ffmpeg header */
-#define HAVE_MMX 1
-#ifdef HAVE_LIBAVCODEC_AVCODEC_H
-#   include <libavcodec/avcodec.h>
-#elif defined(HAVE_FFMPEG_AVCODEC_H)
-#   include <ffmpeg/avcodec.h>
-#else
-#   include <avcodec.h>
-#endif
-
-#if LIBAVCODEC_BUILD < 5000
-#   error You must have a libavcodec >= 5000 (get svn)
-#endif
-
-#include "avcodec.h"
-#include "fourcc.h"
-#include "avutil.h"
-
-/*****************************************************************************
- * decoder_sys_t: decoder descriptor
- *****************************************************************************/
-struct decoder_sys_t
-{
-    /* Common part between video and audio decoder */
-    FFMPEG_COMMON_MEMBERS
-};
-
-/****************************************************************************
- * Local prototypes
- ****************************************************************************/
-static int OpenDecoder( vlc_object_t * );
-static void CloseDecoder( vlc_object_t * );
-
-static const int  nloopf_list[] = { 0, 1, 2, 3, 4 };
-static const char *const nloopf_list_text[] =
-  { N_("None"), N_("Non-ref"), N_("Bidir"), N_("Non-key"), N_("All") };
-
-#ifdef ENABLE_SOUT
-static const char *const enc_hq_list[] = { "rd", "bits", "simple" };
-static const char *const enc_hq_list_text[] = {
-    N_("rd"), N_("bits"), N_("simple") };
-#endif
-
-/*****************************************************************************
- * Module descriptor
- *****************************************************************************/
-#define MODULE_DESCRIPTION N_( "Various audio and video decoders/encoders" \
-        "delivered by the FFmpeg library. This includes (MS)MPEG4, DivX, SV1,"\
-        "H261, H263, H264, WMV, WMA, AAC, AMR, DV, MJPEG and other codecs")
-
-vlc_module_begin();
-    set_shortname( "FFmpeg");
-    add_shortcut( "ffmpeg" );
-    set_category( CAT_INPUT );
-    set_subcategory( SUBCAT_INPUT_SCODEC );
-    /* decoder main module */
-#if defined(MODULE_NAME_is_ffmpegaltivec) \
-     || (defined(CAN_COMPILE_ALTIVEC) && !defined(NO_ALTIVEC_IN_FFMPEG))
-    set_description( N_("AltiVec FFmpeg audio/video decoder ((MS)MPEG4,SVQ1,H263,WMV,WMA)") );
-    /*add_requirement( ALTIVEC );*/
-    set_capability( "decoder", 71 );
-#else
-    set_description( N_("FFmpeg audio/video decoder") );
-    set_help( MODULE_DESCRIPTION );
-    set_capability( "decoder", 70 );
-#endif
-    set_section( N_("Decoding") , NULL );
-    set_callbacks( OpenDecoder, CloseDecoder );
-
-
-    add_bool( "ffmpeg-dr", 1, NULL, DR_TEXT, DR_TEXT, true );
-    add_integer ( "ffmpeg-error-resilience", 1, NULL, ERROR_TEXT,
-        ERROR_LONGTEXT, true );
-    add_integer ( "ffmpeg-workaround-bugs", 1, NULL, BUGS_TEXT, BUGS_LONGTEXT,
-        false );
-    add_bool( "ffmpeg-hurry-up", 1, NULL, HURRYUP_TEXT, HURRYUP_LONGTEXT,
-        false );
-    add_integer( "ffmpeg-skip-frame", 0, NULL, SKIP_FRAME_TEXT,
-        SKIP_FRAME_LONGTEXT, true );
-        change_integer_range( -1, 4 );
-    add_integer( "ffmpeg-skip-idct", 0, NULL, SKIP_IDCT_TEXT,
-        SKIP_IDCT_LONGTEXT, true );
-        change_integer_range( -1, 4 );
-    add_integer ( "ffmpeg-vismv", 0, NULL, VISMV_TEXT, VISMV_LONGTEXT,
-        true );
-    add_integer ( "ffmpeg-lowres", 0, NULL, LOWRES_TEXT, LOWRES_LONGTEXT,
-        true );
-        change_integer_range( 0, 2 );
-    add_integer ( "ffmpeg-skiploopfilter", 0, NULL, SKIPLOOPF_TEXT,
-                  SKIPLOOPF_LONGTEXT, true );
-        change_integer_list( nloopf_list, nloopf_list_text, 0 );
-
-    add_integer( "ffmpeg-debug", 0, NULL, DEBUG_TEXT, DEBUG_LONGTEXT,
-                 true );
-
-#ifdef ENABLE_SOUT
-    /* encoder submodule */
-    add_submodule();
-    set_section( N_("Encoding") , NULL );
-    set_description( N_("FFmpeg audio/video encoder") );
-    set_capability( "encoder", 100 );
-    set_callbacks( OpenEncoder, CloseEncoder );
-
-    add_string( ENC_CFG_PREFIX "hq", "simple", NULL, ENC_HQ_TEXT,
-                ENC_HQ_LONGTEXT, false );
-        change_string_list( enc_hq_list, enc_hq_list_text, 0 );
-    add_integer( ENC_CFG_PREFIX "keyint", 0, NULL, ENC_KEYINT_TEXT,
-                 ENC_KEYINT_LONGTEXT, false );
-    add_integer( ENC_CFG_PREFIX "bframes", 0, NULL, ENC_BFRAMES_TEXT,
-                 ENC_BFRAMES_LONGTEXT, false );
-    add_bool( ENC_CFG_PREFIX "hurry-up", 0, NULL, ENC_HURRYUP_TEXT,
-              ENC_HURRYUP_LONGTEXT, false );
-    add_bool( ENC_CFG_PREFIX "interlace", 0, NULL, ENC_INTERLACE_TEXT,
-              ENC_INTERLACE_LONGTEXT, true );
-    add_bool( ENC_CFG_PREFIX "interlace-me", 1, NULL, ENC_INTERLACE_ME_TEXT,
-              ENC_INTERLACE_ME_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "vt", 0, NULL, ENC_VT_TEXT,
-                 ENC_VT_LONGTEXT, true );
-    add_bool( ENC_CFG_PREFIX "pre-me", 0, NULL, ENC_PRE_ME_TEXT,
-              ENC_PRE_ME_LONGTEXT, true );
-    add_bool( ENC_CFG_PREFIX "strict-rc", 0, NULL, ENC_RC_STRICT_TEXT,
-              ENC_RC_STRICT_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "rc-buffer-size", 224*1024*8, NULL,
-                 ENC_RC_BUF_TEXT, ENC_RC_BUF_LONGTEXT, true );
-    add_float( ENC_CFG_PREFIX "rc-buffer-aggressivity", 1.0, NULL,
-               ENC_RC_BUF_AGGR_TEXT, ENC_RC_BUF_AGGR_LONGTEXT, true );
-    add_float( ENC_CFG_PREFIX "i-quant-factor", 0, NULL,
-               ENC_IQUANT_FACTOR_TEXT, ENC_IQUANT_FACTOR_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "noise-reduction", 0, NULL,
-                 ENC_NOISE_RED_TEXT, ENC_NOISE_RED_LONGTEXT, true );
-    add_bool( ENC_CFG_PREFIX "mpeg4-matrix", 0, NULL,
-              ENC_MPEG4_MATRIX_TEXT, ENC_MPEG4_MATRIX_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "qmin", 0, NULL,
-                 ENC_QMIN_TEXT, ENC_QMIN_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "qmax", 0, NULL,
-                 ENC_QMAX_TEXT, ENC_QMAX_LONGTEXT, true );
-    add_bool( ENC_CFG_PREFIX "trellis", 0, NULL,
-              ENC_TRELLIS_TEXT, ENC_TRELLIS_LONGTEXT, true );
-    add_float( ENC_CFG_PREFIX "qscale", 0, NULL,
-               ENC_QSCALE_TEXT, ENC_QSCALE_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "strict", 0, NULL,
-                 ENC_STRICT_TEXT, ENC_STRICT_LONGTEXT, true );
-    add_float( ENC_CFG_PREFIX "lumi-masking", 0.0, NULL,
-               ENC_LUMI_MASKING_TEXT, ENC_LUMI_MASKING_LONGTEXT, true );
-    add_float( ENC_CFG_PREFIX "dark-masking", 0.0, NULL,
-               ENC_DARK_MASKING_TEXT, ENC_DARK_MASKING_LONGTEXT, true );
-    add_float( ENC_CFG_PREFIX "p-masking", 0.0, NULL,
-               ENC_P_MASKING_TEXT, ENC_P_MASKING_LONGTEXT, true );
-    add_float( ENC_CFG_PREFIX "border-masking", 0.0, NULL,
-               ENC_BORDER_MASKING_TEXT, ENC_BORDER_MASKING_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "luma-elim-threshold", 0, NULL,
-                 ENC_LUMA_ELIM_TEXT, ENC_LUMA_ELIM_LONGTEXT, true );
-    add_integer( ENC_CFG_PREFIX "chroma-elim-threshold", 0, NULL,
-                 ENC_CHROMA_ELIM_TEXT, ENC_CHROMA_ELIM_LONGTEXT, true );
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
-    /* Audio AAC encoder profile */
-    add_string( ENC_CFG_PREFIX "aac-profile", "main", NULL,
-                ENC_PROFILE_TEXT, ENC_PROFILE_LONGTEXT, true );
-#endif
-#endif /* ENABLE_SOUT */
-
-    /* video filter submodule */
-    add_submodule();
-    set_capability( "video filter2", 0 );
-    set_callbacks( OpenDeinterlace, CloseDeinterlace );
-    set_description( N_("FFmpeg deinterlace video filter") );
-    add_shortcut( "ffmpeg-deinterlace" );
-
-vlc_module_end();
-
-/*****************************************************************************
- * OpenDecoder: probe the decoder and return score
- *****************************************************************************/
-static int OpenDecoder( vlc_object_t *p_this )
-{
-    decoder_t *p_dec = (decoder_t*) p_this;
-    int i_cat, i_codec_id, i_result;
-    const char *psz_namecodec;
-
-    AVCodecContext *p_context = NULL;
-    AVCodec        *p_codec = NULL;
-
-    /* *** determine codec type *** */
-    if( !GetFfmpegCodec( p_dec->fmt_in.i_codec, &i_cat, &i_codec_id,
-                             &psz_namecodec ) )
-    {
-        return VLC_EGENERIC;
-    }
-
-    /* Bail out if buggy decoder */
-    if( i_codec_id == CODEC_ID_AAC )
-    {
-        msg_Dbg( p_dec, "refusing to use ffmpeg's (%s) decoder which is buggy",
-                 psz_namecodec );
-        return VLC_EGENERIC;
-    }
-
-    /* Initialization must be done before avcodec_find_decoder() */
-    InitLibavcodec(p_this);
-
-    /* *** ask ffmpeg for a decoder *** */
-    p_codec = avcodec_find_decoder( i_codec_id );
-    if( !p_codec )
-    {
-        msg_Dbg( p_dec, "codec not found (%s)", psz_namecodec );
-        return VLC_EGENERIC;
-    }
-
-    /* *** get a p_context *** */
-    p_context = avcodec_alloc_context();
-    if( !p_context )
-        return VLC_ENOMEM;
-    p_context->debug = config_GetInt( p_dec, "ffmpeg-debug" );
-    p_context->opaque = (void *)p_this;
-
-    /* Set CPU capabilities */
-    unsigned i_cpu = vlc_CPU();
-    p_context->dsp_mask = 0;
-    if( !(i_cpu & CPU_CAPABILITY_MMX) )
-    {
-        p_context->dsp_mask |= FF_MM_MMX;
-    }
-    if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
-    {
-        p_context->dsp_mask |= FF_MM_MMXEXT;
-    }
-    if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
-    {
-        p_context->dsp_mask |= FF_MM_3DNOW;
-    }
-    if( !(i_cpu & CPU_CAPABILITY_SSE) )
-    {
-        p_context->dsp_mask |= FF_MM_SSE;
-    }
-    if( !(i_cpu & CPU_CAPABILITY_SSE2) )
-    {
-        p_context->dsp_mask |= FF_MM_SSE2;
-    }
-
-    p_dec->b_need_packetized = true;
-    switch( i_cat )
-    {
-    case VIDEO_ES:
-        p_dec->pf_decode_video = DecodeVideo;
-        i_result =  InitVideoDec ( p_dec, p_context, p_codec,
-                                       i_codec_id, psz_namecodec );
-        break;
-    case AUDIO_ES:
-        p_dec->pf_decode_audio = DecodeAudio;
-        i_result =  InitAudioDec ( p_dec, p_context, p_codec,
-                                       i_codec_id, psz_namecodec );
-        break;
-    default:
-        i_result = VLC_EGENERIC;
-    }
-
-    if( i_result == VLC_SUCCESS ) p_dec->p_sys->i_cat = i_cat;
-
-    return i_result;
-}
-
-/*****************************************************************************
- * CloseDecoder: decoder destruction
- *****************************************************************************/
-static void CloseDecoder( vlc_object_t *p_this )
-{
-    decoder_t *p_dec = (decoder_t *)p_this;
-    decoder_sys_t *p_sys = p_dec->p_sys;
-
-    switch( p_sys->i_cat )
-    {
-    case AUDIO_ES:
-         EndAudioDec ( p_dec );
-        break;
-    case VIDEO_ES:
-         EndVideoDec ( p_dec );
-        break;
-    }
-
-    if( p_sys->p_context )
-    {
-        vlc_mutex_t *lock;
-
-        if( p_sys->p_context->extradata )
-            free( p_sys->p_context->extradata );
-        p_sys->p_context->extradata = NULL;
-
-        lock = var_AcquireMutex( "avcodec" );
-        avcodec_close( p_sys->p_context );
-        vlc_mutex_unlock( lock );
-        msg_Dbg( p_dec, "ffmpeg codec (%s) stopped", p_sys->psz_namecodec );
-        av_free( p_sys->p_context );
-    }
-
-    free( p_sys );
-}
-
-void InitLibavcodec( vlc_object_t *p_object )
-{
-    static int b_ffmpeginit = 0;
-    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
-
-    /* *** init ffmpeg library (libavcodec) *** */
-    if( !b_ffmpeginit )
-    {
-        avcodec_init();
-        avcodec_register_all();
-        av_log_set_callback( LibavutilCallback );
-        b_ffmpeginit = 1;
-
-        msg_Dbg( p_object, "libavcodec initialized (interface %d )",
-                 LIBAVCODEC_VERSION_INT );
-    }
-    else
-    {
-        msg_Dbg( p_object, "libavcodec already initialized" );
-    }
-
-    vlc_mutex_unlock( lock );
-}
diff --git a/modules/codec/ffmpeg/avcodec.h b/modules/codec/ffmpeg/avcodec.h
deleted file mode 100644 (file)
index c80aa87..0000000
+++ /dev/null
@@ -1,244 +0,0 @@
-/*****************************************************************************
- * avcodec.h: decoder and encoder using libavcodec
- *****************************************************************************
- * Copyright (C) 2001-2008 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-picture_t * DecodeVideo    ( decoder_t *, block_t ** );
-aout_buffer_t * DecodeAudio( decoder_t *, block_t ** );
-
-/* Video encoder module */
-int  OpenEncoder ( vlc_object_t * );
-void CloseEncoder( vlc_object_t * );
-
-/* Audio encoder module */
-int  OpenAudioEncoder ( vlc_object_t * );
-void CloseAudioEncoder( vlc_object_t * );
-
-/* Deinterlace video filter module */
-int  OpenDeinterlace( vlc_object_t * );
-void CloseDeinterlace( vlc_object_t * );
-
-void InitLibavcodec( vlc_object_t *p_object );
-
-/* Video Decoder */
-int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,
-                  AVCodec *p_codec, int i_codec_id, const char *psz_namecodec );
-void EndVideoDec( decoder_t *p_dec );
-
-/* Audio Decoder */
-int InitAudioDec( decoder_t *p_dec, AVCodecContext *p_context,
-                  AVCodec *p_codec, int i_codec_id, const char *psz_namecodec );
-void EndAudioDec( decoder_t *p_dec );
-
-/*****************************************************************************
- * Module descriptor help strings
- *****************************************************************************/
-#define DR_TEXT N_("Direct rendering")
-/* FIXME Does somebody who knows what it does, explain */
-#define DR_LONGTEXT N_("Direct rendering")
-
-#define ERROR_TEXT N_("Error resilience")
-#define ERROR_LONGTEXT N_( \
-    "Ffmpeg can do error resilience.\n" \
-    "However, with a buggy encoder (such as the ISO MPEG-4 encoder from M$) " \
-    "this can produce a lot of errors.\n" \
-    "Valid values range from 0 to 4 (0 disables all errors resilience).")
-
-#define BUGS_TEXT N_("Workaround bugs")
-#define BUGS_LONGTEXT N_( \
-    "Try to fix some bugs:\n" \
-    "1  autodetect\n" \
-    "2  old msmpeg4\n" \
-    "4  xvid interlaced\n" \
-    "8  ump4 \n" \
-    "16 no padding\n" \
-    "32 ac vlc\n" \
-    "64 Qpel chroma.\n" \
-    "This must be the sum of the values. For example, to fix \"ac vlc\" and " \
-    "\"ump4\", enter 40.")
-
-#define HURRYUP_TEXT N_("Hurry up")
-#define HURRYUP_LONGTEXT N_( \
-    "The decoder can partially decode or skip frame(s) " \
-    "when there is not enough time. It's useful with low CPU power " \
-    "but it can produce distorted pictures.")
-
-#define SKIP_FRAME_TEXT N_("Skip frame (default=0)")
-#define SKIP_FRAME_LONGTEXT N_( \
-    "Force skipping of frames to speed up decoding " \
-    "(-1=None, 0=Default, 1=B-frames, 2=P-frames, 3=B+P frames, 4=all frames)." )
-
-#define SKIP_IDCT_TEXT N_("Skip idct (default=0)")
-#define SKIP_IDCT_LONGTEXT N_( \
-    "Force skipping of idct to speed up decoding for frame types" \
-    "(-1=None, 0=Default, 1=B-frames, 2=P-frames, 3=B+P frames, 4=all frames)." )
-
-#define DEBUG_TEXT N_( "Debug mask" )
-#define DEBUG_LONGTEXT N_( "Set ffmpeg debug mask" )
-
-/* TODO: Use a predefined list, with 0,1,2,4,7 */
-#define VISMV_TEXT N_( "Visualize motion vectors" )
-#define VISMV_LONGTEXT N_( \
-    "You can overlay the motion vectors (arrows showing how the images move) "\
-    "on the image. This value is a mask, based on these values:\n"\
-    "1 - visualize forward predicted MVs of P frames\n" \
-    "2 - visualize forward predicted MVs of B frames\n" \
-    "4 - visualize backward predicted MVs of B frames\n" \
-    "To visualize all vectors, the value should be 7." )
-
-#define LOWRES_TEXT N_( "Low resolution decoding" )
-#define LOWRES_LONGTEXT N_( "Only decode a low resolution version of " \
-    "the video. This requires less processing power" )
-
-#define SKIPLOOPF_TEXT N_( "Skip the loop filter for H.264 decoding" )
-#define SKIPLOOPF_LONGTEXT N_( "Skipping the loop filter (aka deblocking) " \
-    "usually has a detrimental effect on quality. However it provides a big " \
-    "speedup for high definition streams." )
-
-/*
- * Encoder options
- */
-#define ENC_CFG_PREFIX "sout-ffmpeg-"
-
-#define ENC_KEYINT_TEXT N_( "Ratio of key frames" )
-#define ENC_KEYINT_LONGTEXT N_( "Number of frames " \
-  "that will be coded for one key frame." )
-
-#define ENC_BFRAMES_TEXT N_( "Ratio of B frames" )
-#define ENC_BFRAMES_LONGTEXT N_( "Number of " \
-  "B frames that will be coded between two reference frames." )
-
-#define ENC_VT_TEXT N_( "Video bitrate tolerance" )
-#define ENC_VT_LONGTEXT N_( "Video bitrate tolerance in kbit/s." )
-
-#define ENC_INTERLACE_TEXT N_( "Interlaced encoding" )
-#define ENC_INTERLACE_LONGTEXT N_( "Enable dedicated " \
-  "algorithms for interlaced frames." )
-
-#define ENC_INTERLACE_ME_TEXT N_( "Interlaced motion estimation" )
-#define ENC_INTERLACE_ME_LONGTEXT N_( "Enable interlaced " \
-  "motion estimation algorithms. This requires more CPU." )
-
-#define ENC_PRE_ME_TEXT N_( "Pre-motion estimation" )
-#define ENC_PRE_ME_LONGTEXT N_( "Enable the pre-motion " \
-  "estimation algorithm.")
-
-#define ENC_RC_STRICT_TEXT N_( "Strict rate control" )
-#define ENC_RC_STRICT_LONGTEXT N_( "Enable the strict rate " \
-  "control algorithm." )
-
-#define ENC_RC_BUF_TEXT N_( "Rate control buffer size" )
-#define ENC_RC_BUF_LONGTEXT N_( "Rate control " \
-  "buffer size (in kbytes). A bigger buffer will allow for better rate " \
-  "control, but will cause a delay in the stream." )
-
-#define ENC_RC_BUF_AGGR_TEXT N_( "Rate control buffer aggressiveness" )
-#define ENC_RC_BUF_AGGR_LONGTEXT N_( "Rate control "\
-  "buffer aggressiveness." )
-
-#define ENC_IQUANT_FACTOR_TEXT N_( "I quantization factor" )
-#define ENC_IQUANT_FACTOR_LONGTEXT N_(  \
-  "Quantization factor of I frames, compared with P frames (for instance " \
-  "1.0 => same qscale for I and P frames)." )
-
-#define ENC_NOISE_RED_TEXT N_( "Noise reduction" )
-#define ENC_NOISE_RED_LONGTEXT N_( "Enable a simple noise " \
-  "reduction algorithm to lower the encoding length and bitrate, at the " \
-  "expense of lower quality frames." )
-
-#define ENC_MPEG4_MATRIX_TEXT N_( "MPEG4 quantization matrix" )
-#define ENC_MPEG4_MATRIX_LONGTEXT N_( "Use the MPEG4 " \
-  "quantization matrix for MPEG2 encoding. This generally yields a " \
-  "better looking picture, while still retaining the compatibility with " \
-  "standard MPEG2 decoders.")
-
-#define ENC_HQ_TEXT N_( "Quality level" )
-#define ENC_HQ_LONGTEXT N_( "Quality level " \
-  "for the encoding of motions vectors (this can slow down the encoding " \
-  "very much)." )
-
-#define ENC_HURRYUP_TEXT N_( "Hurry up" )
-#define ENC_HURRYUP_LONGTEXT N_( "The encoder " \
-  "can make on-the-fly quality tradeoffs if your CPU can't keep up with " \
-  "the encoding rate. It will disable trellis quantization, then the rate " \
-  "distortion of motion vectors (hq), and raise the noise reduction " \
-  "threshold to ease the encoder's task." )
-
-#define ENC_QMIN_TEXT N_( "Minimum video quantizer scale" )
-#define ENC_QMIN_LONGTEXT N_( "Minimum video " \
-  "quantizer scale." )
-
-#define ENC_QMAX_TEXT N_( "Maximum video quantizer scale" )
-#define ENC_QMAX_LONGTEXT N_( "Maximum video " \
-  "quantizer scale." )
-
-#define ENC_TRELLIS_TEXT N_( "Trellis quantization" )
-#define ENC_TRELLIS_LONGTEXT N_( "Enable trellis " \
-  "quantization (rate distortion for block coefficients)." )
-
-#define ENC_QSCALE_TEXT N_( "Fixed quantizer scale" )
-#define ENC_QSCALE_LONGTEXT N_( "A fixed video " \
-  "quantizer scale for VBR encoding (accepted values: 0.01 to 255.0)." )
-
-#define ENC_STRICT_TEXT N_( "Strict standard compliance" )
-#define ENC_STRICT_LONGTEXT N_( "Force a strict standard " \
-  "compliance when encoding (accepted values: -1, 0, 1)." )
-
-#define ENC_LUMI_MASKING_TEXT N_( "Luminance masking" )
-#define ENC_LUMI_MASKING_LONGTEXT N_( "Raise the quantizer for " \
-  "very bright macroblocks (default: 0.0)." )
-
-#define ENC_DARK_MASKING_TEXT N_( "Darkness masking" )
-#define ENC_DARK_MASKING_LONGTEXT N_( "Raise the quantizer for " \
-  "very dark macroblocks (default: 0.0)." )
-
-#define ENC_P_MASKING_TEXT N_( "Motion masking" )
-#define ENC_P_MASKING_LONGTEXT N_( "Raise the quantizer for " \
-  "macroblocks with a high temporal complexity (default: 0.0)." )
-
-#define ENC_BORDER_MASKING_TEXT N_( "Border masking" )
-#define ENC_BORDER_MASKING_LONGTEXT N_( "Raise the quantizer " \
-  "for macroblocks at the border of the frame (default: 0.0)." )
-
-#define ENC_LUMA_ELIM_TEXT N_( "Luminance elimination" )
-#define ENC_LUMA_ELIM_LONGTEXT N_( "Eliminates luminance blocks when " \
-  "the PSNR isn't much changed (default: 0.0). The H264 specification " \
-  "recommends -4." )
-
-#define ENC_CHROMA_ELIM_TEXT N_( "Chrominance elimination" )
-#define ENC_CHROMA_ELIM_LONGTEXT N_( "Eliminates chrominance blocks when " \
-  "the PSNR isn't much changed (default: 0.0). The H264 specification " \
-  "recommends 7." )
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
-#define ENC_PROFILE_TEXT N_( "Specify AAC audio profile to use" )
-#define ENC_PROFILE_LONGTEXT N_( "Specify the AAC audio profile to use " \
-   "for encoding the audio bitstream. It takes the following options: " \
-   "main, low, ssr (not supported) and ltp (default: main)" )
-#endif
-
-#define FFMPEG_COMMON_MEMBERS   \
-    int i_cat;                  \
-    int i_codec_id;             \
-    const char *psz_namecodec;  \
-    AVCodecContext *p_context;  \
-    AVCodec        *p_codec;
-
diff --git a/modules/codec/ffmpeg/avutil.h b/modules/codec/ffmpeg/avutil.h
deleted file mode 100644 (file)
index d7e5548..0000000
+++ /dev/null
@@ -1,80 +0,0 @@
-/*****************************************************************************
- * avutil.h: avutil helper functions
- *****************************************************************************
- * Copyright (C) 1999-2008 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *          Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Export libavutil messages to the VLC message system
- *****************************************************************************/
-void LibavutilCallback( void *p_opaque, int i_level,
-                        const char *psz_format, va_list va )
-{
-    int i_vlc_level;
-    AVCodecContext *p_avctx = (AVCodecContext *)p_opaque;
-    AVClass *p_avc;
-    vlc_object_t *p_this;
-    char *psz_new_format;
-    const char *psz_item_name;
-
-    p_avc = p_avctx ? p_avctx->av_class : 0;
-
-#define cln p_avc->class_name
-    /* Make sure we can get p_this back */
-    if( !p_avctx || !p_avc || !cln ||
-        cln[0]!='A' || cln[1]!='V' || cln[2]!='C' || cln[3]!='o' ||
-        cln[4]!='d' || cln[5]!='e' || cln[6]!='c' )
-    {
-        if( i_level == AV_LOG_ERROR ) vfprintf( stderr, psz_format, va );
-        return;
-    }
-#undef cln
-
-    p_this = (vlc_object_t *)p_avctx->opaque;
-
-    switch( i_level )
-    {
-    case AV_LOG_QUIET:
-        i_vlc_level = VLC_MSG_ERR;
-        break;
-    case AV_LOG_ERROR:
-        i_vlc_level = VLC_MSG_WARN;
-        break;
-    case AV_LOG_INFO:
-        i_vlc_level = VLC_MSG_DBG;
-        break;
-    case AV_LOG_DEBUG:
-        /* Print debug messages if they were requested */
-        if( p_avctx->debug ) vfprintf( stderr, psz_format, va );
-        return;
-    default:
-        return;
-    }
-
-    psz_item_name = p_avc->item_name(p_opaque);
-    psz_new_format = malloc( strlen(psz_format) + strlen(psz_item_name)
-                              + 18 + 5 );
-    snprintf( psz_new_format, strlen(psz_format) + strlen(psz_item_name)
-              + 18 + 5, "%s (%s@%p)", psz_format, p_avc->item_name(p_opaque), p_opaque );
-    msg_GenericVa( p_this, i_vlc_level,
-                    MODULE_STRING, psz_new_format, va );
-    free( psz_new_format );
-}
diff --git a/modules/codec/ffmpeg/chroma.h b/modules/codec/ffmpeg/chroma.h
deleted file mode 100644 (file)
index f538761..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-/*****************************************************************************
- * chroma.h: libavutil <-> libvlc conversion routines
- *****************************************************************************
- * Copyright (C) 1999-2008 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *          Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Chroma fourcc -> ffmpeg_id mapping
- *****************************************************************************/
-static struct
-{
-    vlc_fourcc_t  i_chroma;
-    int  i_chroma_id;
-
-} chroma_table[] =
-{
-    /* Planar YUV formats */
-    { VLC_FOURCC('Y','U','V','A'), PIX_FMT_YUV444P }, /* Hack */
-    { VLC_FOURCC('I','4','4','4'), PIX_FMT_YUV444P },
-    { VLC_FOURCC('J','4','4','4'), PIX_FMT_YUVJ444P },
-    { VLC_FOURCC('I','4','2','2'), PIX_FMT_YUV422P },
-    { VLC_FOURCC('J','4','2','2'), PIX_FMT_YUVJ422P },
-    { VLC_FOURCC('I','4','2','0'), PIX_FMT_YUV420P },
-    { VLC_FOURCC('Y','V','1','2'), PIX_FMT_YUV420P },
-    { VLC_FOURCC('I','Y','U','V'), PIX_FMT_YUV420P },
-    { VLC_FOURCC('J','4','2','0'), PIX_FMT_YUVJ420P },
-    { VLC_FOURCC('I','4','1','1'), PIX_FMT_YUV411P },
-    { VLC_FOURCC('I','4','1','0'), PIX_FMT_YUV410P },
-    { VLC_FOURCC('Y','V','U','9'), PIX_FMT_YUV410P },
-
-    /* Packed YUV formats */
-    { VLC_FOURCC('Y','U','Y','2'), PIX_FMT_YUV422 },
-    { VLC_FOURCC('Y','U','Y','V'), PIX_FMT_YUV422 },
-    { VLC_FOURCC('U','Y','V','Y'), PIX_FMT_UYVY422 },
-
-    /* Packed RGB formats */
-#if defined(WORDS_BIGENDIAN)
-    { VLC_FOURCC('R','G','B','8'), PIX_FMT_BGR8 },
-    { VLC_FOURCC('R','V','1','5'), PIX_FMT_BGR555 },
-    { VLC_FOURCC('R','V','1','6'), PIX_FMT_BGR565 },
-    { VLC_FOURCC('R','V','2','4'), PIX_FMT_BGR24 },
-#else
-#if defined(PIX_FMT_RGB8)
-    { VLC_FOURCC('R','G','B','8'), PIX_FMT_RGB8 },
-#endif
-    { VLC_FOURCC('R','V','1','5'), PIX_FMT_RGB555 },
-    { VLC_FOURCC('R','V','1','6'), PIX_FMT_RGB565 },
-    { VLC_FOURCC('R','V','2','4'), PIX_FMT_RGB24 },
-#endif
-    { VLC_FOURCC('R','V','3','2'), PIX_FMT_RGBA32 },
-#if defined(PIX_FMT_RGBA)
-    { VLC_FOURCC('R','G','B','A'), PIX_FMT_RGBA },
-#endif
-    { VLC_FOURCC('G','R','E','Y'), PIX_FMT_GRAY8 },
-
-    { 0, 0 }
-};
-
-static int GetFfmpegChroma( vlc_fourcc_t i_chroma )
-{
-    int i;
-
-    for( i = 0; chroma_table[i].i_chroma != 0; i++ )
-    {
-        if( chroma_table[i].i_chroma == i_chroma )
-            return chroma_table[i].i_chroma_id;
-    }
-    return -1;
-}
-
-static vlc_fourcc_t GetVlcChroma( int i_ffmpeg_chroma )
-{
-    int i;
-
-    for( i = 0; chroma_table[i].i_chroma != 0; i++ )
-    {
-        if( chroma_table[i].i_chroma_id == i_ffmpeg_chroma )
-            return chroma_table[i].i_chroma;
-    }
-    return 0;
-}
diff --git a/modules/codec/ffmpeg/deinterlace.c b/modules/codec/ffmpeg/deinterlace.c
deleted file mode 100644 (file)
index c9299c2..0000000
+++ /dev/null
@@ -1,159 +0,0 @@
-/*****************************************************************************
- * video filter: video filter doing chroma conversion and resizing
- *               using the ffmpeg library
- *****************************************************************************
- * Copyright (C) 1999-2001 the VideoLAN team
- * $Id$
- *
- * Authors: Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble
- *****************************************************************************/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <vlc_common.h>
-#include <vlc_codec.h>
-#include <vlc_vout.h>
-#include <vlc_filter.h>
-
-/* ffmpeg header */
-#ifdef HAVE_LIBAVCODEC_AVCODEC_H
-#   include <libavcodec/avcodec.h>
-#elif defined(HAVE_FFMPEG_AVCODEC_H)
-#   include <ffmpeg/avcodec.h>
-#else
-#   include <avcodec.h>
-#endif
-
-#include "avcodec.h"
-#include "chroma.h"
-
-static picture_t *Deinterlace( filter_t *p_filter, picture_t *p_pic );
-
-/*****************************************************************************
- * filter_sys_t : filter descriptor
- *****************************************************************************/
-struct filter_sys_t
-{
-    bool b_resize;
-    bool b_convert;
-    bool b_resize_first;
-    bool b_enable_croppadd;
-
-    es_format_t fmt_in;
-    int i_src_ffmpeg_chroma;
-    es_format_t fmt_out;
-    int i_dst_ffmpeg_chroma;
-
-    AVPicture tmp_pic;
-};
-
-/*****************************************************************************
- * OpenDeinterlace: probe the filter and return score
- *****************************************************************************/
-int OpenDeinterlace( vlc_object_t *p_this )
-{
-    filter_t *p_filter = (filter_t*)p_this;
-    filter_sys_t *p_sys;
-
-    /* Check if we can handle that formats */
-    if( GetFfmpegChroma( p_filter->fmt_in.video.i_chroma ) < 0 )
-    {
-        return VLC_EGENERIC;
-    }
-
-    /* Allocate the memory needed to store the decoder's structure */
-    if( ( p_filter->p_sys = p_sys =
-          (filter_sys_t *)malloc(sizeof(filter_sys_t)) ) == NULL )
-    {
-        msg_Err( p_filter, "out of memory" );
-        return VLC_EGENERIC;
-    }
-
-    /* Misc init */
-    p_sys->i_src_ffmpeg_chroma =
-        GetFfmpegChroma( p_filter->fmt_in.video.i_chroma );
-    p_filter->pf_video_filter = Deinterlace;
-
-    msg_Dbg( p_filter, "deinterlacing" );
-
-    /* libavcodec needs to be initialized for some chroma conversions */
-    InitLibavcodec(p_this);
-
-    return VLC_SUCCESS;
-}
-
-/*****************************************************************************
- * CloseDeinterlace: clean up the filter
- *****************************************************************************/
-void CloseDeinterlace( vlc_object_t *p_this )
-{
-    filter_t *p_filter = (filter_t*)p_this;
-    filter_sys_t *p_sys = p_filter->p_sys;
-
-    free( p_sys );
-}
-
-/*****************************************************************************
- * Do the processing here
- *****************************************************************************/
-static picture_t *Deinterlace( filter_t *p_filter, picture_t *p_pic )
-{
-    filter_sys_t *p_sys = p_filter->p_sys;
-    AVPicture src_pic, dest_pic;
-    picture_t *p_pic_dst;
-    int i, i_res = -1;
-
-    /* Request output picture */
-    p_pic_dst = p_filter->pf_vout_buffer_new( p_filter );
-    if( !p_pic_dst )
-        return NULL;
-
-    /* Prepare the AVPictures for the conversion */
-    for( i = 0; i < p_pic->i_planes; i++ )
-    {
-        src_pic.data[i] = p_pic->p[i].p_pixels;
-        src_pic.linesize[i] = p_pic->p[i].i_pitch;
-    }
-    for( i = 0; i < p_pic_dst->i_planes; i++ )
-    {
-        dest_pic.data[i] = p_pic_dst->p[i].p_pixels;
-        dest_pic.linesize[i] = p_pic_dst->p[i].i_pitch;
-    }
-
-    i_res = avpicture_deinterlace( &dest_pic, &src_pic, p_sys->i_src_ffmpeg_chroma,
-                                   p_filter->fmt_in.video.i_width,
-                                   p_filter->fmt_in.video.i_height );
-    if( i_res == -1 )
-    {
-        msg_Err( p_filter, "deinterlacing picture failed" );
-        p_filter->pf_vout_buffer_del( p_filter, p_pic_dst );
-        return NULL;
-    }
-    p_pic_dst->date = p_pic->date;
-    p_pic_dst->b_force = p_pic->b_force;
-    p_pic_dst->i_nb_fields = p_pic->i_nb_fields;
-    p_pic_dst->b_progressive = true;
-    p_pic_dst->b_top_field_first = p_pic->b_top_field_first;
-
-    p_pic->pf_release( p_pic );
-    return p_pic_dst;
-}
diff --git a/modules/codec/ffmpeg/encoder.c b/modules/codec/ffmpeg/encoder.c
deleted file mode 100644 (file)
index 7adeb0f..0000000
+++ /dev/null
@@ -1,1103 +0,0 @@
-/*****************************************************************************
- * encoder.c: video and audio encoder using the ffmpeg library
- *****************************************************************************
- * Copyright (C) 1999-2004 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *          Gildas Bazin <gbazin@videolan.org>
- *          Christophe Massiot <massiot@via.ecp.fr>
- * Part of the file Copyright (C) FFMPEG Project Developers
- * (mpeg4_default matrixes)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble
- *****************************************************************************/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <vlc_common.h>
-#include <vlc_vout.h>
-#include <vlc_aout.h>
-#include <vlc_sout.h>
-#include <vlc_codec.h>
-#include <vlc_interface.h>
-
-/* ffmpeg header */
-#define HAVE_MMX 1
-#ifdef HAVE_LIBAVCODEC_AVCODEC_H
-#   include <libavcodec/avcodec.h>
-#elif defined(HAVE_FFMPEG_AVCODEC_H)
-#   include <ffmpeg/avcodec.h>
-#else
-#   include <avcodec.h>
-#endif
-
-#include "avcodec.h"
-#include "chroma.h"
-#include "fourcc.h"
-
-#define HURRY_UP_GUARD1 (450000)
-#define HURRY_UP_GUARD2 (300000)
-#define HURRY_UP_GUARD3 (100000)
-
-#define MAX_FRAME_DELAY (FF_MAX_B_FRAMES + 2)
-
-/*****************************************************************************
- * Local prototypes
- *****************************************************************************/
-int  OpenEncoder ( vlc_object_t * );
-void CloseEncoder( vlc_object_t * );
-
-static block_t *EncodeVideo( encoder_t *, picture_t * );
-static block_t *EncodeAudio( encoder_t *, aout_buffer_t * );
-
-struct thread_context_t;
-static int FfmpegThread( struct thread_context_t *p_context );
-static int FfmpegExecute( AVCodecContext *s,
-                          int (*pf_func)(AVCodecContext *c2, void *arg2),
-                          void **arg, int *ret, int count );
-
-/*****************************************************************************
- * thread_context_t : for multithreaded encoding
- *****************************************************************************/
-struct thread_context_t
-{
-    VLC_COMMON_MEMBERS
-
-    AVCodecContext  *p_context;
-    int             (* pf_func)(AVCodecContext *c, void *arg);
-    void            *arg;
-    int             i_ret;
-
-    vlc_mutex_t     lock;
-    vlc_cond_t      cond;
-    bool            b_work, b_done;
-};
-
-/*****************************************************************************
- * encoder_sys_t : ffmpeg encoder descriptor
- *****************************************************************************/
-struct encoder_sys_t
-{
-    /*
-     * Ffmpeg properties
-     */
-    AVCodec         *p_codec;
-    AVCodecContext  *p_context;
-
-    /*
-     * Common properties
-     */
-    char *p_buffer;
-    char *p_buffer_out;
-
-    /*
-     * Video properties
-     */
-    mtime_t i_last_ref_pts;
-    mtime_t i_buggy_pts_detect;
-    mtime_t i_last_pts;
-    bool    b_inited;
-
-    /*
-     * Audio properties
-     */
-    int i_frame_size;
-    int i_samples_delay;
-    mtime_t i_pts;
-
-    /* Encoding settings */
-    int        i_key_int;
-    int        i_b_frames;
-    int        i_vtolerance;
-    int        i_qmin;
-    int        i_qmax;
-    int        i_hq;
-    bool       b_strict_rc;
-    int        i_rc_buffer_size;
-    float      f_rc_buffer_aggressivity;
-    bool       b_pre_me;
-    bool       b_hurry_up;
-    bool       b_interlace, b_interlace_me;
-    float      f_i_quant_factor;
-    int        i_noise_reduction;
-    bool       b_mpeg4_matrix;
-    bool       b_trellis;
-    int        i_quality; /* for VBR */
-    float      f_lumi_masking, f_dark_masking, f_p_masking, f_border_masking;
-    int        i_luma_elim, i_chroma_elim;
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
-    int        i_aac_profile; /* AAC profile to use.*/
-#endif
-    /* Used to work around stupid timestamping behaviour in libavcodec */
-    uint64_t i_framenum;
-    mtime_t  pi_delay_pts[MAX_FRAME_DELAY];
-};
-
-static const char *const ppsz_enc_options[] = {
-    "keyint", "bframes", "vt", "qmin", "qmax", "hq", "strict-rc",
-    "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
-    "interlace", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
-    "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
-    "p-masking", "border-masking", "luma-elim-threshold",
-    "chroma-elim-threshold",
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
-     "aac-profile",
-#endif
-     NULL
-};
-
-static const uint16_t mpa_bitrate_tab[2][15] =
-{
-    {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
-    {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
-};
-
-static const uint16_t mpa_freq_tab[6] =
-{ 44100, 48000, 32000, 22050, 24000, 16000 };
-
-static const uint16_t mpeg4_default_intra_matrix[64] = {
-  8, 17, 18, 19, 21, 23, 25, 27,
- 17, 18, 19, 21, 23, 25, 27, 28,
- 20, 21, 22, 23, 24, 26, 28, 30,
- 21, 22, 23, 24, 26, 28, 30, 32,
- 22, 23, 24, 26, 28, 30, 32, 35,
- 23, 24, 26, 28, 30, 32, 35, 38,
- 25, 26, 28, 30, 32, 35, 38, 41,
- 27, 28, 30, 32, 35, 38, 41, 45,
-};
-
-static const uint16_t mpeg4_default_non_intra_matrix[64] = {
- 16, 17, 18, 19, 20, 21, 22, 23,
- 17, 18, 19, 20, 21, 22, 23, 24,
- 18, 19, 20, 21, 22, 23, 24, 25,
- 19, 20, 21, 22, 23, 24, 26, 27,
- 20, 21, 22, 23, 25, 26, 27, 28,
- 21, 22, 23, 24, 26, 27, 28, 30,
- 22, 23, 24, 26, 27, 28, 30, 31,
- 23, 24, 25, 27, 28, 30, 31, 33,
-};
-
-/*****************************************************************************
- * OpenEncoder: probe the encoder
- *****************************************************************************/
-
-int OpenEncoder( vlc_object_t *p_this )
-{
-    encoder_t *p_enc = (encoder_t *)p_this;
-    encoder_sys_t *p_sys = p_enc->p_sys;
-    AVCodecContext *p_context;
-    AVCodec *p_codec;
-    int i_codec_id, i_cat;
-    const char *psz_namecodec;
-    vlc_value_t val;
-
-    if( !GetFfmpegCodec( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
-                             &psz_namecodec ) )
-    {
-        if( GetFfmpegChroma( p_enc->fmt_out.i_codec ) < 0 )
-        {
-            /* handed chroma output */
-            return VLC_EGENERIC;
-        }
-        i_cat      = VIDEO_ES;
-        i_codec_id = CODEC_ID_RAWVIDEO;
-        psz_namecodec = "Raw video";
-    }
-
-    if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
-    {
-        msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
-        intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
-                        _("\"%s\" is no video encoder."), psz_namecodec );
-        return VLC_EGENERIC;
-    }
-
-    if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
-    {
-        msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
-        intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
-                        _("\"%s\" is no audio encoder."), psz_namecodec );
-        return VLC_EGENERIC;
-    }
-
-    /* Initialization must be done before avcodec_find_encoder() */
-    InitLibavcodec( p_this );
-
-    p_codec = avcodec_find_encoder( i_codec_id );
-    if( !p_codec )
-    {
-        msg_Err( p_enc, "cannot find encoder %s", psz_namecodec );
-        intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
-                        _("VLC could not find encoder \"%s\"."), psz_namecodec );
-        return VLC_EGENERIC;
-    }
-
-    /* Allocate the memory needed to store the encoder's structure */
-    if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
-    {
-        msg_Err( p_enc, "out of memory" );
-        return VLC_EGENERIC;
-    }
-    memset( p_sys, 0, sizeof(encoder_sys_t) );
-    p_enc->p_sys = p_sys;
-    p_sys->p_codec = p_codec;
-
-    p_enc->pf_encode_video = EncodeVideo;
-    p_enc->pf_encode_audio = EncodeAudio;
-
-    p_sys->p_buffer_out = NULL;
-    p_sys->p_buffer = NULL;
-
-    p_sys->p_context = p_context = avcodec_alloc_context();
-    p_context->debug = config_GetInt( p_enc, "ffmpeg-debug" );
-    p_context->opaque = (void *)p_this;
-
-    /* Set CPU capabilities */
-    unsigned i_cpu = vlc_CPU();
-    p_context->dsp_mask = 0;
-    if( !(i_cpu & CPU_CAPABILITY_MMX) )
-    {
-        p_context->dsp_mask |= FF_MM_MMX;
-    }
-    if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
-    {
-        p_context->dsp_mask |= FF_MM_MMXEXT;
-    }
-    if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
-    {
-        p_context->dsp_mask |= FF_MM_3DNOW;
-    }
-    if( !(i_cpu & CPU_CAPABILITY_SSE) )
-    {
-        p_context->dsp_mask |= FF_MM_SSE;
-        p_context->dsp_mask |= FF_MM_SSE2;
-    }
-
-    config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
-
-    var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
-    p_sys->i_key_int = val.i_int;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
-    p_sys->i_b_frames = val.i_int;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
-    p_sys->i_vtolerance = val.i_int * 1000;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
-    p_sys->b_interlace = val.b_bool;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "interlace-me", &val );
-    p_sys->b_interlace_me = val.b_bool;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
-    p_sys->b_pre_me = val.b_bool;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
-    p_sys->b_hurry_up = val.b_bool;
-    if( p_sys->b_hurry_up )
-    {
-        /* hurry up mode needs noise reduction, even small */
-        p_sys->i_noise_reduction = 1;
-    }
-
-    var_Get( p_enc, ENC_CFG_PREFIX "strict-rc", &val );
-    p_sys->b_strict_rc = val.b_bool;
-    var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
-    p_sys->i_rc_buffer_size = val.i_int;
-    var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
-    p_sys->f_rc_buffer_aggressivity = val.f_float;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
-    p_sys->f_i_quant_factor = val.f_float;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
-    p_sys->i_noise_reduction = val.i_int;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
-    p_sys->b_mpeg4_matrix = val.b_bool;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
-    if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
-    p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
-
-    var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
-    p_sys->i_hq = FF_MB_DECISION_RD;
-    if( val.psz_string && *val.psz_string )
-    {
-        if( !strcmp( val.psz_string, "rd" ) )
-            p_sys->i_hq = FF_MB_DECISION_RD;
-        else if( !strcmp( val.psz_string, "bits" ) )
-            p_sys->i_hq = FF_MB_DECISION_BITS;
-        else if( !strcmp( val.psz_string, "simple" ) )
-            p_sys->i_hq = FF_MB_DECISION_SIMPLE;
-        else
-            p_sys->i_hq = FF_MB_DECISION_RD;
-    }
-    else
-        p_sys->i_hq = FF_MB_DECISION_RD;
-    free( val.psz_string );
-
-    var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
-    p_sys->i_qmin = val.i_int;
-    var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
-    p_sys->i_qmax = val.i_int;
-    var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
-    p_sys->b_trellis = val.b_bool;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
-    if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
-    p_context->strict_std_compliance = val.i_int;
-
-    var_Get( p_enc, ENC_CFG_PREFIX "lumi-masking", &val );
-    p_sys->f_lumi_masking = val.f_float;
-    var_Get( p_enc, ENC_CFG_PREFIX "dark-masking", &val );
-    p_sys->f_dark_masking = val.f_float;
-    var_Get( p_enc, ENC_CFG_PREFIX "p-masking", &val );
-    p_sys->f_p_masking = val.f_float;
-    var_Get( p_enc, ENC_CFG_PREFIX "border-masking", &val );
-    p_sys->f_border_masking = val.f_float;
-    var_Get( p_enc, ENC_CFG_PREFIX "luma-elim-threshold", &val );
-    p_sys->i_luma_elim = val.i_int;
-    var_Get( p_enc, ENC_CFG_PREFIX "chroma-elim-threshold", &val );
-    p_sys->i_chroma_elim = val.i_int;
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
-    var_Get( p_enc, ENC_CFG_PREFIX "aac-profile", &val );
-    p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
-    if( val.psz_string && *val.psz_string )
-    {
-        if( !strncmp( val.psz_string, "main", 4 ) )
-            p_sys->i_aac_profile = FF_PROFILE_AAC_MAIN;
-        else if( !strncmp( val.psz_string, "low", 3 ) )
-            p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
-#if 0    /* Not supported by FAAC encoder */
-        else if( !strncmp( val.psz_string, "ssr", 3 ) )
-            p_sys->i_aac_profile = FF_PROFILE_AAC_SSR;
-#endif
-        else  if( !strncmp( val.psz_string, "ltp", 3 ) )
-            p_sys->i_aac_profile = FF_PROFILE_AAC_LTP;
-        else
-        {
-            msg_Warn( p_enc, "unknown AAC profile requested" );
-            p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
-        }
-    }
-    free( val.psz_string );
-#endif
-
-    if( p_enc->fmt_in.i_cat == VIDEO_ES )
-    {
-        int i_aspect_num, i_aspect_den;
-
-        if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
-        {
-            msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
-                      p_enc->fmt_in.video.i_height );
-            free( p_sys );
-            return VLC_EGENERIC;
-        }
-
-        p_context->width = p_enc->fmt_in.video.i_width;
-        p_context->height = p_enc->fmt_in.video.i_height;
-        if( p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v')
-             && (p_context->width > 720 || p_context->height > 576) )
-            p_context->level = 4; /* High level */
-
-        p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
-        p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
-
-        /* Defaults from ffmpeg.c */
-        p_context->qblur = 0.5;
-        p_context->qcompress = 0.5;
-        p_context->b_quant_offset = 1.25;
-        p_context->b_quant_factor = 1.25;
-        p_context->i_quant_offset = 0.0;
-        p_context->i_quant_factor = -0.8;
-
-        p_context->lumi_masking = p_sys->f_lumi_masking;
-        p_context->dark_masking = p_sys->f_dark_masking;
-        p_context->p_masking = p_sys->f_p_masking;
-        p_context->border_masking = p_sys->f_border_masking;
-        p_context->luma_elim_threshold = p_sys->i_luma_elim;
-        p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
-
-        if( p_sys->i_key_int > 0 )
-            p_context->gop_size = p_sys->i_key_int;
-        p_context->max_b_frames =
-            __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
-        p_context->b_frame_strategy = 0;
-        if( !p_context->max_b_frames  &&
-            (  p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v') ||
-               p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
-            p_context->flags |= CODEC_FLAG_LOW_DELAY;
-
-        av_reduce( &i_aspect_num, &i_aspect_den,
-                   p_enc->fmt_in.video.i_aspect,
-                   VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
-        av_reduce( &p_context->sample_aspect_ratio.num,
-                   &p_context->sample_aspect_ratio.den,
-                   i_aspect_num * (int64_t)p_context->height,
-                   i_aspect_den * (int64_t)p_context->width, 1 << 30 );
-
-        p_sys->p_buffer_out = malloc( p_context->height * p_context->width * 3 );
-
-        p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
-        p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
-        if( p_codec->pix_fmts )
-        {
-            const enum PixelFormat *p = p_codec->pix_fmts;
-            for( ; *p != -1; p++ )
-            {
-                if( *p == p_context->pix_fmt ) break;
-            }
-            if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
-            p_enc->fmt_in.i_codec = GetVlcChroma( p_context->pix_fmt );
-        }
-
-        if ( p_sys->b_strict_rc )
-        {
-            p_context->rc_qsquish = 1.0;
-            p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
-            p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
-            p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
-            /* This is from ffmpeg's ffmpeg.c : */
-            p_context->rc_initial_buffer_occupancy
-                = p_sys->i_rc_buffer_size * 3/4;
-            p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
-        }
-
-        if ( p_sys->f_i_quant_factor != 0.0 )
-            p_context->i_quant_factor = p_sys->f_i_quant_factor;
-
-        p_context->noise_reduction = p_sys->i_noise_reduction;
-
-        if ( p_sys->b_mpeg4_matrix )
-        {
-            p_context->intra_matrix = mpeg4_default_intra_matrix;
-            p_context->inter_matrix = mpeg4_default_non_intra_matrix;
-        }
-
-        if ( p_sys->b_pre_me )
-        {
-            p_context->pre_me = 1;
-            p_context->me_pre_cmp = FF_CMP_CHROMA;
-        }
-
-        if ( p_sys->b_interlace )
-        {
-            if ( p_context->height <= 280 )
-            {
-                if ( p_context->height != 16 || p_context->width != 16 )
-                    msg_Warn( p_enc,
-                        "disabling interlaced video because height=%d <= 280",
-                        p_context->height );
-            }
-            else
-            {
-                p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
-                if ( p_sys->b_interlace_me )
-                    p_context->flags |= CODEC_FLAG_INTERLACED_ME;
-            }
-        }
-
-        if ( p_sys->b_trellis )
-            p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
-
-        if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
-            p_context->flags |= CODEC_FLAG_QSCALE;
-
-        if ( p_enc->i_threads >= 1 )
-            p_context->thread_count = p_enc->i_threads;
-
-        if( p_sys->i_vtolerance > 0 )
-            p_context->bit_rate_tolerance = p_sys->i_vtolerance;
-
-        /* usually if someone sets bitrate, he likes more to get that bitrate
-         * over quality should help 'normal' user to get asked bitrate
-         */
-        if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
-        {
-            p_sys->i_qmax = 51;
-            p_sys->i_qmin = 3;
-        }
-
-        if( p_sys->i_qmin > 0 )
-        {
-            p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
-            p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
-        }
-        if( p_sys->i_qmax > 0 )
-        {
-            p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
-            p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
-        }
-        p_context->max_qdiff = 3;
-
-        p_context->mb_decision = p_sys->i_hq;
-
-        if( p_sys->i_quality )
-        {
-            p_context->flags |= CODEC_FLAG_QSCALE;
-            p_context->global_quality = p_sys->i_quality;
-        }
-    }
-    else if( p_enc->fmt_in.i_cat == AUDIO_ES )
-    {
-        /* work around bug in libmp3lame encoding */
-        if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
-            p_enc->fmt_in.audio.i_channels = 2;
-
-        p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
-        p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
-        p_context->channels    = p_enc->fmt_out.audio.i_channels;
-
-        if ( p_enc->fmt_out.i_codec == VLC_FOURCC('m','p','4','a') )
-        {
-            /* XXX: FAAC does resample only when setting the INPUT samplerate
-             * to the desired value (-R option of the faac frontend) */
-            p_enc->fmt_in.audio.i_rate = p_context->sample_rate;
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
-        /* Ignore FF_PROFILE_UNKNOWN */
-        if( p_sys->i_aac_profile >= FF_PROFILE_AAC_MAIN )
-            p_context->profile = p_sys->i_aac_profile;
-#endif
-        }
-    }
-
-    /* Misc parameters */
-    p_context->bit_rate = p_enc->fmt_out.i_bitrate;
-
-    if( i_codec_id == CODEC_ID_RAWVIDEO )
-    {
-        /* XXX: hack: Force same codec (will be handled by transcode) */
-        p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
-        p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
-    }
-
-    /* Make sure we get extradata filled by the encoder */
-    p_context->extradata_size = 0;
-    p_context->extradata = NULL;
-    p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
-
-    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
-
-    if( avcodec_open( p_context, p_codec ) )
-    {
-        vlc_mutex_unlock( lock );
-        if( p_enc->fmt_in.i_cat == AUDIO_ES &&
-             (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
-               || i_codec_id == CODEC_ID_MP3) )
-        {
-            if( p_context->channels > 2 )
-            {
-                p_context->channels = 2;
-                p_enc->fmt_in.audio.i_channels = 2; // FIXME
-                msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
-            }
-
-            if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
-            {
-                int i_frequency, i;
-
-                for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
-                {
-                    if ( p_enc->fmt_out.audio.i_rate
-                            == mpa_freq_tab[i_frequency] )
-                        break;
-                }
-                if ( i_frequency == 6 )
-                {
-                    msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
-                             p_enc->fmt_out.audio.i_rate );
-                    free( p_sys );
-                    return VLC_EGENERIC;
-                }
-
-                for ( i = 1; i < 14; i++ )
-                {
-                    if ( p_enc->fmt_out.i_bitrate / 1000
-                          <= mpa_bitrate_tab[i_frequency / 3][i] )
-                        break;
-                }
-                if ( p_enc->fmt_out.i_bitrate / 1000
-                      != mpa_bitrate_tab[i_frequency / 3][i] )
-                {
-                    msg_Warn( p_enc,
-                              "MPEG audio doesn't support bitrate=%d, using %d",
-                              p_enc->fmt_out.i_bitrate,
-                              mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
-                    p_enc->fmt_out.i_bitrate =
-                        mpa_bitrate_tab[i_frequency / 3][i] * 1000;
-                    p_context->bit_rate = p_enc->fmt_out.i_bitrate;
-                }
-            }
-
-            p_context->codec = NULL;
-            vlc_mutex_lock( lock );
-            if( avcodec_open( p_context, p_codec ) )
-            {
-                vlc_mutex_unlock( lock );
-                msg_Err( p_enc, "cannot open encoder" );
-                intf_UserFatal( p_enc, false,
-                                _("Streaming / Transcoding failed"),
-                                _("VLC could not open the encoder.") );
-                free( p_sys );
-                return VLC_EGENERIC;
-            }
-        }
-        else
-        {
-            msg_Err( p_enc, "cannot open encoder" );
-            intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
-                            _("VLC could not open the encoder.") );
-            free( p_sys );
-            return VLC_EGENERIC;
-        }
-    }
-    vlc_mutex_unlock( lock);
-
-    p_enc->fmt_out.i_extra = p_context->extradata_size;
-    if( p_enc->fmt_out.i_extra )
-    {
-        p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
-        memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
-                p_enc->fmt_out.i_extra );
-    }
-    p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
-
-    if( p_enc->fmt_in.i_cat == AUDIO_ES )
-    {
-        p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
-        p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
-        p_sys->p_buffer = malloc( p_sys->i_frame_size );
-        p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
-    }
-
-    msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
-
-    return VLC_SUCCESS;
-}
-
-/****************************************************************************
- * Ffmpeg threading system
- ****************************************************************************/
-static int FfmpegThread( struct thread_context_t *p_context )
-{
-    while ( !p_context->b_die && !p_context->b_error )
-    {
-        vlc_mutex_lock( &p_context->lock );
-        while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
-        {
-            vlc_cond_wait( &p_context->cond, &p_context->lock );
-        }
-        p_context->b_work = 0;
-        vlc_mutex_unlock( &p_context->lock );
-        if ( p_context->b_die || p_context->b_error )
-            break;
-
-        if ( p_context->pf_func )
-        {
-            p_context->i_ret = p_context->pf_func( p_context->p_context,
-                                                   p_context->arg );
-        }
-
-        vlc_mutex_lock( &p_context->lock );
-        p_context->b_done = 1;
-        vlc_cond_signal( &p_context->cond );
-        vlc_mutex_unlock( &p_context->lock );
-    }
-
-    return 0;
-}
-
-static int FfmpegExecute( AVCodecContext *s,
-                          int (*pf_func)(AVCodecContext *c2, void *arg2),
-                          void **arg, int *ret, int count )
-{
-    struct thread_context_t ** pp_contexts =
-                         (struct thread_context_t **)s->thread_opaque;
-    int i;
-
-    /* Note, we can be certain that this is not called with the same
-     * AVCodecContext by different threads at the same time */
-    for ( i = 0; i < count; i++ )
-    {
-        vlc_mutex_lock( &pp_contexts[i]->lock );
-        pp_contexts[i]->arg = arg[i];
-        pp_contexts[i]->pf_func = pf_func;
-        pp_contexts[i]->i_ret = 12345;
-        pp_contexts[i]->b_work = 1;
-        vlc_cond_signal( &pp_contexts[i]->cond );
-        vlc_mutex_unlock( &pp_contexts[i]->lock );
-    }
-    for ( i = 0; i < count; i++ )
-    {
-        vlc_mutex_lock( &pp_contexts[i]->lock );
-        while ( !pp_contexts[i]->b_done )
-        {
-            vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
-        }
-        pp_contexts[i]->b_done = 0;
-        pp_contexts[i]->pf_func = NULL;
-        vlc_mutex_unlock( &pp_contexts[i]->lock );
-
-        if ( ret )
-        {
-            ret[i] = pp_contexts[i]->i_ret;
-        }
-    }
-
-    return 0;
-}
-
-/****************************************************************************
- * EncodeVideo: the whole thing
- ****************************************************************************/
-static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
-{
-    encoder_sys_t *p_sys = p_enc->p_sys;
-    AVFrame frame;
-    int i_out, i_plane;
-
-    if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
-    {
-        struct thread_context_t ** pp_contexts;
-        int i;
-
-        p_sys->b_inited = 1;
-        pp_contexts = malloc( sizeof(struct thread_context_t *)
-                                 * p_enc->i_threads );
-        p_sys->p_context->thread_opaque = (void *)pp_contexts;
-
-        for ( i = 0; i < p_enc->i_threads; i++ )
-        {
-            pp_contexts[i] = vlc_object_create( p_enc,
-                                     sizeof(struct thread_context_t) );
-            pp_contexts[i]->p_context = p_sys->p_context;
-            vlc_mutex_init( &pp_contexts[i]->lock );
-            vlc_cond_init( p_enc, &pp_contexts[i]->cond );
-            pp_contexts[i]->b_work = 0;
-            pp_contexts[i]->b_done = 0;
-            if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
-                                    VLC_THREAD_PRIORITY_VIDEO, false ) )
-            {
-                msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
-                return NULL;
-            }
-        }
-
-        p_sys->p_context->execute = FfmpegExecute;
-    }
-
-    memset( &frame, 0, sizeof( AVFrame ) );
-    for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
-    {
-        frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
-        frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
-    }
-
-    /* Let ffmpeg select the frame type */
-    frame.pict_type = 0;
-
-    frame.repeat_pict = p_pict->i_nb_fields - 2;
-    frame.interlaced_frame = !p_pict->b_progressive;
-    frame.top_field_first = !!p_pict->b_top_field_first;
-
-    /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
-    if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
-    {
-        frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
-
-        if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
-        {
-            mtime_t current_date = mdate();
-
-            if ( current_date + HURRY_UP_GUARD3 > frame.pts )
-            {
-                p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
-                p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
-                msg_Dbg( p_enc, "hurry up mode 3" );
-            }
-            else
-            {
-                p_sys->p_context->mb_decision = p_sys->i_hq;
-
-                if ( current_date + HURRY_UP_GUARD2 > frame.pts )
-                {
-                    p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
-                    p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
-                         + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
-                    msg_Dbg( p_enc, "hurry up mode 2" );
-                }
-                else
-                {
-                    if ( p_sys->b_trellis )
-                        p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
-
-                    p_sys->p_context->noise_reduction =
-                        p_sys->i_noise_reduction;
-                }
-            }
-
-            if ( current_date + HURRY_UP_GUARD1 > frame.pts )
-            {
-                frame.pict_type = FF_P_TYPE;
-                /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
-            }
-        }
-    }
-    else
-    {
-        frame.pts = (int64_t)AV_NOPTS_VALUE;
-    }
-
-    if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
-    {
-        if ( p_sys->i_last_pts == frame.pts )
-        {
-            msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
-                      "same PTS (%"PRId64 ")", frame.pts );
-            return NULL;
-        }
-        else if ( p_sys->i_last_pts > frame.pts )
-        {
-            msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
-                      "past (current: %"PRId64 ", last: %"PRId64")",
-                      frame.pts, p_sys->i_last_pts );
-            return NULL;
-        }
-        else
-        {
-            p_sys->i_last_pts = frame.pts;
-        }
-    }
-
-    frame.quality = p_sys->i_quality;
-
-    /* Ugly work-around for stupid libavcodec behaviour */
-    p_sys->i_framenum++;
-    p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
-    frame.pts = p_sys->i_framenum * AV_TIME_BASE *
-        p_enc->fmt_in.video.i_frame_rate_base;
-    frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
-    frame.pts /= p_enc->fmt_in.video.i_frame_rate;
-    /* End work-around */
-
-    i_out = avcodec_encode_video( p_sys->p_context, (uint8_t*)p_sys->p_buffer_out,
-                                  p_sys->p_context->height * p_sys->p_context->width * 3, &frame );
-
-    if( i_out > 0 )
-    {
-        block_t *p_block = block_New( p_enc, i_out );
-        memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
-
-        /* FIXME, 3-2 pulldown is not handled correctly */
-        p_block->i_length = INT64_C(1000000) *
-            p_enc->fmt_in.video.i_frame_rate_base /
-                p_enc->fmt_in.video.i_frame_rate;
-
-        if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
-        {
-            /* No delay -> output pts == input pts */
-            p_block->i_pts = p_block->i_dts = p_pict->date;
-        }
-        else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
-            p_sys->p_context->coded_frame->pts != 0 &&
-            p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
-        {
-            p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
-            p_block->i_pts = p_sys->p_context->coded_frame->pts;
-
-            /* Ugly work-around for stupid libavcodec behaviour */
-            {
-                int64_t i_framenum = p_block->i_pts *
-                    p_enc->fmt_in.video.i_frame_rate /
-                    p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
-
-                p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
-            }
-            /* End work-around */
-
-            if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
-                p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
-            {
-                p_block->i_dts = p_block->i_pts;
-            }
-            else
-            {
-                if( p_sys->i_last_ref_pts )
-                {
-                    p_block->i_dts = p_sys->i_last_ref_pts;
-                }
-                else
-                {
-                    /* Let's put something sensible */
-                    p_block->i_dts = p_block->i_pts;
-                }
-
-                p_sys->i_last_ref_pts = p_block->i_pts;
-            }
-        }
-        else
-        {
-            /* Buggy libavcodec which doesn't update coded_frame->pts
-             * correctly */
-            p_block->i_dts = p_block->i_pts = p_pict->date;
-        }
-
-        switch ( p_sys->p_context->coded_frame->pict_type )
-        {
-        case FF_I_TYPE:
-            p_block->i_flags |= BLOCK_FLAG_TYPE_I;
-            break;
-        case FF_P_TYPE:
-            p_block->i_flags |= BLOCK_FLAG_TYPE_P;
-            break;
-        case FF_B_TYPE:
-            p_block->i_flags |= BLOCK_FLAG_TYPE_B;
-            break;
-        }
-
-        return p_block;
-    }
-
-    return NULL;
-}
-
-/****************************************************************************
- * EncodeAudio: the whole thing
- ****************************************************************************/
-static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
-{
-    encoder_sys_t *p_sys = p_enc->p_sys;
-    block_t *p_block, *p_chain = NULL;
-
-    uint8_t *p_buffer = p_aout_buf->p_buffer;
-    int i_samples = p_aout_buf->i_nb_samples;
-    int i_samples_delay = p_sys->i_samples_delay;
-
-    p_sys->i_pts = p_aout_buf->start_date -
-                (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
-                (mtime_t)p_enc->fmt_in.audio.i_rate;
-
-    p_sys->i_samples_delay += i_samples;
-
-    while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
-    {
-        int16_t *p_samples;
-        int i_out;
-
-        if( i_samples_delay )
-        {
-            /* Take care of the left-over from last time */
-            int i_delay_size = i_samples_delay * 2 *
-                                 p_sys->p_context->channels;
-            int i_size = p_sys->i_frame_size - i_delay_size;
-
-            p_samples = (int16_t *)p_sys->p_buffer;
-            memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
-            p_buffer -= i_delay_size;
-            i_samples += i_samples_delay;
-            i_samples_delay = 0;
-        }
-        else
-        {
-            p_samples = (int16_t *)p_buffer;
-        }
-
-        i_out = avcodec_encode_audio( p_sys->p_context,
-                                      (uint8_t *)p_sys->p_buffer_out,
-                                      2 * AVCODEC_MAX_AUDIO_FRAME_SIZE,
-                                      p_samples );
-
-#if 0
-        msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
-#endif
-        if( i_out < 0 ) break;
-
-        p_buffer += p_sys->i_frame_size;
-        p_sys->i_samples_delay -= p_sys->p_context->frame_size;
-        i_samples -= p_sys->p_context->frame_size;
-
-        if( i_out == 0 ) continue;
-
-        p_block = block_New( p_enc, i_out );
-        memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
-
-        p_block->i_length = (mtime_t)1000000 *
-            (mtime_t)p_sys->p_context->frame_size /
-            (mtime_t)p_sys->p_context->sample_rate;
-
-        p_block->i_dts = p_block->i_pts = p_sys->i_pts;
-
-        /* Update pts */
-        p_sys->i_pts += p_block->i_length;
-        block_ChainAppend( &p_chain, p_block );
-    }
-
-    /* Backup the remaining raw samples */
-    if( i_samples )
-    {
-        memcpy( p_sys->p_buffer + i_samples_delay * 2 *
-                p_sys->p_context->channels, p_buffer,
-                i_samples * 2 * p_sys->p_context->channels );
-    }
-
-    return p_chain;
-}
-
-/*****************************************************************************
- * CloseEncoder: ffmpeg encoder destruction
- *****************************************************************************/
-void CloseEncoder( vlc_object_t *p_this )
-{
-    encoder_t *p_enc = (encoder_t *)p_this;
-    encoder_sys_t *p_sys = p_enc->p_sys;
-
-    if ( p_sys->b_inited && p_enc->i_threads >= 1 )
-    {
-        int i;
-        struct thread_context_t ** pp_contexts =
-                (struct thread_context_t **)p_sys->p_context->thread_opaque;
-        for ( i = 0; i < p_enc->i_threads; i++ )
-        {
-            vlc_object_kill( pp_contexts[i] );
-            vlc_cond_signal( &pp_contexts[i]->cond );
-            vlc_thread_join( pp_contexts[i] );
-            vlc_mutex_destroy( &pp_contexts[i]->lock );
-            vlc_cond_destroy( &pp_contexts[i]->cond );
-            vlc_object_release( pp_contexts[i] );
-        }
-
-        free( pp_contexts );
-    }
-
-    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
-    avcodec_close( p_sys->p_context );
-    vlc_mutex_unlock( lock );
-    av_free( p_sys->p_context );
-
-    free( p_sys->p_buffer );
-    free( p_sys->p_buffer_out );
-
-    free( p_sys );
-}
diff --git a/modules/codec/ffmpeg/fourcc.h b/modules/codec/ffmpeg/fourcc.h
deleted file mode 100644 (file)
index d879480..0000000
+++ /dev/null
@@ -1,1052 +0,0 @@
-/*****************************************************************************
- * fourcc.h: libavcodec <-> libvlc conversion routines
- *****************************************************************************
- * Copyright (C) 1999-2008 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *          Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Codec fourcc -> ffmpeg_id mapping
- *****************************************************************************/
-static struct
-{
-    vlc_fourcc_t  i_fourcc;
-    int  i_codec;
-    int  i_cat;
-    const char *psz_name;
-
-} codecs_table[] =
-{
-    /*
-     * Video Codecs
-     */
-
-    /* MPEG-1 Video */
-    { VLC_FOURCC('m','p','1','v'), CODEC_ID_MPEG1VIDEO,
-      VIDEO_ES, "MPEG-1 Video" },
-    { VLC_FOURCC('m','p','e','g'), CODEC_ID_MPEG1VIDEO,
-      VIDEO_ES, "MPEG-1 Video" },
-    { VLC_FOURCC('m','p','g','1'), CODEC_ID_MPEG1VIDEO,
-      VIDEO_ES, "MPEG-1 Video" },
-    { VLC_FOURCC('P','I','M','1'), CODEC_ID_MPEG1VIDEO,
-      VIDEO_ES, "Pinnacle DC1000 (MPEG-1 Video)" },
-
-    /* MPEG-2 Video */
-    { VLC_FOURCC('m','p','2','v'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG-2 Video" },
-    { VLC_FOURCC('M','P','E','G'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG-2 Video" },
-    { VLC_FOURCC('m','p','g','v'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG-2 Video" },
-    { VLC_FOURCC('m','p','g','2'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG-2 Video" },
-    { VLC_FOURCC('h','d','v','1'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "HDV 720p30 (MPEG-2 Video)" },
-    { VLC_FOURCC('h','d','v','2'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "Sony HDV (MPEG-2 Video)" },
-    { VLC_FOURCC('h','d','v','3'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "FCP HDV (MPEG-2 Video)" },
-    { VLC_FOURCC('h','d','v','5'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "HDV 720p25 (MPEG-2 Video)" },
-    { VLC_FOURCC('m','x','5','n'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG2 IMX NTSC 525/60 50mb/s (FCP)" },
-    { VLC_FOURCC('m','x','5','p'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG2 IMX PAL 625/60 50mb/s (FCP)" },
-    { VLC_FOURCC('m','x','4','n'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG2 IMX NTSC 525/60 40mb/s (FCP)" },
-    { VLC_FOURCC('m','x','4','p'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG2 IMX PAL 625/50 40mb/s (FCP)" },
-     { VLC_FOURCC('m','x','3','n'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG2 IMX NTSC 525/60 30mb/s (FCP)" },
-    { VLC_FOURCC('m','x','3','p'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "MPEG2 IMX NTSC 625/50 30mb/s (FCP)" },
-    { VLC_FOURCC('x','d','v','2'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "XDCAM HD 1080i60" },
-    { VLC_FOURCC('A','V','m','p'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "AVID IMX PAL" },
-    /* ATI VCR2 */
-    { VLC_FOURCC('V','C','R','2'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "ATI VCR2 Video" },
-    { VLC_FOURCC('M','M','E','S'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "Matrox MPEG-2" },
-    { VLC_FOURCC('m','m','e','s'), CODEC_ID_MPEG2VIDEO,
-      VIDEO_ES, "Matrox MPEG-2" },
-
-    /* MPEG-4 Video */
-    { VLC_FOURCC('D','I','V','X'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('d','i','v','x'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('M','P','4','S'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('m','p','4','s'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('M','4','S','2'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('m','4','s','2'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    /* XVID flavours */
-    { VLC_FOURCC('x','v','i','d'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('X','V','I','D'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('X','v','i','D'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('X','V','I','X'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('x','v','i','x'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    /* DX50 */
-    { VLC_FOURCC('D','X','5','0'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('d','x','5','0'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('B','L','Z','0'), CODEC_ID_MPEG4,
-      VIDEO_ES, "Blizzard MPEG-4 Video" },
-    { VLC_FOURCC('D','X','G','M'), CODEC_ID_MPEG4,
-      VIDEO_ES, "Electronic Arts Game MPEG-4 Video" },
-    { VLC_FOURCC('m','p','4','v'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('M','P','4','V'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC( 4,  0,  0,  0 ), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('m','4','c','c'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('M','4','C','C'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('F','M','P','4'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('f','m','p','4'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    /* 3ivx delta 3.5 Unsupported
-     * putting it here gives extreme distorted images
-    { VLC_FOURCC('3','I','V','1'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('3','i','v','1'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" }, */
-    /* 3ivx delta 4 */
-    { VLC_FOURCC('3','I','V','2'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('3','i','v','2'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('U','M','P','4'), CODEC_ID_MPEG4,
-      VIDEO_ES, "UB MPEG-4 Video" },
-    { VLC_FOURCC('W','V','1','F'), CODEC_ID_MPEG4,
-      VIDEO_ES, "MPEG-4 Video" },
-    { VLC_FOURCC('S','E','D','G'), CODEC_ID_MPEG4,
-      VIDEO_ES, "Samsung MPEG-4 Video" },
-    { VLC_FOURCC('R','M','P','4'), CODEC_ID_MPEG4,
-      VIDEO_ES, "REALmagic MPEG-4 Video" },
-    { VLC_FOURCC('H','D','X','4'), CODEC_ID_MPEG4,
-      VIDEO_ES, "Jomigo HDX4 (MPEG-4 Video)" },
-    { VLC_FOURCC('h','d','x','4'), CODEC_ID_MPEG4,
-      VIDEO_ES, "Jomigo HDX4 (MPEG-4 Video)" },
-    { VLC_FOURCC('S','M','P','4'), CODEC_ID_MPEG4,
-      VIDEO_ES, "Samsung SMP4 (MPEG-4 Video)" },
-    { VLC_FOURCC('f','v','f','w'), CODEC_ID_MPEG4,
-      VIDEO_ES, "FFmpeg MPEG-4" },
-    { VLC_FOURCC('F','V','F','W'), CODEC_ID_MPEG4,
-      VIDEO_ES, "FFmpeg MPEG-4" },
-
-    /* MSMPEG4 v1 */
-    { VLC_FOURCC('D','I','V','1'), CODEC_ID_MSMPEG4V1,
-      VIDEO_ES, "MS MPEG-4 Video v1" },
-    { VLC_FOURCC('d','i','v','1'), CODEC_ID_MSMPEG4V1,
-      VIDEO_ES, "MS MPEG-4 Video v1" },
-    { VLC_FOURCC('M','P','G','4'), CODEC_ID_MSMPEG4V1,
-      VIDEO_ES, "MS MPEG-4 Video v1" },
-    { VLC_FOURCC('m','p','g','4'), CODEC_ID_MSMPEG4V1,
-      VIDEO_ES, "MS MPEG-4 Video v1" },
-
-    /* MSMPEG4 v2 */
-    { VLC_FOURCC('D','I','V','2'), CODEC_ID_MSMPEG4V2,
-      VIDEO_ES, "MS MPEG-4 Video v2" },
-    { VLC_FOURCC('d','i','v','2'), CODEC_ID_MSMPEG4V2,
-      VIDEO_ES, "MS MPEG-4 Video v2" },
-    { VLC_FOURCC('M','P','4','2'), CODEC_ID_MSMPEG4V2,
-      VIDEO_ES, "MS MPEG-4 Video v2" },
-    { VLC_FOURCC('m','p','4','2'), CODEC_ID_MSMPEG4V2,
-      VIDEO_ES, "MS MPEG-4 Video v2" },
-
-    /* MSMPEG4 v3 / M$ mpeg4 v3 */
-    { VLC_FOURCC('M','P','G','3'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('m','p','g','3'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('d','i','v','3'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('M','P','4','3'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('m','p','4','3'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    /* DivX 3.20 */
-    { VLC_FOURCC('D','I','V','3'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('D','I','V','4'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('d','i','v','4'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('D','I','V','5'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('d','i','v','5'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('D','I','V','6'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('d','i','v','6'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    /* Cool Codec */
-    { VLC_FOURCC('C','O','L','1'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('c','o','l','1'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('C','O','L','0'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('c','o','l','0'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    /* AngelPotion stuff */
-    { VLC_FOURCC('A','P','4','1'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    /* 3ivx doctered divx files */
-    { VLC_FOURCC('3','I','V','D'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('3','i','v','d'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    /* who knows? */
-    { VLC_FOURCC('3','V','I','D'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-    { VLC_FOURCC('3','v','i','d'), CODEC_ID_MSMPEG4V3,
-      VIDEO_ES, "MS MPEG-4 Video v3" },
-
-    /* Sorenson v1 */
-    { VLC_FOURCC('S','V','Q','1'), CODEC_ID_SVQ1,
-      VIDEO_ES, "SVQ-1 (Sorenson Video v1)" },
-    { VLC_FOURCC('s','v','q','1'), CODEC_ID_SVQ1,
-      VIDEO_ES, "SVQ-1 (Sorenson Video v1)" },
-    { VLC_FOURCC('s','v','q','i'), CODEC_ID_SVQ1,
-      VIDEO_ES, "SVQ-1 (Sorenson Video v1)" },
-
-    /* Sorenson v3 */
-    { VLC_FOURCC('S','V','Q','3'), CODEC_ID_SVQ3,
-      VIDEO_ES, "SVQ-3 (Sorenson Video v3)" },
-
-    /* h264 */
-    { VLC_FOURCC('h','2','6','4'), CODEC_ID_H264,
-      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
-    { VLC_FOURCC('H','2','6','4'), CODEC_ID_H264,
-      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
-    { VLC_FOURCC('x','2','6','4'), CODEC_ID_H264,
-      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
-    { VLC_FOURCC('X','2','6','4'), CODEC_ID_H264,
-      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
-    /* avc1: special case h264 */
-    { VLC_FOURCC('a','v','c','1'), CODEC_ID_H264,
-      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
-    { VLC_FOURCC('A','V','C','1'), CODEC_ID_H264,
-      VIDEO_ES, "H264 - MPEG-4 AVC (part 10)" },
-    { VLC_FOURCC('V','S','S','H'), CODEC_ID_H264,
-      VIDEO_ES, "Vanguard VSS H264" },
-    { VLC_FOURCC('V','S','S','W'), CODEC_ID_H264,
-      VIDEO_ES, "Vanguard VSS H264" },
-    { VLC_FOURCC('v','s','s','h'), CODEC_ID_H264,
-      VIDEO_ES, "Vanguard VSS H264" },
-    { VLC_FOURCC('D','A','V','C'), CODEC_ID_H264,
-      VIDEO_ES, "Dicas MPEGable H.264/MPEG-4 AVC" },
-    { VLC_FOURCC('d','a','v','c'), CODEC_ID_H264,
-      VIDEO_ES, "Dicas MPEGable H.264/MPEG-4 AVC" },
-
-/* H263 and H263i */
-/* H263(+) is also known as Real Video 1.0 */
-
-    /* H263 */
-    { VLC_FOURCC('D','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "DEC H263" },
-    { VLC_FOURCC('H','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "H263" },
-    { VLC_FOURCC('h','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "H263" },
-    { VLC_FOURCC('L','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "LEAD H263" },
-    { VLC_FOURCC('s','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "H263" },
-    { VLC_FOURCC('S','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "H263" },
-    { VLC_FOURCC('M','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "Microsoft H263" },
-    { VLC_FOURCC('X','2','6','3'), CODEC_ID_H263,
-      VIDEO_ES, "Xirlink H263" },
-
-    /* Zygo (partial) */
-    { VLC_FOURCC('Z','y','G','o'), CODEC_ID_H263,
-      VIDEO_ES, "ITU H263+" },
-
-    /* H263i */
-    { VLC_FOURCC('I','2','6','3'), CODEC_ID_H263I,
-      VIDEO_ES, "I263.I" },
-    { VLC_FOURCC('i','2','6','3'), CODEC_ID_H263I,
-      VIDEO_ES, "I263.I" },
-
-    /* H263P */
-    { VLC_FOURCC('v','i','v','1'), CODEC_ID_H263P,
-      VIDEO_ES, "H263+" },
-    { VLC_FOURCC('v','i','v','O'), CODEC_ID_H263P,
-      VIDEO_ES, "H263+" },
-    { VLC_FOURCC('v','i','v','2'), CODEC_ID_H263P,
-      VIDEO_ES, "H263+" },
-    { VLC_FOURCC('U','2','6','3'), CODEC_ID_H263P,
-      VIDEO_ES, "UB H263+" },
-    { VLC_FOURCC('I','L','V','R'), CODEC_ID_H263P,
-      VIDEO_ES, "ITU H263+" },
-
-    /* Flash (H263) variant */
-    { VLC_FOURCC('F','L','V','1'), CODEC_ID_FLV1,
-      VIDEO_ES, "Flash Video" },
-
-    /* H261 */
-    { VLC_FOURCC('H','2','6','1'), CODEC_ID_H261,
-      VIDEO_ES, "H.261" },
-    { VLC_FOURCC('h','2','6','1'), CODEC_ID_H261,
-      VIDEO_ES, "H.261" },
-
-    { VLC_FOURCC('F','L','I','C'), CODEC_ID_FLIC,
-      VIDEO_ES, "Flic Video" },
-
-    /* MJPEG */
-    { VLC_FOURCC( 'M','J','P','G' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'm','j','p','g' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'm','j','p','a' ), CODEC_ID_MJPEG, /* for mov file */
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'j','p','e','g' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'J','P','E','G' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'J','F','I','F' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'J','P','G','L' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'A','V','D','J' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG Video" },
-    { VLC_FOURCC( 'm','j','p','b' ), CODEC_ID_MJPEGB, /* for mov file */
-      VIDEO_ES, "Motion JPEG B Video" },
-    { VLC_FOURCC( 'L','J','P','G' ), CODEC_ID_LJPEG,
-      VIDEO_ES, "Lead Motion JPEG Video" },
-    { VLC_FOURCC( 'L','J','P','G' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Lead Motion JPEG Video" },
-    /* AVID MJPEG */
-    { VLC_FOURCC( 'A','V','R','n' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Avid Motion JPEG" },
-    { VLC_FOURCC( 'A','D','J','V' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Avid Motion JPEG" },
-    { VLC_FOURCC( 'd','m','b','1' ), CODEC_ID_MJPEG,
-      VIDEO_ES, "Motion JPEG OpenDML Video" },
-
-    /* SP5x */
-    { VLC_FOURCC( 'S','P','5','X' ), CODEC_ID_SP5X,
-      VIDEO_ES, "Sunplus Motion JPEG Video" },
-    { VLC_FOURCC( 'S','P','5','3' ), CODEC_ID_SP5X,
-      VIDEO_ES, "Sunplus Motion JPEG Video" },
-    { VLC_FOURCC( 'S','P','5','4' ), CODEC_ID_SP5X,
-      VIDEO_ES, "Sunplus Motion JPEG Video" },
-    { VLC_FOURCC( 'S','P','5','5' ), CODEC_ID_SP5X,
-      VIDEO_ES, "Sunplus Motion JPEG Video" },
-    { VLC_FOURCC( 'S','P','5','6' ), CODEC_ID_SP5X,
-      VIDEO_ES, "Sunplus Motion JPEG Video" },
-    { VLC_FOURCC( 'S','P','5','7' ), CODEC_ID_SP5X,
-      VIDEO_ES, "Sunplus Motion JPEG Video" },
-    { VLC_FOURCC( 'S','P','5','8' ), CODEC_ID_SP5X,
-      VIDEO_ES, "Sunplus Motion JPEG Video" },
-
-    /* DV */
-    { VLC_FOURCC('d','v','s','l'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video" },
-    { VLC_FOURCC('d','v','s','d'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video" },
-    { VLC_FOURCC('D','V','S','D'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video" },
-    { VLC_FOURCC('d','v','h','d'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video" },
-    { VLC_FOURCC('d','v','c',' '), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video" },
-    { VLC_FOURCC('d','v','c','p'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video PAL" },
-    { VLC_FOURCC('d','v','p',' '), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video Pro" },
-    { VLC_FOURCC('d','v','p','p'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video Pro PAL" },
-    { VLC_FOURCC('C','D','V','C'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video" },
-    { VLC_FOURCC('c','d','v','c'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video" },
-    { VLC_FOURCC('d','v','5','p'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video C Pro 50 PAL" },
-    { VLC_FOURCC('d','v','5','n'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "DV Video C Pro 50 NTSC" },
-    { VLC_FOURCC('A','V','d','v'), CODEC_ID_DVVIDEO,
-      VIDEO_ES, "AVID DV" },
-
-    /* Windows Media Video */
-    { VLC_FOURCC('W','M','V','1'), CODEC_ID_WMV1,
-      VIDEO_ES, "Windows Media Video 1" },
-    { VLC_FOURCC('w','m','v','1'), CODEC_ID_WMV1,
-      VIDEO_ES, "Windows Media Video 1" },
-    { VLC_FOURCC('W','M','V','2'), CODEC_ID_WMV2,
-      VIDEO_ES, "Windows Media Video 2" },
-    { VLC_FOURCC('w','m','v','2'), CODEC_ID_WMV2,
-      VIDEO_ES, "Windows Media Video 2" },
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(10<<8)+1)
-    { VLC_FOURCC('W','M','V','3'), CODEC_ID_WMV3,
-      VIDEO_ES, "Windows Media Video 3" },
-    { VLC_FOURCC('w','m','v','3'), CODEC_ID_WMV3,
-      VIDEO_ES, "Windows Media Video 3" },
-    { VLC_FOURCC('W','V','C','1'), CODEC_ID_VC1,
-      VIDEO_ES, "Windows Media Video VC1" },
-    { VLC_FOURCC('w','v','c','1'), CODEC_ID_VC1,
-      VIDEO_ES, "Windows Media Video VC1" },
-    /* WMVA is the VC-1 codec before the standardization proces,
-       it is not bitstream compatible and deprecated  */
-    { VLC_FOURCC('W','M','V','A'), CODEC_ID_VC1,
-      VIDEO_ES, "Windows Media Video Advanced Profile" },
-#endif
-
-    /* Microsoft Video 1 */
-    { VLC_FOURCC('M','S','V','C'), CODEC_ID_MSVIDEO1,
-      VIDEO_ES, "Microsoft Video 1" },
-    { VLC_FOURCC('m','s','v','c'), CODEC_ID_MSVIDEO1,
-      VIDEO_ES, "Microsoft Video 1" },
-    { VLC_FOURCC('C','R','A','M'), CODEC_ID_MSVIDEO1,
-      VIDEO_ES, "Microsoft Video 1" },
-    { VLC_FOURCC('c','r','a','m'), CODEC_ID_MSVIDEO1,
-      VIDEO_ES, "Microsoft Video 1" },
-    { VLC_FOURCC('W','H','A','M'), CODEC_ID_MSVIDEO1,
-      VIDEO_ES, "Microsoft Video 1" },
-    { VLC_FOURCC('w','h','a','m'), CODEC_ID_MSVIDEO1,
-      VIDEO_ES, "Microsoft Video 1" },
-
-    /* Microsoft RLE */
-    { VLC_FOURCC('m','r','l','e'), CODEC_ID_MSRLE,
-      VIDEO_ES, "Microsoft RLE Video" },
-    { VLC_FOURCC('W','R','L','E'), CODEC_ID_MSRLE,
-      VIDEO_ES, "Microsoft RLE Video" },
-    { VLC_FOURCC(0x1,0x0,0x0,0x0), CODEC_ID_MSRLE,
-      VIDEO_ES, "Microsoft RLE Video" },
-    { VLC_FOURCC(0x2,0x0,0x0,0x0), CODEC_ID_MSRLE,
-      VIDEO_ES, "Microsoft RLE Video" },
-
-    /* Indeo Video Codecs (Quality of this decoder on ppc is not good) */
-    { VLC_FOURCC('I','V','3','1'), CODEC_ID_INDEO3,
-      VIDEO_ES, "Indeo Video v3" },
-    { VLC_FOURCC('i','v','3','1'), CODEC_ID_INDEO3,
-      VIDEO_ES, "Indeo Video v3" },
-    { VLC_FOURCC('I','V','3','2'), CODEC_ID_INDEO3,
-      VIDEO_ES, "Indeo Video v3" },
-    { VLC_FOURCC('i','v','3','2'), CODEC_ID_INDEO3,
-      VIDEO_ES, "Indeo Video v3" },
-
-    /* Huff YUV */
-    { VLC_FOURCC('H','F','Y','U'), CODEC_ID_HUFFYUV,
-      VIDEO_ES, "Huff YUV Video" },
-    { VLC_FOURCC('F','F','V','H'), CODEC_ID_FFVHUFF,
-      VIDEO_ES, "Huff YUV Video" },
-
-    /* Creative YUV */
-    { VLC_FOURCC('C','Y','U','V'), CODEC_ID_CYUV,
-      VIDEO_ES, "Creative YUV Video" },
-    { VLC_FOURCC('c','y','u','v'), CODEC_ID_CYUV,
-      VIDEO_ES, "Creative YUV Video" },
-
-    /* On2 VP3 Video Codecs */
-    { VLC_FOURCC('V','P','3',' '), CODEC_ID_VP3,
-      VIDEO_ES, "On2's VP3 Video" },
-    { VLC_FOURCC('V','P','3','0'), CODEC_ID_VP3,
-      VIDEO_ES, "On2's VP3 Video" },
-    { VLC_FOURCC('V','P','3','1'), CODEC_ID_VP3,
-      VIDEO_ES, "On2's VP3 Video" },
-    { VLC_FOURCC('v','p','3','1'), CODEC_ID_VP3,
-      VIDEO_ES, "On2's VP3 Video" },
-
-    /* On2  VP5, VP6 codecs */
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(14<<8)+0)
-    { VLC_FOURCC('V','P','5',' '), CODEC_ID_VP5,
-      VIDEO_ES, "On2's VP5 Video" },
-    { VLC_FOURCC('V','P','5','0'), CODEC_ID_VP5,
-      VIDEO_ES, "On2's VP5 Video" },
-    { VLC_FOURCC('V','P','6','2'), CODEC_ID_VP6,
-      VIDEO_ES, "On2's VP6.2 Video" },
-    { VLC_FOURCC('v','p','6','2'), CODEC_ID_VP6,
-      VIDEO_ES, "On2's VP6.2 Video" },
-    { VLC_FOURCC('V','P','6','F'), CODEC_ID_VP6F,
-      VIDEO_ES, "On2's VP6.2 Video (Flash)" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(27<<8)+0)
-    { VLC_FOURCC('V','P','6','0'), CODEC_ID_VP6,
-      VIDEO_ES, "On2's VP6.0 Video" },
-    { VLC_FOURCC('V','P','6','1'), CODEC_ID_VP6,
-      VIDEO_ES, "On2's VP6.1 Video" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(47<<8)+0)
-    { VLC_FOURCC('V','P','6','A'), CODEC_ID_VP6A,
-      VIDEO_ES, "On2's VP6 A Video" },
-#endif
-
-    /* Xiph.org theora */
-    { VLC_FOURCC('t','h','e','o'), CODEC_ID_THEORA,
-      VIDEO_ES, "Xiph.org's Theora Video" },
-    { VLC_FOURCC('T','h','r','a'), CODEC_ID_THEORA,
-      VIDEO_ES, "Xiph.org's Theora Video" },
-
-#if ( !defined( WORDS_BIGENDIAN ) )
-    /* Asus Video (Another thing that doesn't work on PPC) */
-    { VLC_FOURCC('A','S','V','1'), CODEC_ID_ASV1,
-      VIDEO_ES, "Asus V1 Video" },
-    { VLC_FOURCC('A','S','V','2'), CODEC_ID_ASV2,
-      VIDEO_ES, "Asus V2 Video" },
-#endif
-
-    /* FFMPEG Video 1 (lossless codec) */
-    { VLC_FOURCC('F','F','V','1'), CODEC_ID_FFV1,
-      VIDEO_ES, "FFMpeg Video 1" },
-
-    /* ATI VCR1 */
-    { VLC_FOURCC('V','C','R','1'), CODEC_ID_VCR1,
-      VIDEO_ES, "ATI VCR1 Video" },
-
-    /* Cirrus Logic AccuPak */
-    { VLC_FOURCC('C','L','J','R'), CODEC_ID_CLJR,
-      VIDEO_ES, "Creative Logic AccuPak" },
-
-    /* Real Video */
-    { VLC_FOURCC('R','V','1','0'), CODEC_ID_RV10,
-      VIDEO_ES, "Real Video 10" },
-    { VLC_FOURCC('r','v','1','0'), CODEC_ID_RV10,
-      VIDEO_ES, "Real Video 10" },
-    { VLC_FOURCC('R','V','1','3'), CODEC_ID_RV10,
-      VIDEO_ES, "Real Video 13" },
-    { VLC_FOURCC('r','v','1','3'), CODEC_ID_RV10,
-      VIDEO_ES, "Real Video 13" },
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(15<<8)+1)
-    { VLC_FOURCC('R','V','2','0'), CODEC_ID_RV20,
-      VIDEO_ES, "Real Video 20" },
-    { VLC_FOURCC('r','v','2','0'), CODEC_ID_RV20,
-      VIDEO_ES, "Real Video 20" },
-#endif
-
-    /* Apple Video */
-    { VLC_FOURCC('r','p','z','a'), CODEC_ID_RPZA,
-      VIDEO_ES, "Apple Video" },
-    { VLC_FOURCC('a','z','p','r'), CODEC_ID_RPZA,
-      VIDEO_ES, "Apple Video" },
-
-    { VLC_FOURCC('s','m','c',' '), CODEC_ID_SMC,
-      VIDEO_ES, "Apple graphics" },
-
- /* CINEPAK. We have our own decoder with an higher priority,
-       but this can't harm */
-    { VLC_FOURCC('C','V','I','D'), CODEC_ID_CINEPAK,
-      VIDEO_ES, "Cinepak Video" },
-    { VLC_FOURCC('c','v','i','d'), CODEC_ID_CINEPAK,
-      VIDEO_ES, "Cinepak Video" },
-
-    /* Screen Capture Video Codecs */
-    { VLC_FOURCC('t','s','c','c'), CODEC_ID_TSCC,
-      VIDEO_ES, "TechSmith Camtasia Screen Capture Video" },
-    { VLC_FOURCC('T','S','C','C'), CODEC_ID_TSCC,
-      VIDEO_ES, "TechSmith Camtasia Screen Capture Video" },
-
-    { VLC_FOURCC('C','S','C','D'), CODEC_ID_CSCD,
-      VIDEO_ES, "CamStudio Screen Codec" },
-    { VLC_FOURCC('c','s','c','d'), CODEC_ID_CSCD,
-      VIDEO_ES, "CamStudio Screen Codec" },
-
-    { VLC_FOURCC('Z','M','B','V'), CODEC_ID_ZMBV,
-      VIDEO_ES, "DosBox Capture Codec" },
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(13<<8)+0)
-    { VLC_FOURCC('V','M','n','c'), CODEC_ID_VMNC,
-      VIDEO_ES, "VMware Video" },
-#endif
-    { VLC_FOURCC('F','P','S','1'), CODEC_ID_FRAPS,
-      VIDEO_ES, "FRAPS: Realtime Video Capture" },
-    { VLC_FOURCC('f','p','s','1'), CODEC_ID_FRAPS,
-      VIDEO_ES, "FRAPS: Realtime Video Capture" },
-
-    /* Duck TrueMotion */
-    { VLC_FOURCC('D','U','C','K'), CODEC_ID_TRUEMOTION1,
-      VIDEO_ES, "Duck TrueMotion v1 Video" },
-    { VLC_FOURCC('T','M','2','0'), CODEC_ID_TRUEMOTION2,
-      VIDEO_ES, "Duck TrueMotion v2.0 Video" },
-
-    /* FFMPEG's SNOW wavelet codec */
-    { VLC_FOURCC('S','N','O','W'), CODEC_ID_SNOW,
-      VIDEO_ES, "FFMpeg SNOW wavelet Video" },
-    { VLC_FOURCC('s','n','o','w'), CODEC_ID_SNOW,
-      VIDEO_ES, "FFMpeg SNOW wavelet Video" },
-
-    { VLC_FOURCC('r','l','e',' '), CODEC_ID_QTRLE,
-      VIDEO_ES, "Apple QuickTime RLE Video" },
-
-    { VLC_FOURCC('q','d','r','w'), CODEC_ID_QDRAW,
-      VIDEO_ES, "Apple QuickDraw Video" },
-
-    { VLC_FOURCC('Q','P','E','G'), CODEC_ID_QPEG,
-      VIDEO_ES, "QPEG Video" },
-    { VLC_FOURCC('Q','1','.','0'), CODEC_ID_QPEG,
-      VIDEO_ES, "QPEG Video" },
-    { VLC_FOURCC('Q','1','.','1'), CODEC_ID_QPEG,
-      VIDEO_ES, "QPEG Video" },
-
-    { VLC_FOURCC('U','L','T','I'), CODEC_ID_ULTI,
-      VIDEO_ES, "IBM Ultimotion Video" },
-
-    { VLC_FOURCC('V','I','X','L'), CODEC_ID_VIXL,
-      VIDEO_ES, "Miro/Pinnacle VideoXL Video" },
-    { VLC_FOURCC('P','I','X','L'), CODEC_ID_VIXL,
-      VIDEO_ES, "Pinnacle VideoXL Video" },
-
-    { VLC_FOURCC('L','O','C','O'), CODEC_ID_LOCO,
-      VIDEO_ES, "LOCO Video" },
-
-    { VLC_FOURCC('W','N','V','1'), CODEC_ID_WNV1,
-      VIDEO_ES, "Winnov WNV1 Video" },
-
-    { VLC_FOURCC('A','A','S','C'), CODEC_ID_AASC,
-      VIDEO_ES, "Autodesc RLE Video" },
-
-    { VLC_FOURCC('I','V','2','0'), CODEC_ID_INDEO2,
-      VIDEO_ES, "Indeo Video v2" },
-    { VLC_FOURCC('R','T','2','1'), CODEC_ID_INDEO2,
-      VIDEO_ES, "Indeo Video v2" },
-
-        /* Flash Screen Video */
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(11<<8)+0)
-    { VLC_FOURCC('F','S','V','1'), CODEC_ID_FLASHSV,
-              VIDEO_ES, "Flash Screen Video" },
-#endif
-   { VLC_FOURCC('K','M','V','C'), CODEC_ID_KMVC,
-      VIDEO_ES, "Karl Morton's Video Codec (Worms)" },
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(13<<8)+0)
-    { VLC_FOURCC('N','U','V','1'), CODEC_ID_NUV,
-      VIDEO_ES, "Nuppel Video" },
-    { VLC_FOURCC('R','J','P','G'), CODEC_ID_NUV,
-      VIDEO_ES, "Nuppel Video" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(8<<8)+0)
-    /* CODEC_ID_SMACKVIDEO */
-    { VLC_FOURCC('S','M','K','2'), CODEC_ID_SMACKVIDEO,
-      VIDEO_ES, "Smacker Video" },
-    { VLC_FOURCC('S','M','K','4'), CODEC_ID_SMACKVIDEO,
-      VIDEO_ES, "Smacker Video" },
-#endif
-
-    /* Chinese AVS - Untested */
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(8<<8)+0)
-    { VLC_FOURCC('C','A','V','S'), CODEC_ID_CAVS,
-      VIDEO_ES, "Chinese AVS" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+0)
-    /* Untested yet */
-    { VLC_FOURCC('A','V','d','n'), CODEC_ID_DNXHD,
-      VIDEO_ES, "DNxHD" },
-#endif
-    { VLC_FOURCC('8','B','P','S'), CODEC_ID_8BPS,
-      VIDEO_ES, "8BPS" },
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(52<<8)+0)
-    { VLC_FOURCC('M','L','2','O'), CODEC_ID_MIMIC,
-      VIDEO_ES, "Mimic" },
-#endif
-
-    /* Videogames Codecs */
-
-    /* Interplay MVE */
-    { VLC_FOURCC('i','m','v','e'), CODEC_ID_INTERPLAY_VIDEO,
-      VIDEO_ES, "Interplay MVE Video" },
-    { VLC_FOURCC('I','N','P','V'), CODEC_ID_INTERPLAY_VIDEO,
-      VIDEO_ES, "Interplay MVE Video" },
-
-    /* Id Quake II CIN */
-    { VLC_FOURCC('I','D','C','I'), CODEC_ID_IDCIN,
-      VIDEO_ES, "Id Quake II CIN Video" },
-
-    /* 4X Technologies */
-    { VLC_FOURCC('4','x','m','v'), CODEC_ID_4XM,
-      VIDEO_ES, "4X Technologies Video" },
-    { VLC_FOURCC('4','X','M','V'), CODEC_ID_4XM,
-      VIDEO_ES, "4X Technologies Video" },
-
-    /* Id RoQ */
-    { VLC_FOURCC('R','o','Q','v'), CODEC_ID_ROQ,
-      VIDEO_ES, "Id RoQ Video" },
-
-    /* Sony Playstation MDEC */
-    { VLC_FOURCC('M','D','E','C'), CODEC_ID_MDEC,
-      VIDEO_ES, "PSX MDEC Video" },
-
-    /* Sierra VMD */
-    { VLC_FOURCC('v','m','d','v'), CODEC_ID_VMDVIDEO,
-      VIDEO_ES, "Sierra VMD Video" },
-    { VLC_FOURCC('V','M','D','V'), CODEC_ID_VMDVIDEO,
-      VIDEO_ES, "Sierra VMD Video" },
-
-#if 0
-/*    UNTESTED VideoGames*/
-    { VLC_FOURCC('W','C','3','V'), CODEC_ID_XAN_WC3,
-      VIDEO_ES, "XAN wc3 Video" },
-    { VLC_FOURCC('W','C','4','V'), CODEC_ID_XAN_WC4,
-      VIDEO_ES, "XAN wc4 Video" },
-    { VLC_FOURCC('S','T','3','C'), CODEC_ID_TXD,
-      VIDEO_ES, "Renderware TeXture Dictionary" },
-    { VLC_FOURCC('V','Q','A','V'), CODEC_ID_WS_VQA,
-      VIDEO_ES, "WestWood Vector Quantized Animation" },
-    { VLC_FOURCC('T','S','E','Q'), CODEC_ID_TIERTEXSEQVIDEO,
-      VIDEO_ES, "Tiertex SEQ Video" },
-    { VLC_FOURCC('D','X','A','1'), CODEC_ID_DXA,
-      VIDEO_ES, "Feeble DXA Video" },
-    { VLC_FOURCC('D','C','I','V'), CODEC_ID_DSICINVIDEO,
-      VIDEO_ES, "Delphine CIN Video" },
-    { VLC_FOURCC('T','H','P','V'), CODEC_ID_THP,
-      VIDEO_ES, "THP Video" },
-    { VLC_FOURCC('B','E','T','H'), CODEC_ID_BETHSOFTVID,
-      VIDEO_ES, "THP Video" },
-    { VLC_FOURCC('C','9','3','V'), CODEC_ID_C93,
-      VIDEO_ES, "THP Video" },
-#endif
-
-    /*
-     *  Image codecs
-     */
-    { VLC_FOURCC('p','n','g',' '), CODEC_ID_PNG,
-      VIDEO_ES, "PNG Image" },
-    { VLC_FOURCC('p','p','m',' '), CODEC_ID_PPM,
-      VIDEO_ES, "PPM Image" },
-    { VLC_FOURCC('p','g','m',' '), CODEC_ID_PGM,
-      VIDEO_ES, "PGM Image" },
-    { VLC_FOURCC('p','g','m','y'), CODEC_ID_PGMYUV,
-      VIDEO_ES, "PGM YUV Image" },
-    { VLC_FOURCC('p','a','m',' '), CODEC_ID_PAM,
-      VIDEO_ES, "PAM Image" },
-    { VLC_FOURCC('M','J','L','S'), CODEC_ID_JPEGLS,
-      VIDEO_ES, "PAM Image" },
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(0<<8)+0)
-    { VLC_FOURCC('b','m','p',' '), CODEC_ID_BMP,
-      VIDEO_ES, "BMP Image" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+1)
-    { VLC_FOURCC('t','i','f','f'), CODEC_ID_TIFF,
-      VIDEO_ES, "TIFF Image" },
-    { VLC_FOURCC('g','i','f',' '), CODEC_ID_GIF,
-      VIDEO_ES, "GIF Image" },
-    { VLC_FOURCC('t','g','a',' '), CODEC_ID_TARGA,
-      VIDEO_ES, "Truevision Targa Image" },
-    { VLC_FOURCC('m','t','g','a'), CODEC_ID_TARGA,
-      VIDEO_ES, "Truevision Targa Image" },
-    { VLC_FOURCC('M','T','G','A'), CODEC_ID_TARGA,
-      VIDEO_ES, "Truevision Targa Image" },
-#endif
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+3)
-    { VLC_FOURCC('s','g','i',' '), CODEC_ID_SGI,
-      VIDEO_ES, "SGI Image" },
-#endif
-
-    /*
-     *  Audio Codecs
-     */
-
-    /* Windows Media Audio 1 */
-    { VLC_FOURCC('W','M','A','1'), CODEC_ID_WMAV1,
-      AUDIO_ES, "Windows Media Audio 1" },
-    { VLC_FOURCC('w','m','a','1'), CODEC_ID_WMAV1,
-      AUDIO_ES, "Windows Media Audio 1" },
-
-    /* Windows Media Audio 2 */
-    { VLC_FOURCC('W','M','A','2'), CODEC_ID_WMAV2,
-      AUDIO_ES, "Windows Media Audio 2" },
-    { VLC_FOURCC('w','m','a','2'), CODEC_ID_WMAV2,
-      AUDIO_ES, "Windows Media Audio 2" },
-
-    /* DV Audio */
-    { VLC_FOURCC('d','v','a','u'), CODEC_ID_DVAUDIO,
-      AUDIO_ES, "DV Audio" },
-
-    /* MACE-3 Audio */
-    { VLC_FOURCC('M','A','C','3'), CODEC_ID_MACE3,
-      AUDIO_ES, "MACE-3 Audio" },
-
-    /* MACE-6 Audio */
-    { VLC_FOURCC('M','A','C','6'), CODEC_ID_MACE6,
-      AUDIO_ES, "MACE-6 Audio" },
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(41<<8)+1)
-    /* MUSEPACK7 Audio */
-    { VLC_FOURCC('M','P','C',' '), CODEC_ID_MUSEPACK7,
-      AUDIO_ES, "MUSEPACK7 Audio" },
-#endif
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(48<<8)+0)
-    /* MUSEPACK8 Audio */
-    { VLC_FOURCC('M','P','C','K'), CODEC_ID_MUSEPACK8,
-      AUDIO_ES, "MUSEPACK8 Audio" },
-    { VLC_FOURCC('M','P','C','8'), CODEC_ID_MUSEPACK8,
-      AUDIO_ES, "MUSEPACK8 Audio" },
-#endif
-
-    /* RealAudio 1.0 */
-    { VLC_FOURCC('1','4','_','4'), CODEC_ID_RA_144,
-      AUDIO_ES, "RealAudio 1.0" },
-    { VLC_FOURCC('l','p','c','J'), CODEC_ID_RA_144,
-      AUDIO_ES, "RealAudio 1.0" },
-
-    /* RealAudio 2.0 */
-    { VLC_FOURCC('2','8','_','8'), CODEC_ID_RA_288,
-      AUDIO_ES, "RealAudio 2.0" },
-
-    /* MPEG Audio layer 1/2/3 */
-    { VLC_FOURCC('m','p','g','a'), CODEC_ID_MP2,
-      AUDIO_ES, "MPEG Audio layer 1/2" },
-    { VLC_FOURCC('m','p','3',' '), CODEC_ID_MP3,
-      AUDIO_ES, "MPEG Audio layer 1/2/3" },
-    { VLC_FOURCC('.','m','p','3'), CODEC_ID_MP3,
-      AUDIO_ES, "MPEG Audio layer 1/2/3" },
-    { VLC_FOURCC('M','P','3',' '), CODEC_ID_MP3,
-      AUDIO_ES, "MPEG Audio layer 1/2/3" },
-    { VLC_FOURCC('L','A','M','E'), CODEC_ID_MP3,
-      AUDIO_ES, "MPEG Audio layer 1/2/3" },
-
-    /* A52 Audio (aka AC3) */
-    { VLC_FOURCC('a','5','2',' '), CODEC_ID_AC3,
-      AUDIO_ES, "A52 Audio (aka AC3)" },
-    { VLC_FOURCC('a','5','2','b'), CODEC_ID_AC3, /* VLC specific hack */
-      AUDIO_ES, "A52 Audio (aka AC3)" },
-
-    /* DTS Audio */
-    { VLC_FOURCC('d','t','s',' '), CODEC_ID_DTS,
-      AUDIO_ES, "DTS Audio" },
-
-    /* AAC audio */
-    { VLC_FOURCC('m','p','4','a'), CODEC_ID_AAC,
-      AUDIO_ES, "MPEG AAC Audio" },
-
-    /* AC-3 Audio (Dolby Digital) */
-    { VLC_FOURCC('a','c','-','3'), CODEC_ID_AC3,
-      AUDIO_ES, "AC-3 Audio (Dolby Digital)" },
-
-    /* 4X Technologies */
-    { VLC_FOURCC('4','x','m','a'), CODEC_ID_ADPCM_4XM,
-      AUDIO_ES, "4X Technologies Audio" },
-
-    /* EA ADPCM */
-    { VLC_FOURCC('A','D','E','A'), CODEC_ID_ADPCM_EA,
-      AUDIO_ES, "EA ADPCM Audio" },
-
-    /* Interplay DPCM */
-    { VLC_FOURCC('i','d','p','c'), CODEC_ID_INTERPLAY_DPCM,
-      AUDIO_ES, "Interplay DPCM Audio" },
-
-    /* Id RoQ */
-    { VLC_FOURCC('R','o','Q','a'), CODEC_ID_ROQ_DPCM,
-      AUDIO_ES, "Id RoQ DPCM Audio" },
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(27<<8)+0)
-    /* DCIN Audio */
-    { VLC_FOURCC('D','C','I','A'), CODEC_ID_DSICINAUDIO,
-      AUDIO_ES, "Delphine CIN Audio" },
-#endif
-
-    /* Sony Playstation XA ADPCM */
-    { VLC_FOURCC('x','a',' ',' '), CODEC_ID_ADPCM_XA,
-      AUDIO_ES, "PSX XA ADPCM Audio" },
-
-    /* ADX ADPCM */
-    { VLC_FOURCC('a','d','x',' '), CODEC_ID_ADPCM_ADX,
-      AUDIO_ES, "ADX ADPCM Audio" },
-
-    /* Westwood ADPCM */
-    { VLC_FOURCC('A','I','W','S'), CODEC_ID_ADPCM_IMA_WS,
-      AUDIO_ES, "Westwood IMA ADPCM audio" },
-
-    /* Sierra VMD */
-    { VLC_FOURCC('v','m','d','a'), CODEC_ID_VMDAUDIO,
-      AUDIO_ES, "Sierra VMD Audio" },
-
-    /* G.726 ADPCM */
-    { VLC_FOURCC('g','7','2','6'), CODEC_ID_ADPCM_G726,
-      AUDIO_ES, "G.726 ADPCM Audio" },
-
-    /* AMR */
-    { VLC_FOURCC('s','a','m','r'), CODEC_ID_AMR_NB,
-      AUDIO_ES, "AMR narrow band" },
-    { VLC_FOURCC('s','a','w','b'), CODEC_ID_AMR_WB,
-      AUDIO_ES, "AMR wide band" },
-
-    /* FLAC */
-    { VLC_FOURCC('f','l','a','c'), CODEC_ID_FLAC,
-      AUDIO_ES, "FLAC (Free Lossless Audio Codec)" },
-
-    /* ALAC */
-    { VLC_FOURCC('a','l','a','c'), CODEC_ID_ALAC,
-      AUDIO_ES, "Apple Lossless Audio Codec" },
-
-#if LIBAVCODEC_VERSION_INT >= ((50<<16)+(0<<8)+1)
-    /* QDM2 */
-    { VLC_FOURCC('Q','D','M','2'), CODEC_ID_QDM2,
-      AUDIO_ES, "QDM2 Audio" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(0<<8)+0)
-    /* COOK */
-    { VLC_FOURCC('c','o','o','k'), CODEC_ID_COOK,
-      AUDIO_ES, "Cook Audio" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(4<<8)+0)
-    /* TTA: The Lossless True Audio */
-    { VLC_FOURCC('T','T','A','1'), CODEC_ID_TTA,
-      AUDIO_ES, "The Lossless True Audio" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(8<<8)+0)
-    /* Shorten */
-    { VLC_FOURCC('s','h','n',' '), CODEC_ID_SHORTEN,
-      AUDIO_ES, "Shorten Lossless Audio" },
-    { VLC_FOURCC('s','h','r','n'), CODEC_ID_SHORTEN,
-      AUDIO_ES, "Shorten Lossless Audio" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(16<<8)+0)
-    { VLC_FOURCC('w','v','p','k'), CODEC_ID_WAVPACK,
-      AUDIO_ES, "WavPack" },
-    { VLC_FOURCC('W','V','P','K'), CODEC_ID_WAVPACK,
-      AUDIO_ES, "WavPack" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(34<<8)+0)
-    { VLC_FOURCC('g','s','m',' '), CODEC_ID_GSM,
-      AUDIO_ES, "GSM Audio" },
-    { VLC_FOURCC('g','s','m','s'), CODEC_ID_GSM_MS,
-      AUDIO_ES, "Microsoft GSM Audio" },
-#endif
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
-    { VLC_FOURCC('a','t','r','c'), CODEC_ID_ATRAC3,
-      AUDIO_ES, "atrac 3" },
-    { VLC_FOURCC(0x70,0x2,0x0,0x0), CODEC_ID_ATRAC3,
-      AUDIO_ES, "atrac 3" },
-#endif
-
-    { VLC_FOURCC('S','O','N','C'), CODEC_ID_SONIC,
-      AUDIO_ES, "Sonic" },
-
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(34<<8)+0)
-    { VLC_FOURCC(0x1,0x4,0x0,0x0), CODEC_ID_IMC,
-      AUDIO_ES, "IMC" },
-#endif
-    { VLC_FOURCC(0x22,0x0,0x0,0x0), CODEC_ID_TRUESPEECH,
-      AUDIO_ES, "TrueSpeech" },
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(46<<8)+0)
-    { VLC_FOURCC('N','E','L','L'), CODEC_ID_NELLYMOSER,
-      AUDIO_ES, "NellyMoser ASAO" },
-#endif
-#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(44<<8)+0)
-    { VLC_FOURCC('A','P','E',' '), CODEC_ID_APE,
-      AUDIO_ES, "Monkey's Audio" },
-#endif
-    /* PCM */
-    { VLC_FOURCC('s','8',' ',' '), CODEC_ID_PCM_S8,
-      AUDIO_ES, "PCM S8" },
-    { VLC_FOURCC('u','8',' ',' '), CODEC_ID_PCM_U8,
-      AUDIO_ES, "PCM U8" },
-    { VLC_FOURCC('s','1','6','l'), CODEC_ID_PCM_S16LE,
-      AUDIO_ES, "PCM S16 LE" },
-    { VLC_FOURCC('s','1','6','b'), CODEC_ID_PCM_S16BE,
-      AUDIO_ES, "PCM S16 BE" },
-    { VLC_FOURCC('u','1','6','l'), CODEC_ID_PCM_U16LE,
-      AUDIO_ES, "PCM U16 LE" },
-    { VLC_FOURCC('u','1','6','b'), CODEC_ID_PCM_U16BE,
-      AUDIO_ES, "PCM U16 BE" },
-    { VLC_FOURCC('s','2','4','l'), CODEC_ID_PCM_S24LE,
-      AUDIO_ES, "PCM S24 LE" },
-    { VLC_FOURCC('s','2','4','b'), CODEC_ID_PCM_S24BE,
-      AUDIO_ES, "PCM S24 BE" },
-    { VLC_FOURCC('u','2','4','l'), CODEC_ID_PCM_U24LE,
-      AUDIO_ES, "PCM U24 LE" },
-    { VLC_FOURCC('u','2','4','b'), CODEC_ID_PCM_U24BE,
-      AUDIO_ES, "PCM U24 BE" },
-    { VLC_FOURCC('s','3','2','l'), CODEC_ID_PCM_S32LE,
-      AUDIO_ES, "PCM S32 LE" },
-    { VLC_FOURCC('s','3','2','b'), CODEC_ID_PCM_S32BE,
-      AUDIO_ES, "PCM S32 BE" },
-    { VLC_FOURCC('u','3','2','l'), CODEC_ID_PCM_U32LE,
-      AUDIO_ES, "PCM U32 LE" },
-    { VLC_FOURCC('u','3','2','b'), CODEC_ID_PCM_U32BE,
-      AUDIO_ES, "PCM U32 BE" },
-    { VLC_FOURCC('a','l','a','w'), CODEC_ID_PCM_ALAW,
-      AUDIO_ES, "PCM ALAW" },
-    { VLC_FOURCC('u','l','a','w'), CODEC_ID_PCM_MULAW,
-      AUDIO_ES, "PCM ULAW" },
-    { VLC_FOURCC('d','a','u','d'), CODEC_ID_PCM_S24DAUD,
-      AUDIO_ES, "PCM ULAW" },
-
-    { 0, 0, 0, 0 }
-};
-
-static int GetFfmpegCodec( vlc_fourcc_t i_fourcc, int *pi_cat,
-                           int *pi_ffmpeg_codec, const char **ppsz_name )
-{
-    int i;
-
-    for( i = 0; codecs_table[i].i_fourcc != 0; i++ )
-    {
-        if( codecs_table[i].i_fourcc == i_fourcc )
-        {
-            if( pi_cat ) *pi_cat = codecs_table[i].i_cat;
-            if( pi_ffmpeg_codec ) *pi_ffmpeg_codec = codecs_table[i].i_codec;
-            if( ppsz_name ) *ppsz_name = (char *)codecs_table[i].psz_name;
-
-            return true;
-        }
-    }
-    return false;
-}
-
-static int GetVlcFourcc( int i_ffmpeg_codec, int *pi_cat,
-                         vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
-{
-    int i;
-
-    for( i = 0; codecs_table[i].i_codec != 0; i++ )
-    {
-        if( codecs_table[i].i_codec == i_ffmpeg_codec )
-        {
-            if( pi_cat ) *pi_cat = codecs_table[i].i_cat;
-            if( pi_fourcc ) *pi_fourcc = codecs_table[i].i_fourcc;
-            if( ppsz_name ) *ppsz_name = codecs_table[i].psz_name;
-
-            return true;
-        }
-    }
-    return false;
-}
diff --git a/modules/codec/ffmpeg/video.c b/modules/codec/ffmpeg/video.c
deleted file mode 100644 (file)
index 12391a0..0000000
+++ /dev/null
@@ -1,1000 +0,0 @@
-/*****************************************************************************
- * video.c: video decoder using the ffmpeg library
- *****************************************************************************
- * Copyright (C) 1999-2001 the VideoLAN team
- * $Id$
- *
- * Authors: Laurent Aimar <fenrir@via.ecp.fr>
- *          Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble
- *****************************************************************************/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <vlc_common.h>
-#include <vlc_codec.h>
-#include <vlc_vout.h>
-#include <vlc_input.h>                  /* hmmm, just for INPUT_RATE_DEFAULT */
-#include <vlc_codecs.h>                               /* BITMAPINFOHEADER */
-
-/* ffmpeg header */
-#ifdef HAVE_LIBAVCODEC_AVCODEC_H
-#   include <libavcodec/avcodec.h>
-#elif defined(HAVE_FFMPEG_AVCODEC_H)
-#   include <ffmpeg/avcodec.h>
-#else
-#   include <avcodec.h>
-#endif
-
-#include "avcodec.h"
-
-/*****************************************************************************
- * decoder_sys_t : decoder descriptor
- *****************************************************************************/
-struct decoder_sys_t
-{
-    FFMPEG_COMMON_MEMBERS
-
-    /* Video decoder specific part */
-    mtime_t input_pts;
-    mtime_t input_dts;
-    mtime_t i_pts;
-
-    AVFrame          *p_ff_pic;
-    BITMAPINFOHEADER *p_format;
-
-    /* for frame skipping algo */
-    int b_hurry_up;
-    enum AVDiscard i_skip_frame;
-    enum AVDiscard i_skip_idct;
-
-    /* how many decoded frames are late */
-    int     i_late_frames;
-    mtime_t i_late_frames_start;
-
-    /* for direct rendering */
-    int b_direct_rendering;
-
-    bool b_has_b_frames;
-
-    /* Hack to force display of still pictures */
-    bool b_first_frame;
-
-    int i_buffer_orig, i_buffer;
-    char *p_buffer_orig, *p_buffer;
-
-    /* Postprocessing handle */
-    void *p_pp;
-    bool b_pp;
-    bool b_pp_async;
-    bool b_pp_init;
-};
-
-/* FIXME (dummy palette for now) */
-static AVPaletteControl palette_control;
-
-/*****************************************************************************
- * Local prototypes
- *****************************************************************************/
-static void ffmpeg_InitCodec      ( decoder_t * );
-static void ffmpeg_CopyPicture    ( decoder_t *, picture_t *, AVFrame * );
-static int  ffmpeg_GetFrameBuf    ( struct AVCodecContext *, AVFrame * );
-static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *, AVFrame * );
-
-static uint32_t ffmpeg_CodecTag( vlc_fourcc_t fcc )
-{
-    uint8_t *p = (uint8_t*)&fcc;
-    return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
-}
-
-/*****************************************************************************
- * Local Functions
- *****************************************************************************/
-static uint32_t ffmpeg_PixFmtToChroma( int i_ff_chroma )
-{
-    switch( i_ff_chroma )
-    {
-    case PIX_FMT_YUV420P:
-    case PIX_FMT_YUVJ420P: /* Hacky but better then chroma conversion */
-        return VLC_FOURCC('I','4','2','0');
-    case PIX_FMT_YUV422P:
-    case PIX_FMT_YUVJ422P: /* Hacky but better then chroma conversion */
-        return VLC_FOURCC('I','4','2','2');
-    case PIX_FMT_YUV444P:
-    case PIX_FMT_YUVJ444P: /* Hacky but better then chroma conversion */
-        return VLC_FOURCC('I','4','4','4');
-
-    case PIX_FMT_YUV422:
-        return VLC_FOURCC('Y','U','Y','2');
-
-#if defined(WORDS_BIGENDIAN)
-    case PIX_FMT_BGR8:
-        return VLC_FOURCC('R','G','B','8');
-    case PIX_FMT_BGR555:
-        return VLC_FOURCC('R','V','1','5');
-    case PIX_FMT_BGR565:
-        return VLC_FOURCC('R','V','1','6');
-    case PIX_FMT_BGR24:
-        return VLC_FOURCC('R','V','2','4');
-#else
-#if defined(PIX_FMT_RGB8)
-    case PIX_FMT_RGB8:
-        return VLC_FOURCC('R','G','B','8');
-#endif
-    case PIX_FMT_RGB555:
-        return VLC_FOURCC('R','V','1','5');
-    case PIX_FMT_RGB565:
-        return VLC_FOURCC('R','V','1','6');
-    case PIX_FMT_RGB24:
-        return VLC_FOURCC('R','V','2','4');
-#endif
-    case PIX_FMT_RGBA32:
-        return VLC_FOURCC('R','V','3','2');
-#ifdef PIX_FMT_RGBA
-    case PIX_FMT_RGBA:
-        return VLC_FOURCC('R','G','B','A');
-#endif
-    case PIX_FMT_GRAY8:
-        return VLC_FOURCC('G','R','E','Y');
-
-    case PIX_FMT_YUV410P:
-    case PIX_FMT_YUV411P:
-    default:
-        return 0;
-    }
-}
-
-/* Returns a new picture buffer */
-static inline picture_t *ffmpeg_NewPictBuf( decoder_t *p_dec,
-                                            AVCodecContext *p_context )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-    picture_t *p_pic;
-
-    p_dec->fmt_out.video.i_width = p_context->width;
-    p_dec->fmt_out.video.i_height = p_context->height;
-    p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt );
-
-    if( !p_context->width || !p_context->height )
-    {
-        return NULL; /* invalid display size */
-    }
-
-    if( !p_dec->fmt_out.i_codec )
-    {
-        /* we make conversion if possible*/
-        p_dec->fmt_out.i_codec = VLC_FOURCC('I','4','2','0');
-    }
-
-    /* If an aspect-ratio was specified in the input format then force it */
-    if( p_dec->fmt_in.video.i_aspect )
-    {
-        p_dec->fmt_out.video.i_aspect = p_dec->fmt_in.video.i_aspect;
-    }
-    else
-    {
-        p_dec->fmt_out.video.i_aspect =
-            VOUT_ASPECT_FACTOR * ( av_q2d(p_context->sample_aspect_ratio) *
-                p_context->width / p_context->height );
-        p_dec->fmt_out.video.i_sar_num = p_context->sample_aspect_ratio.num;
-        p_dec->fmt_out.video.i_sar_den = p_context->sample_aspect_ratio.den;
-
-        if( p_dec->fmt_out.video.i_aspect == 0 )
-        {
-            p_dec->fmt_out.video.i_aspect =
-                VOUT_ASPECT_FACTOR * p_context->width / p_context->height;
-        }
-    }
-
-    if( p_dec->fmt_out.video.i_frame_rate > 0 &&
-        p_dec->fmt_out.video.i_frame_rate_base > 0 )
-    {
-        p_dec->fmt_out.video.i_frame_rate =
-            p_dec->fmt_in.video.i_frame_rate;
-        p_dec->fmt_out.video.i_frame_rate_base =
-            p_dec->fmt_in.video.i_frame_rate_base;
-    }
-    else if( p_context->time_base.num > 0 && p_context->time_base.den > 0 )
-    {
-        p_dec->fmt_out.video.i_frame_rate = p_context->time_base.den;
-        p_dec->fmt_out.video.i_frame_rate_base = p_context->time_base.num;
-    }
-
-    p_pic = p_dec->pf_vout_buffer_new( p_dec );
-
-// FIXME    if( p_sys->p_pp && p_sys->b_pp && !p_sys->b_pp_init )
-// FIXME    {
-// FIXME        InitPostproc( p_sys->p_pp, p_context->width,
-// FIXME                          p_context->height, p_context->pix_fmt );
-// FIXME        p_sys->b_pp_init = true;
-// FIXME    }
-
-    return p_pic;
-}
-
-/*****************************************************************************
- * InitVideo: initialize the video decoder
- *****************************************************************************
- * the ffmpeg codec will be opened, some memory allocated. The vout is not yet
- * opened (done after the first decoded frame).
- *****************************************************************************/
-int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,
-                      AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
-{
-    decoder_sys_t *p_sys;
-    vlc_value_t val;
-
-    /* Allocate the memory needed to store the decoder's structure */
-    if( ( p_dec->p_sys = p_sys =
-          (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
-    {
-        msg_Err( p_dec, "out of memory" );
-        return VLC_ENOMEM;
-    }
-    memset( p_sys, 0, sizeof(decoder_sys_t) );
-
-    p_dec->p_sys->p_context = p_context;
-    p_dec->p_sys->p_codec = p_codec;
-    p_dec->p_sys->i_codec_id = i_codec_id;
-    p_dec->p_sys->psz_namecodec = psz_namecodec;
-    p_sys->p_ff_pic = avcodec_alloc_frame();
-
-    /* ***** Fill p_context with init values ***** */
-    p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_codec );
-    p_sys->p_context->width  = p_dec->fmt_in.video.i_width;
-    p_sys->p_context->height = p_dec->fmt_in.video.i_height;
-    p_sys->p_context->bits_per_sample = p_dec->fmt_in.video.i_bits_per_pixel;
-
-    /*  ***** Get configuration of ffmpeg plugin ***** */
-    p_sys->p_context->workaround_bugs =
-        config_GetInt( p_dec, "ffmpeg-workaround-bugs" );
-    p_sys->p_context->error_resilience =
-        config_GetInt( p_dec, "ffmpeg-error-resilience" );
-
-    var_Create( p_dec, "grayscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "grayscale", &val );
-    if( val.b_bool ) p_sys->p_context->flags |= CODEC_FLAG_GRAY;
-
-    var_Create( p_dec, "ffmpeg-vismv", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "ffmpeg-vismv", &val );
-    if( val.i_int ) p_sys->p_context->debug_mv = val.i_int;
-
-    var_Create( p_dec, "ffmpeg-lowres", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "ffmpeg-lowres", &val );
-    if( val.i_int > 0 && val.i_int <= 2 ) p_sys->p_context->lowres = val.i_int;
-
-    var_Create( p_dec, "ffmpeg-skiploopfilter",
-                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "ffmpeg-skiploopfilter", &val );
-    if( val.i_int > 0 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONREF;
-    if( val.i_int > 1 ) p_sys->p_context->skip_loop_filter = AVDISCARD_BIDIR;
-    if( val.i_int > 2 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONKEY;
-    if( val.i_int > 3 ) p_sys->p_context->skip_loop_filter = AVDISCARD_ALL;
-
-    /* ***** ffmpeg frame skipping ***** */
-    var_Create( p_dec, "ffmpeg-hurry-up", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "ffmpeg-hurry-up", &val );
-    p_sys->b_hurry_up = val.b_bool;
-
-    var_Create( p_dec, "ffmpeg-skip-frame", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "ffmpeg-skip-frame", &val );
-    switch( val.i_int )
-    {
-        case -1:
-            p_sys->p_context->skip_frame = AVDISCARD_NONE;
-            break;
-        case 0:
-            p_sys->p_context->skip_frame = AVDISCARD_DEFAULT;
-            break;
-        case 1:
-            p_sys->p_context->skip_frame = AVDISCARD_BIDIR;
-            break;
-        case 2:
-            p_sys->p_context->skip_frame = AVDISCARD_NONKEY;
-            break;
-        case 3:
-            p_sys->p_context->skip_frame = AVDISCARD_ALL;
-            break;
-        default:
-            p_sys->p_context->skip_frame = AVDISCARD_NONE;
-            break;
-    }
-    p_sys->i_skip_frame = p_sys->p_context->skip_frame;
-
-    var_Create( p_dec, "ffmpeg-skip-idct",  VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "ffmpeg-skip-idct", &val );
-    switch( val.i_int )
-    {
-        case -1:
-            p_sys->p_context->skip_idct = AVDISCARD_NONE;
-            break;
-        case 0:
-            p_sys->p_context->skip_idct = AVDISCARD_DEFAULT;
-            break;
-        case 1:
-            p_sys->p_context->skip_idct = AVDISCARD_BIDIR;
-            break;
-        case 2:
-            p_sys->p_context->skip_idct = AVDISCARD_NONKEY;
-            break;
-        case 3:
-            p_sys->p_context->skip_idct = AVDISCARD_ALL;
-            break;
-        default:
-            p_sys->p_context->skip_idct = AVDISCARD_NONE;
-            break;
-    }
-    p_sys->i_skip_idct = p_sys->p_context->skip_idct;
-
-    /* ***** ffmpeg direct rendering ***** */
-    p_sys->b_direct_rendering = 0;
-    var_Create( p_dec, "ffmpeg-dr", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
-    var_Get( p_dec, "ffmpeg-dr", &val );
-    if( val.b_bool && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) &&
-        /* Apparently direct rendering doesn't work with YUV422P */
-        p_sys->p_context->pix_fmt != PIX_FMT_YUV422P &&
-        /* H264 uses too many reference frames */
-        p_sys->i_codec_id != CODEC_ID_H264 &&
-        !p_sys->p_context->debug_mv )
-    {
-        /* Some codecs set pix_fmt only after the 1st frame has been decoded,
-         * so we need to do another check in ffmpeg_GetFrameBuf() */
-        p_sys->b_direct_rendering = 1;
-    }
-
-    p_sys->p_pp = NULL;
-    p_sys->b_pp = p_sys->b_pp_async = p_sys->b_pp_init = false;
-    // FIXME p_sys->p_pp = OpenPostproc( p_dec, &p_sys->b_pp_async );
-
-    /* ffmpeg doesn't properly release old pictures when frames are skipped */
-    //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = 0;
-    if( p_sys->b_direct_rendering )
-    {
-        msg_Dbg( p_dec, "using direct rendering" );
-        p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE;
-    }
-
-    /* Always use our get_buffer wrapper so we can calculate the
-     * PTS correctly */
-    p_sys->p_context->get_buffer = ffmpeg_GetFrameBuf;
-    p_sys->p_context->release_buffer = ffmpeg_ReleaseFrameBuf;
-    p_sys->p_context->opaque = p_dec;
-
-    /* ***** init this codec with special data ***** */
-    ffmpeg_InitCodec( p_dec );
-
-    /* ***** misc init ***** */
-    p_sys->input_pts = p_sys->input_dts = 0;
-    p_sys->i_pts = 0;
-    p_sys->b_has_b_frames = false;
-    p_sys->b_first_frame = true;
-    p_sys->i_late_frames = 0;
-    p_sys->i_buffer = 0;
-    p_sys->i_buffer_orig = 1;
-    p_sys->p_buffer_orig = p_sys->p_buffer = malloc( p_sys->i_buffer_orig );
-
-    /* Set output properties */
-    p_dec->fmt_out.i_cat = VIDEO_ES;
-    p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt );
-
-    /* Setup palette */
-    if( p_dec->fmt_in.video.p_palette )
-        p_sys->p_context->palctrl =
-            (AVPaletteControl *)p_dec->fmt_in.video.p_palette;
-    else
-        p_sys->p_context->palctrl = &palette_control;
-
-    /* ***** Open the codec ***** */
-    vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
-    if( lock == NULL )
-    {
-        free( p_sys );
-        return VLC_ENOMEM;
-    }
-
-    if( avcodec_open( p_sys->p_context, p_sys->p_codec ) < 0 )
-    {
-        vlc_mutex_unlock( lock );
-        msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
-        free( p_sys );
-        return VLC_EGENERIC;
-    }
-    vlc_mutex_unlock( lock );
-    msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
-
-
-    return VLC_SUCCESS;
-}
-
-/*****************************************************************************
- * DecodeVideo: Called to decode one or more frames
- *****************************************************************************/
-picture_t *DecodeVideo( decoder_t *p_dec, block_t **pp_block )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-    int b_drawpicture;
-    int b_null_size = false;
-    block_t *p_block;
-
-    if( !pp_block || !*pp_block ) return NULL;
-
-    if( !p_sys->p_context->extradata_size && p_dec->fmt_in.i_extra )
-        ffmpeg_InitCodec( p_dec );
-
-    p_block = *pp_block;
-
-    if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
-    {
-        p_sys->i_buffer = 0;
-        p_sys->i_pts = 0; /* To make sure we recover properly */
-
-        p_sys->input_pts = p_sys->input_dts = 0;
-        p_sys->i_late_frames = 0;
-
-        block_Release( p_block );
-
-        //if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
-            //avcodec_flush_buffers( p_sys->p_context );
-        return NULL;
-    }
-
-    if( p_block->i_flags & BLOCK_FLAG_PREROLL )
-    {
-        /* Do not care about late frames when prerolling
-         * TODO avoid decoding of non reference frame
-         * (ie all B except for H264 where it depends only on nal_ref_idc) */
-        p_sys->i_late_frames = 0;
-    }
-
-    if( !p_dec->b_pace_control && (p_sys->i_late_frames > 0) &&
-        (mdate() - p_sys->i_late_frames_start > INT64_C(5000000)) )
-    {
-        if( p_sys->i_pts )
-        {
-            msg_Err( p_dec, "more than 5 seconds of late video -> "
-                     "dropping frame (computer too slow ?)" );
-            p_sys->i_pts = 0; /* To make sure we recover properly */
-        }
-        block_Release( p_block );
-        p_sys->i_late_frames--;
-        return NULL;
-    }
-
-    if( p_block->i_pts > 0 || p_block->i_dts > 0 )
-    {
-        p_sys->input_pts = p_block->i_pts;
-        p_sys->input_dts = p_block->i_dts;
-
-        /* Make sure we don't reuse the same timestamps twice */
-        p_block->i_pts = p_block->i_dts = 0;
-    }
-
-    /* A good idea could be to decode all I pictures and see for the other */
-    if( !p_dec->b_pace_control &&
-        p_sys->b_hurry_up &&
-        (p_sys->i_late_frames > 4) )
-    {
-        b_drawpicture = 0;
-        if( p_sys->i_late_frames < 8 )
-        {
-            p_sys->p_context->skip_frame =
-                    (p_sys->i_skip_frame <= AVDISCARD_BIDIR) ?
-                    AVDISCARD_BIDIR : p_sys->i_skip_frame;
-        }
-        else
-        {
-            /* picture too late, won't decode
-             * but break picture until a new I, and for mpeg4 ...*/
-            p_sys->i_late_frames--; /* needed else it will never be decrease */
-            block_Release( p_block );
-            p_sys->i_buffer = 0;
-            return NULL;
-        }
-    }
-    else
-    {
-        if( p_sys->b_hurry_up )
-            p_sys->p_context->skip_frame = p_sys->i_skip_frame;
-        if( !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
-            b_drawpicture = 1;
-        else
-            b_drawpicture = 0;
-    }
-
-    if( p_sys->p_context->width <= 0 || p_sys->p_context->height <= 0 )
-    {
-        if( p_sys->b_hurry_up )
-            p_sys->p_context->skip_frame = p_sys->i_skip_frame;
-        b_null_size = true;
-    }
-
-    /*
-     * Do the actual decoding now
-     */
-
-    /* Check if post-processing was enabled */
-    p_sys->b_pp = p_sys->b_pp_async;
-
-    /* Don't forget that ffmpeg requires a little more bytes
-     * that the real frame size */
-    if( p_block->i_buffer > 0 )
-    {
-        p_sys->i_buffer = p_block->i_buffer;
-        if( p_sys->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE >
-            p_sys->i_buffer_orig )
-        {
-            free( p_sys->p_buffer_orig );
-            p_sys->i_buffer_orig =
-                p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE;
-            p_sys->p_buffer_orig = malloc( p_sys->i_buffer_orig );
-        }
-        p_sys->p_buffer = p_sys->p_buffer_orig;
-        p_sys->i_buffer = p_block->i_buffer;
-        vlc_memcpy( p_sys->p_buffer, p_block->p_buffer, p_block->i_buffer );
-        memset( p_sys->p_buffer + p_block->i_buffer, 0,
-                FF_INPUT_BUFFER_PADDING_SIZE );
-
-        p_block->i_buffer = 0;
-    }
-
-    while( p_sys->i_buffer > 0 )
-    {
-        int i_used, b_gotpicture;
-        picture_t *p_pic;
-
-        i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
-                                       &b_gotpicture,
-                                       (uint8_t*)p_sys->p_buffer, p_sys->i_buffer );
-        if( b_null_size && p_sys->p_context->width > 0 &&
-            p_sys->p_context->height > 0 )
-        {
-            /* Reparse it to not drop the I frame */
-            b_null_size = false;
-            if( p_sys->b_hurry_up )
-                p_sys->p_context->skip_frame = p_sys->i_skip_frame;
-            i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
-                                           &b_gotpicture,
-                                           (uint8_t*)p_sys->p_buffer, p_sys->i_buffer );
-        }
-
-        if( i_used < 0 )
-        {
-            msg_Warn( p_dec, "cannot decode one frame (%d bytes)",
-                      p_sys->i_buffer );
-            block_Release( p_block );
-            return NULL;
-        }
-        else if( i_used > p_sys->i_buffer )
-        {
-            i_used = p_sys->i_buffer;
-        }
-
-        /* Consumed bytes */
-        p_sys->i_buffer -= i_used;
-        p_sys->p_buffer += i_used;
-
-        /* Nothing to display */
-        if( !b_gotpicture )
-        {
-            if( i_used == 0 ) break;
-            continue;
-        }
-
-        /* Update frame late count (except when doing preroll) */
-        if( p_sys->i_pts && decoder_GetDisplayDate(p_dec, p_sys->i_pts) <= mdate() &&
-            !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
-        {
-            p_sys->i_late_frames++;
-            if( p_sys->i_late_frames == 1 )
-                p_sys->i_late_frames_start = mdate();
-        }
-        else
-        {
-            p_sys->i_late_frames = 0;
-        }
-
-        if( !b_drawpicture || !p_sys->p_ff_pic->linesize[0] )
-        {
-            /* Do not display the picture */
-            p_pic = (picture_t *)p_sys->p_ff_pic->opaque;
-            if( !b_drawpicture && p_pic )
-                p_dec->pf_vout_buffer_del( p_dec, p_pic );
-            continue;
-        }
-
-        if( !p_sys->p_ff_pic->opaque )
-        {
-            /* Get a new picture */
-            p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
-            if( !p_pic )
-            {
-                block_Release( p_block );
-                return NULL;
-            }
-
-            /* Fill p_picture_t from AVVideoFrame and do chroma conversion
-             * if needed */
-            ffmpeg_CopyPicture( p_dec, p_pic, p_sys->p_ff_pic );
-        }
-        else
-        {
-            p_pic = (picture_t *)p_sys->p_ff_pic->opaque;
-        }
-
-        /* Set the PTS */
-        if( p_sys->p_ff_pic->pts ) p_sys->i_pts = p_sys->p_ff_pic->pts;
-
-        /* Sanity check (seems to be needed for some streams) */
-        if( p_sys->p_ff_pic->pict_type == FF_B_TYPE )
-        {
-            p_sys->b_has_b_frames = true;
-        }
-
-        if( !p_dec->fmt_in.video.i_aspect )
-        {
-            /* Fetch again the aspect ratio in case it changed */
-            p_dec->fmt_out.video.i_aspect =
-                VOUT_ASPECT_FACTOR
-                    * ( av_q2d(p_sys->p_context->sample_aspect_ratio)
-                    * p_sys->p_context->width / p_sys->p_context->height );
-            p_dec->fmt_out.video.i_sar_num
-                = p_sys->p_context->sample_aspect_ratio.num;
-            p_dec->fmt_out.video.i_sar_den
-                = p_sys->p_context->sample_aspect_ratio.den;
-
-            if( p_dec->fmt_out.video.i_aspect == 0 )
-            {
-                p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR
-                    * p_sys->p_context->width / p_sys->p_context->height;
-            }
-        }
-
-        /* Send decoded frame to vout */
-        if( p_sys->i_pts )
-        {
-            p_pic->date = p_sys->i_pts;
-
-            /* interpolate the next PTS */
-            if( p_dec->fmt_in.video.i_frame_rate > 0 &&
-                p_dec->fmt_in.video.i_frame_rate_base > 0 )
-            {
-                p_sys->i_pts += INT64_C(1000000) *
-                    (2 + p_sys->p_ff_pic->repeat_pict) *
-                    p_dec->fmt_in.video.i_frame_rate_base *
-                    p_block->i_rate / INPUT_RATE_DEFAULT /
-                    (2 * p_dec->fmt_in.video.i_frame_rate);
-            }
-            else if( p_sys->p_context->time_base.den > 0 )
-            {
-                p_sys->i_pts += INT64_C(1000000) *
-                    (2 + p_sys->p_ff_pic->repeat_pict) *
-                    p_sys->p_context->time_base.num *
-                    p_block->i_rate / INPUT_RATE_DEFAULT /
-                    (2 * p_sys->p_context->time_base.den);
-            }
-
-            if( p_sys->b_first_frame )
-            {
-                /* Hack to force display of still pictures */
-                p_sys->b_first_frame = false;
-                p_pic->b_force = true;
-            }
-
-            p_pic->i_nb_fields = 2 + p_sys->p_ff_pic->repeat_pict;
-            p_pic->b_progressive = !p_sys->p_ff_pic->interlaced_frame;
-            p_pic->b_top_field_first = p_sys->p_ff_pic->top_field_first;
-
-            return p_pic;
-        }
-        else
-        {
-            p_dec->pf_vout_buffer_del( p_dec, p_pic );
-        }
-    }
-
-    block_Release( p_block );
-    return NULL;
-}
-
-/*****************************************************************************
- * EndVideo: decoder destruction
- *****************************************************************************
- * This function is called when the thread ends after a successful
- * initialization.
- *****************************************************************************/
-void EndVideoDec( decoder_t *p_dec )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-
-    if( p_sys->p_ff_pic ) av_free( p_sys->p_ff_pic );
-    // FIXME ClosePostproc( p_dec, p_sys->p_pp );
-    free( p_sys->p_buffer_orig );
-}
-
-/*****************************************************************************
- * ffmpeg_InitCodec: setup codec extra initialization data for ffmpeg
- *****************************************************************************/
-static void ffmpeg_InitCodec( decoder_t *p_dec )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-    int i_size = p_dec->fmt_in.i_extra;
-
-    if( !i_size ) return;
-
-    if( p_sys->i_codec_id == CODEC_ID_SVQ3 )
-    {
-        uint8_t *p;
-
-        p_sys->p_context->extradata_size = i_size + 12;
-        p = p_sys->p_context->extradata  =
-            malloc( p_sys->p_context->extradata_size );
-
-        memcpy( &p[0],  "SVQ3", 4 );
-        memset( &p[4], 0, 8 );
-        memcpy( &p[12], p_dec->fmt_in.p_extra, i_size );
-
-        /* Now remove all atoms before the SMI one */
-        if( p_sys->p_context->extradata_size > 0x5a &&
-            strncmp( (char*)&p[0x56], "SMI ", 4 ) )
-        {
-            uint8_t *psz = &p[0x52];
-
-            while( psz < &p[p_sys->p_context->extradata_size - 8] )
-            {
-                int i_size = GetDWBE( psz );
-                if( i_size <= 1 )
-                {
-                    /* FIXME handle 1 as long size */
-                    break;
-                }
-                if( !strncmp( (char*)&psz[4], "SMI ", 4 ) )
-                {
-                    memmove( &p[0x52], psz,
-                             &p[p_sys->p_context->extradata_size] - psz );
-                    break;
-                }
-
-                psz += i_size;
-            }
-        }
-    }
-    else if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '0' ) ||
-             p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '3' ) ||
-             p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '2', '0' ) )
-    {
-        if( p_dec->fmt_in.i_extra == 8 )
-        {
-            p_sys->p_context->extradata_size = 8;
-            p_sys->p_context->extradata = malloc( 8 );
-
-            memcpy( p_sys->p_context->extradata,
-                    p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
-            p_sys->p_context->sub_id= ((uint32_t*)p_dec->fmt_in.p_extra)[1];
-
-            msg_Warn( p_dec, "using extra data for RV codec sub_id=%08x",
-                      p_sys->p_context->sub_id );
-        }
-    }
-    else
-    {
-        p_sys->p_context->extradata_size = i_size;
-        p_sys->p_context->extradata =
-            malloc( i_size + FF_INPUT_BUFFER_PADDING_SIZE );
-        memcpy( p_sys->p_context->extradata,
-                p_dec->fmt_in.p_extra, i_size );
-        memset( &((uint8_t*)p_sys->p_context->extradata)[i_size],
-                0, FF_INPUT_BUFFER_PADDING_SIZE );
-    }
-}
-
-/*****************************************************************************
- * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a
- *                     picture_t structure (when not in direct rendering mode).
- *****************************************************************************/
-static void ffmpeg_CopyPicture( decoder_t *p_dec,
-                                picture_t *p_pic, AVFrame *p_ff_pic )
-{
-    decoder_sys_t *p_sys = p_dec->p_sys;
-
-    if( ffmpeg_PixFmtToChroma( p_sys->p_context->pix_fmt ) )
-    {
-        int i_plane, i_size, i_line;
-        uint8_t *p_dst, *p_src;
-        int i_src_stride, i_dst_stride;
-
-        // FIXME if( p_sys->p_pp && p_sys->b_pp )
-        // FIXME    PostprocPict( p_sys->p_pp, p_pic, p_ff_pic );
-        // FIXME else
-        {
-            for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
-            {
-                p_src  = p_ff_pic->data[i_plane];
-                p_dst = p_pic->p[i_plane].p_pixels;
-                i_src_stride = p_ff_pic->linesize[i_plane];
-                i_dst_stride = p_pic->p[i_plane].i_pitch;
-
-                i_size = __MIN( i_src_stride, i_dst_stride );
-                for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines;
-                     i_line++ )
-                {
-                    vlc_memcpy( p_dst, p_src, i_size );
-                    p_src += i_src_stride;
-                    p_dst += i_dst_stride;
-                }
-            }
-        }
-    }
-    else
-    {
-        AVPicture dest_pic;
-        int i;
-
-        /* we need to convert to I420 */
-        switch( p_sys->p_context->pix_fmt )
-        {
-        case PIX_FMT_YUV410P:
-        case PIX_FMT_YUV411P:
-        case PIX_FMT_RGB32:
-        case PIX_FMT_RGB24:
-#if defined(PIX_FMT_RGB8)
-        case PIX_FMT_RGB8:
-#endif
-#if defined(PIX_FMT_BRG32)
-        case PIX_FMT_BGR32:
-#endif
-        case PIX_FMT_BGR24:
-#if defined(PIX_FMT_BGR8)
-        case PIX_FMT_BGR8:
-#endif
-        case PIX_FMT_PAL8:
-            for( i = 0; i < p_pic->i_planes; i++ )
-            {
-                dest_pic.data[i] = p_pic->p[i].p_pixels;
-                dest_pic.linesize[i] = p_pic->p[i].i_pitch;
-            }
-#if !defined(HAVE_LIBSWSCALE_SWSCALE_H)  && !defined(HAVE_FFMPEG_SWSCALE_H)
-            img_convert( &dest_pic, PIX_FMT_YUV420P,
-                         (AVPicture *)p_ff_pic,
-                         p_sys->p_context->pix_fmt,
-                         p_sys->p_context->width,
-                         p_sys->p_context->height );
-#endif
-            break;
-        default:
-            msg_Err( p_dec, "don't know how to convert chroma %i",
-                     p_sys->p_context->pix_fmt );
-            p_dec->b_error = 1;
-            break;
-        }
-    }
-}
-
-/*****************************************************************************
- * ffmpeg_GetFrameBuf: callback used by ffmpeg to get a frame buffer.
- *****************************************************************************
- * It is used for direct rendering as well as to get the right PTS for each
- * decoded picture (even in indirect rendering mode).
- *****************************************************************************/
-static int ffmpeg_GetFrameBuf( struct AVCodecContext *p_context,
-                               AVFrame *p_ff_pic )
-{
-    decoder_t *p_dec = (decoder_t *)p_context->opaque;
-    decoder_sys_t *p_sys = p_dec->p_sys;
-    picture_t *p_pic;
-
-    /* Set picture PTS */
-    if( p_sys->input_pts )
-    {
-        p_ff_pic->pts = p_sys->input_pts;
-    }
-    else if( p_sys->input_dts )
-    {
-        /* Some demuxers only set the dts so let's try to find a useful
-         * timestamp from this */
-        if( !p_context->has_b_frames || !p_sys->b_has_b_frames ||
-            !p_ff_pic->reference || !p_sys->i_pts )
-        {
-            p_ff_pic->pts = p_sys->input_dts;
-        }
-        else p_ff_pic->pts = 0;
-    }
-    else p_ff_pic->pts = 0;
-
-    if( p_sys->i_pts ) /* make sure 1st frame has a pts > 0 */
-    {
-        p_sys->input_pts = p_sys->input_dts = 0;
-    }
-
-    p_ff_pic->opaque = 0;
-
-    /* Not much to do in indirect rendering mode */
-    if( !p_sys->b_direct_rendering || p_sys->b_pp )
-    {
-        return avcodec_default_get_buffer( p_context, p_ff_pic );
-    }
-
-    /* Some codecs set pix_fmt only after the 1st frame has been decoded,
-     * so this check is necessary. */
-    if( !ffmpeg_PixFmtToChroma( p_context->pix_fmt ) ||
-        p_sys->p_context->width % 16 || p_sys->p_context->height % 16 )
-    {
-        msg_Dbg( p_dec, "disabling direct rendering" );
-        p_sys->b_direct_rendering = 0;
-        return avcodec_default_get_buffer( p_context, p_ff_pic );
-    }
-
-    /* Get a new picture */
-    //p_sys->p_vout->render.b_allow_modify_pics = 0;
-    p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
-    if( !p_pic )
-    {
-        p_sys->b_direct_rendering = 0;
-        return avcodec_default_get_buffer( p_context, p_ff_pic );
-    }
-    p_sys->p_context->draw_horiz_band = NULL;
-
-    p_ff_pic->opaque = (void*)p_pic;
-    p_ff_pic->type = FF_BUFFER_TYPE_USER;
-    p_ff_pic->data[0] = p_pic->p[0].p_pixels;
-    p_ff_pic->data[1] = p_pic->p[1].p_pixels;
-    p_ff_pic->data[2] = p_pic->p[2].p_pixels;
-    p_ff_pic->data[3] = NULL; /* alpha channel but I'm not sure */
-
-    p_ff_pic->linesize[0] = p_pic->p[0].i_pitch;
-    p_ff_pic->linesize[1] = p_pic->p[1].i_pitch;
-    p_ff_pic->linesize[2] = p_pic->p[2].i_pitch;
-    p_ff_pic->linesize[3] = 0;
-
-    if( p_ff_pic->reference != 0 )
-    {
-        p_dec->pf_picture_link( p_dec, p_pic );
-    }
-
-    /* FIXME what is that, should give good value */
-    p_ff_pic->age = 256*256*256*64; // FIXME FIXME from ffmpeg
-
-    return 0;
-}
-
-static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *p_context,
-                                    AVFrame *p_ff_pic )
-{
-    decoder_t *p_dec = (decoder_t *)p_context->opaque;
-    picture_t *p_pic;
-
-    if( !p_ff_pic->opaque )
-    {
-        avcodec_default_release_buffer( p_context, p_ff_pic );
-        return;
-    }
-
-    p_pic = (picture_t*)p_ff_pic->opaque;
-
-    p_ff_pic->data[0] = NULL;
-    p_ff_pic->data[1] = NULL;
-    p_ff_pic->data[2] = NULL;
-    p_ff_pic->data[3] = NULL;
-
-    if( p_ff_pic->reference != 0 )
-    {
-        p_dec->pf_picture_unlink( p_dec, p_pic );
-    }
-}
index 85711d0..d60e2d8 100644 (file)
@@ -42,8 +42,8 @@
 #   include <ffmpeg/avformat.h>
 #endif
 
-#include "../../codec/ffmpeg/fourcc.h"
-#include "../../codec/ffmpeg/chroma.h"
+#include "../../codec/avcodec/fourcc.h"
+#include "../../codec/avcodec/chroma.h"
 
 //#define AVFORMAT_DEBUG 1
 
index f3fc73b..14b19ce 100644 (file)
@@ -41,8 +41,8 @@
 #endif
 
 #include "avformat.h"
-#include "../../codec/ffmpeg/fourcc.h"
-#include "../../codec/ffmpeg/avutil.h"
+#include "../../codec/avcodec/fourcc.h"
+#include "../../codec/avcodec/avutil.h"
 
 //#define AVFORMAT_DEBUG 1
 
index 688debc..cbca27e 100644 (file)
@@ -43,7 +43,7 @@
 #   include <avcodec.h>
 #endif
 
-#include "../codec/ffmpeg/chroma.h"
+#include "../codec/avcodec/chroma.h"
 
 /*****************************************************************************
  * Local prototypes
index 65bf561..24d6034 100644 (file)
@@ -41,7 +41,7 @@
 #endif
 
 /* Gruikkkkkkkkkk!!!!! */
-#include "../codec/ffmpeg/chroma.h"
+#include "../codec/avcodec/chroma.h"
 
 /****************************************************************************
  * Local prototypes