[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[652] mplayerxp

[<nic...@us...>]

Revision: 652
          http://sourceforge.net/p/mplayerxp/code/652
Author:   nickols_k
Date:     2013-06-11 17:36:43 +0000 (Tue, 11 Jun 2013)
Log Message:
-----------
convert decaudio(video)_priv_t -> class A(V)D_Interface

Modified Paths:
--------------
    mplayerxp/libmpcodecs/ad.cpp
    mplayerxp/libmpcodecs/ad.h
    mplayerxp/libmpcodecs/ad_a52.cpp
    mplayerxp/libmpcodecs/ad_dca.cpp
    mplayerxp/libmpcodecs/ad_dvdpcm.cpp
    mplayerxp/libmpcodecs/ad_faad.cpp
    mplayerxp/libmpcodecs/ad_lavc.cpp
    mplayerxp/libmpcodecs/ad_libdv.cpp
    mplayerxp/libmpcodecs/ad_mp3.cpp
    mplayerxp/libmpcodecs/ad_null.cpp
    mplayerxp/libmpcodecs/ad_pcm.cpp
    mplayerxp/libmpcodecs/ad_real.cpp
    mplayerxp/libmpcodecs/ad_vorbis.cpp
    mplayerxp/libmpcodecs/dec_audio.cpp
    mplayerxp/libmpcodecs/dec_audio.h
    mplayerxp/libmpcodecs/dec_video.cpp
    mplayerxp/libmpcodecs/dec_video.h
    mplayerxp/libmpcodecs/vd.cpp
    mplayerxp/libmpcodecs/vd.h
    mplayerxp/libmpcodecs/vd_divx4.cpp
    mplayerxp/libmpcodecs/vd_huffyuv.cpp
    mplayerxp/libmpcodecs/vd_lavc.cpp
    mplayerxp/libmpcodecs/vd_libdv.cpp
    mplayerxp/libmpcodecs/vd_libmpeg2.cpp
    mplayerxp/libmpcodecs/vd_mpegpes.cpp
    mplayerxp/libmpcodecs/vd_null.cpp
    mplayerxp/libmpcodecs/vd_nuv.cpp
    mplayerxp/libmpcodecs/vd_raw.cpp
    mplayerxp/libmpcodecs/vd_real.cpp
    mplayerxp/libmpcodecs/vd_theora.cpp
    mplayerxp/libmpcodecs/vd_xanim.cpp
    mplayerxp/libmpcodecs/vd_xvid.cpp
    mplayerxp/main.cpp
    mplayerxp/mplayerxp.h
    mplayerxp/osdep/mplib.cpp
    mplayerxp/osdep/mplib.h
    mplayerxp/xmpcore/xmp_adecoder.cpp
    mplayerxp/xmpcore/xmp_aplayer.cpp
    mplayerxp/xmpcore/xmp_image.cpp
    mplayerxp/xmpcore/xmp_image.h
    mplayerxp/xmpcore/xmp_vdecoder.cpp

Removed Paths:
-------------
    mplayerxp/libmpcodecs/ad_internal.h
    mplayerxp/libmpcodecs/vd_internal.h

Modified: mplayerxp/libmpcodecs/ad.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -12,6 +12,7 @@
 #include "libmpstream2/stream.h"
 #include "libmpdemux/demuxer.h"
 #include "libmpdemux/stheader.h"
+#include "dec_audio.h"
 #include "ad.h"
 #include "ad_msg.h"
 
@@ -64,7 +65,7 @@
     }
 }
 
-const ad_info_t* afm_find_driver(const std::string& name) {
+const ad_info_t* AD_Interface::find_driver(const std::string& name) const {
     unsigned i;
     for (i=0; mpcodecs_ad_drivers[i] != &ad_null_info; i++) {
 	if(name==mpcodecs_ad_drivers[i]->driver_name)
@@ -73,7 +74,7 @@
     return NULL;
 }
 
-Audio_Decoder* afm_probe_driver(sh_audio_t& sh,audio_filter_info_t& afi) {
+Audio_Decoder* AD_Interface::probe_driver(sh_audio_t& sh,audio_filter_info_t& afi) const {
     unsigned i;
     Audio_Decoder* drv=NULL;
     for (i=0; mpcodecs_ad_drivers[i] != &ad_null_info; i++) {
@@ -108,7 +109,7 @@
     return drv;
 }
 
-void afm_help() {
+void AD_Interface::print_help() {
     unsigned i;
     mpxp_info<<"Available audio codec families/drivers:"<<std::endl;
     for (i=0; mpcodecs_ad_drivers[i] != &ad_null_info; i++) {

Modified: mplayerxp/libmpcodecs/ad.h
===================================================================
--- mplayerxp/libmpcodecs/ad.h	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad.h	2013-06-11 17:36:43 UTC (rev 652)
@@ -58,8 +58,6 @@
 	const mpxp_option_t*	options;
     };
 
-    const ad_info_t*	afm_find_driver(const std::string& name);
-    Audio_Decoder*	afm_probe_driver(sh_audio_t& sh,audio_filter_info_t& afi);
     inline float	FIX_APTS(sh_audio_t& sh_audio,float& pts,unsigned in_size) { return sh_audio.i_bps?(pts+float(in_size))/float(sh_audio.i_bps):pts; }
 } //namespace	usr
 

Modified: mplayerxp/libmpcodecs/ad_a52.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_a52.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_a52.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -3,11 +3,11 @@
 using namespace	usr;
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 #define __USE_XOPEN 1
 #include <unistd.h>
 #include <assert.h>
 #include <dlfcn.h> /* GLIBC specific. Exists under cygwin too! */
-#include "ad_internal.h"
 #include "liba52/a52.h"
 #include "codecs_ld.h"
 
@@ -16,6 +16,10 @@
 #include "osdep/cpudetect.h"
 #include "osdep/bswap.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 #include "osdep/mm_accel.h"
 #include "mplayerxp.h"
 #include "libao3/afmt.h"

Modified: mplayerxp/libmpcodecs/ad_dca.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_dca.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_dca.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -7,7 +7,6 @@
 #include <unistd.h>
 #include <assert.h>
 #include <dlfcn.h> /* GLIBC specific. Exists under cygwin too! */
-#include "ad_internal.h"
 #include "codecs_ld.h"
 
 #include "mplayerxp.h"
@@ -22,6 +21,10 @@
 #include "libao3/audio_out.h"
 #include "postproc/af.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     class dca_decoder : public Audio_Decoder {
 	public:

Modified: mplayerxp/libmpcodecs/ad_dvdpcm.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_dvdpcm.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_dvdpcm.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -4,10 +4,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include "ad_internal.h"
 #include "osdep/bswap.h"
 #include "libao3/afmt.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
 
     class dvdpcm_decoder : public Audio_Decoder {

Modified: mplayerxp/libmpcodecs/ad_faad.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_faad.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_faad.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -14,7 +14,6 @@
 #include "mpxp_help.h"
 #include "osdep/bswap.h"
 #include "codecs_ld.h"
-#include "ad_internal.h"
 #include "mplayerxp.h"
 #include "osdep/cpudetect.h"
 #include "osdep/mm_accel.h"
@@ -22,6 +21,10 @@
 #include "libao3/audio_out.h"
 #include "postproc/af.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     typedef any_t* NeAACDecHandle;
     typedef struct NeAACDecConfiguration {

Deleted: mplayerxp/libmpcodecs/ad_internal.h
===================================================================
--- mplayerxp/libmpcodecs/ad_internal.h	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_internal.h	2013-06-11 17:36:43 UTC (rev 652)
@@ -1,12 +0,0 @@
-#ifdef __AD_ACM /* simply ugly hack */
-#include "win32loader/wine/msacm.h"
-#endif
-#include "libmpconf/codec-cfg.h"
-#include "libmpdemux/demuxer_r.h"
-
-#include "ad.h"
-
-#include "ad_msg.h"
-
-namespace	usr {
-} // namespace	usr
\ No newline at end of file

Modified: mplayerxp/libmpcodecs/ad_lavc.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_lavc.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_lavc.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -9,7 +9,6 @@
 #include <assert.h>
 #include <dlfcn.h> /* GLIBC specific. Exists under cygwin too! */
 #include "libao3/afmt.h"
-#include "ad_internal.h"
 
 #include "mpxp_help.h"
 #include "osdep/bswap.h"
@@ -18,6 +17,10 @@
 #include "mpxp_conf_lavc.h"
 #include "codecs_ld.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     class alavc_decoder: public Audio_Decoder {
 	public:

Modified: mplayerxp/libmpcodecs/ad_libdv.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_libdv.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_libdv.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -18,8 +18,11 @@
 #include "libmpdemux/stheader.h"
 #include "libao3/afmt.h"
 #include "osdep/bswap.h"
-#include "ad_internal.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     class libadv_decoder : public Audio_Decoder {
 	public:

Modified: mplayerxp/libmpcodecs/ad_mp3.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_mp3.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_mp3.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -5,7 +5,6 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <dlfcn.h> /* GLIBC specific. Exists under cygwin too! */
-#include "ad_internal.h"
 #include "mplayerxp.h"
 #include "osdep/cpudetect.h"
 #include "osdep/mm_accel.h"
@@ -16,6 +15,10 @@
 #include "libao3/audio_out.h"
 #include "postproc/af.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
 /** Opaque structure for the libmpg123 decoder handle. */
     struct mpg123_handle_struct;

Modified: mplayerxp/libmpcodecs/ad_null.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_null.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_null.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -4,8 +4,11 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include "ad_internal.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     class anull_decoder : public Audio_Decoder {
 	public:

Modified: mplayerxp/libmpcodecs/ad_pcm.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_pcm.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_pcm.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -4,10 +4,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include "ad_internal.h"
 #include "libao3/afmt.h"
 #include "osdep/bswap.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     class pcm_decoder : public Audio_Decoder {
 	public:

Modified: mplayerxp/libmpcodecs/ad_real.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_real.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_real.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -9,12 +9,16 @@
 #include <stddef.h>
 #include <dlfcn.h>
 
-#include "ad_internal.h"
 #include "codecs_ld.h"
 #include "ad_msg.h"
 #include "osdep/bswap.h"
 #include "libao3/afmt.h"
 
+#include "libmpconf/codec-cfg.h"
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     struct ra_init_t {
 	int samplerate;

Modified: mplayerxp/libmpcodecs/ad_vorbis.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_vorbis.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/ad_vorbis.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -11,11 +11,14 @@
 
 #include "osdep/bswap.h"
 #include "codecs_ld.h"
-#include "ad_internal.h"
 #include "libao3/afmt.h"
 #include "libao3/audio_out.h"
 #include "postproc/af.h"
 
+#include "libmpdemux/demuxer_r.h"
+#include "ad.h"
+#include "ad_msg.h"
+
 namespace	usr {
     // This struct is also defined in demux_ogg.c => common header ?
     class vorbis_decoder : public Audio_Decoder {

Modified: mplayerxp/libmpcodecs/dec_audio.cpp
===================================================================
--- mplayerxp/libmpcodecs/dec_audio.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/dec_audio.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -32,159 +32,150 @@
 
 struct decaudio_priv_t : public Opaque {
     public:
-	decaudio_priv_t();
+	decaudio_priv_t(sh_audio_t& sh);
 	virtual ~decaudio_priv_t();
 
-	sh_audio_t* parent;
+	sh_audio_t& parent;
 	Audio_Decoder* mpadec;
-	audio_filter_info_t* afi;
+	audio_filter_info_t& afi;
 };
 
-decaudio_priv_t::decaudio_priv_t()
-		:afi(new(zeromem) audio_filter_info_t)
+decaudio_priv_t::decaudio_priv_t(sh_audio_t& sh)
+		:parent(sh)
+		,afi(*new(zeromem) audio_filter_info_t)
 {
 }
 
-decaudio_priv_t::~decaudio_priv_t() { delete afi; }
+decaudio_priv_t::~decaudio_priv_t() { delete &afi; }
 
-audio_decoder_t* mpca_init(sh_audio_t *sh_audio)
+AD_Interface::AD_Interface(sh_audio_t& sh)
+	    :ad_private(*new(zeromem) decaudio_priv_t(sh))
 {
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
     const char *afm=NULL,*ac=NULL;
-    audio_decoder_t* handle=new(zeromem) audio_decoder_t;
-    decaudio_priv_t* priv = new(zeromem) decaudio_priv_t;
-    priv->parent=sh_audio;
-    handle->ad_private=priv;
 
     if(mp_conf.audio_family) afm=mp_conf.audio_family;
 
     if(afm) {
-	const ad_info_t* ai=afm_find_driver(afm);
+	const ad_info_t* ai=find_driver(afm);
 	try{
 	    /* Set up some common usefull defaults. ad->preinit() can override these: */
 #ifdef WORDS_BIGENDIAN
-	    sh_audio->afmt=AFMT_S16_BE;
+	    sh.afmt=AFMT_S16_BE;
 #else
-	    sh_audio->afmt=AFMT_S16_LE;
+	    sh.afmt=AFMT_S16_LE;
 #endif
-	    sh_audio->rate=0;
-	    sh_audio->o_bps=0;
-	    priv->mpadec=ai->query_interface(*sh_audio,*priv->afi,sh_audio->wtag);
+	    sh.rate=0;
+	    sh.o_bps=0;
+	    priv.mpadec=ai->query_interface(sh,priv.afi,sh.wtag);
 	} catch(const bad_format_exception&) {
 	    MSG_ERR(MSGTR_CODEC_BAD_AFAMILY,ac, afm);
 	    goto bye;
 	}
     }
-    else priv->mpadec = afm_probe_driver(*sh_audio,*priv->afi);
-    if(!priv->mpadec) {
+    else priv.mpadec = probe_driver(sh,priv.afi);
+    if(!priv.mpadec) {
 bye:
-	delete handle;
-	delete priv->mpadec;
-	delete priv;
-	return NULL;
+	delete priv.mpadec;
+	delete &priv;
+	throw missing_driver_exception();
     }
 
-    audio_probe_t aprobe=priv->mpadec->get_probe_information();
+    audio_probe_t aprobe=priv.mpadec->get_probe_information();
     afm=aprobe.driver;
     ac=aprobe.codec_dll;
     /* fake struct codecs_st*/
-    sh_audio->codec=new(zeromem) struct codecs_st;
-    strcpy(sh_audio->codec->dll_name,aprobe.codec_dll);
-    strcpy(sh_audio->codec->driver_name,aprobe.driver);
-    strcpy(sh_audio->codec->codec_name,sh_audio->codec->dll_name);
-    memcpy(sh_audio->codec->outfmt,aprobe.sample_fmt,sizeof(aprobe.sample_fmt));
+    sh.codec=new(zeromem) struct codecs_st;
+    strcpy(sh.codec->dll_name,aprobe.codec_dll);
+    strcpy(sh.codec->driver_name,aprobe.driver);
+    strcpy(sh.codec->codec_name,sh.codec->dll_name);
+    memcpy(sh.codec->outfmt,aprobe.sample_fmt,sizeof(aprobe.sample_fmt));
 
     /* reset in/out buffer size/pointer: */
-    sh_audio->a_buffer_size=0;
-    sh_audio->a_buffer=NULL;
-    sh_audio->a_in_buffer_size=0;
-    sh_audio->a_in_buffer=NULL;
+    sh.a_buffer_size=0;
+    sh.a_buffer=NULL;
+    sh.a_in_buffer_size=0;
+    sh.a_in_buffer=NULL;
 
-    if(sh_audio->wf) /* NK: We need to know i_bps before its detection by codecs param */
-	sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec;
+    if(sh.wf) /* NK: We need to know i_bps before its detection by codecs param */
+	sh.i_bps=sh.wf->nAvgBytesPerSec;
 
-    sh_audio->audio_out_minsize=8192;/* default size, maybe not enough for Win32/ACM*/
-    sh_audio->audio_in_minsize=0;
+    sh.audio_out_minsize=8192;/* default size, maybe not enough for Win32/ACM*/
+    sh.audio_in_minsize=0;
 
     /* allocate audio in buffer: */
-    if(sh_audio->audio_in_minsize>0){
-	sh_audio->a_in_buffer_size=sh_audio->audio_in_minsize;
-	mpxp_v<<"dec_audio: Allocating "<<sh_audio->a_in_buffer_size<<" bytes for input buffer"<<std::endl;
-	sh_audio->a_in_buffer=new char [sh_audio->a_in_buffer_size];
-	sh_audio->a_in_buffer_len=0;
+    if(sh.audio_in_minsize>0){
+	sh.a_in_buffer_size=sh.audio_in_minsize;
+	mpxp_v<<"dec_audio: Allocating "<<sh.a_in_buffer_size<<" bytes for input buffer"<<std::endl;
+	sh.a_in_buffer=new char [sh.a_in_buffer_size];
+	sh.a_in_buffer_len=0;
     }
 
     /* allocate audio out buffer: */
-    sh_audio->a_buffer_size=sh_audio->audio_out_minsize+MAX_OUTBURST; /* worst case calc.*/
+    sh.a_buffer_size=sh.audio_out_minsize+MAX_OUTBURST; /* worst case calc.*/
 
-    mpxp_v<<"dec_audio: Allocating "<<sh_audio->audio_out_minsize<<" + "<<MAX_OUTBURST
-	<<" = "<<sh_audio->a_buffer_size<<" bytes for output buffer"<<std::endl;
+    mpxp_v<<"dec_audio: Allocating "<<sh.audio_out_minsize<<" + "<<MAX_OUTBURST
+	<<" = "<<sh.a_buffer_size<<" bytes for output buffer"<<std::endl;
 
-    sh_audio->a_buffer=new char [sh_audio->a_buffer_size];
-    if(!sh_audio->a_buffer) {
+    sh.a_buffer=new char [sh.a_buffer_size];
+    if(!sh.a_buffer) {
 	MSG_ERR(MSGTR_CantAllocAudioBuf);
-	delete priv;
-	delete handle;
-	return NULL;
+	goto bye;
     }
-    sh_audio->a_buffer_len=0;
-    sh_audio->inited=1;
+    sh.a_buffer_len=0;
+    sh.inited=1;
 
-    if(!sh_audio->nch || !sh_audio->rate) {
-	mpxp_v<<"audio format wrong: nch="<<sh_audio->nch<<" rate="<<sh_audio->rate<<std::endl;
+    if(!sh.nch || !sh.rate) {
+	mpxp_v<<"audio format wrong: nch="<<sh.nch<<" rate="<<sh.rate<<std::endl;
 	MSG_WARN(MSGTR_UnknownAudio);
-	mpca_uninit(*handle); /* mp_free buffers */
-	return NULL;
+	goto bye;
     }
 
-    if(!sh_audio->o_bps)
-	sh_audio->o_bps=sh_audio->nch*sh_audio->rate*afmt2bps(sh_audio->afmt);
-    if(!sh_audio->i_bps) {
+    if(!sh.o_bps)
+	sh.o_bps=sh.nch*sh.rate*afmt2bps(sh.afmt);
+    if(!sh.i_bps) {
 	static int warned=0;
 	if(!warned) {
 	    warned=1;
 	    MSG_WARN(MSGTR_CODEC_INITAL_AV_RESYNC);
 	}
     } else if(mpxp_context().engine().xp_core->initial_apts_corr.need_correction==1) {
-	mpxp_context().engine().xp_core->initial_apts += ((float)(mpxp_context().engine().xp_core->initial_apts_corr.pts_bytes-mpxp_context().engine().xp_core->initial_apts_corr.nbytes))/(float)sh_audio->i_bps;
+	mpxp_context().engine().xp_core->initial_apts += ((float)(mpxp_context().engine().xp_core->initial_apts_corr.pts_bytes-mpxp_context().engine().xp_core->initial_apts_corr.nbytes))/(float)sh.i_bps;
 	mpxp_context().engine().xp_core->initial_apts_corr.need_correction=0;
     }
-    mpxp_ok<<"[AC] "<<(mp_conf.audio_codec?"Forcing":"Selecting")<<" drv:"<<aprobe.driver<<"."<<ac<<" ratio "<<sh_audio->i_bps<<"->"<<sh_audio->o_bps<<std::endl;
-    if(sh_audio->codec) { delete sh_audio->codec; sh_audio->codec=NULL; }
-    return handle;
+    mpxp_ok<<"[AC] "<<(mp_conf.audio_codec?"Forcing":"Selecting")<<" drv:"<<aprobe.driver<<"."<<ac<<" ratio "<<sh.i_bps<<"->"<<sh.o_bps<<std::endl;
+    if(sh.codec) { delete sh.codec; sh.codec=NULL; }
 }
 
-void mpca_uninit(audio_decoder_t& opaque)
+AD_Interface::~AD_Interface()
 {
-    decaudio_priv_t* priv = reinterpret_cast<decaudio_priv_t*>(opaque.ad_private);
-    sh_audio_t* parent = priv->parent;
-    if(!parent) { delete &opaque; delete priv; return; }
-    if(priv->afi->afilter){
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
+    sh_audio_t& sh = priv.parent;
+    if(priv.afi.afilter){
 	mpxp_v<<"Uninit audio filters..."<<std::endl;
-	af_uninit(priv->afi->afilter);
-	delete priv->afi->afilter;
-	priv->afi->afilter=NULL;
+	af_uninit(priv.afi.afilter);
+	delete priv.afi.afilter;
+	priv.afi.afilter=NULL;
     }
-    if(parent->a_buffer) delete parent->a_buffer;
-    parent->a_buffer=NULL;
-    if(parent->a_in_buffer) delete parent->a_in_buffer;
-    parent->a_in_buffer=NULL;
-    if(!parent->inited) { delete &opaque; delete priv; return; }
+    if(sh.a_buffer) delete sh.a_buffer;
+    sh.a_buffer=NULL;
+    if(sh.a_in_buffer) delete sh.a_in_buffer;
+    sh.a_in_buffer=NULL;
+    if(!sh.inited) { delete &priv; return; }
     mpxp_v<<"uninit audio: ..."<<std::endl;
-    if(parent->a_buffer) delete parent->a_buffer;
-    parent->a_buffer=NULL;
-    parent->inited=0;
-    delete priv;
-    delete &opaque;
+    if(sh.a_buffer) delete sh.a_buffer;
+    sh.a_buffer=NULL;
+    sh.inited=0;
+    delete &priv;
 }
 
  /* Init audio filters */
-MPXP_Rc mpca_preinit_filters(audio_decoder_t& opaque,
-	unsigned in_samplerate, unsigned in_channels, unsigned in_format,
-	unsigned& out_samplerate, unsigned& out_channels, unsigned& out_format){
-    decaudio_priv_t* priv = reinterpret_cast<decaudio_priv_t*>(opaque.ad_private);
-    sh_audio_t* sh_audio = priv->parent;
+MPXP_Rc AD_Interface::preinit_filters(unsigned in_samplerate, unsigned in_channels, unsigned in_format,
+	unsigned& out_samplerate, unsigned& out_channels, unsigned& out_format) const {
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
+    sh_audio_t& sh = priv.parent;
     char strbuf[200];
-    af_stream_t* afs=af_new(sh_audio);
+    af_stream_t* afs=af_new(&sh);
 
     // input format: same as codec's output format:
     afs->input.rate   = in_samplerate;
@@ -213,25 +204,24 @@
     out_channels=afs->output.nch;
     out_format=mpaf2afmt(afs->output.format);
 
-    sh_audio->af_bps = afs->output.rate*afs->output.nch*(afs->output.format&MPAF_BPS_MASK);
+    sh.af_bps = afs->output.rate*afs->output.nch*(afs->output.format&MPAF_BPS_MASK);
 
     mpxp_v<<"AF_pre: af format: "<<afs->output.nch<<" ch, "<<afs->output.rate<<" hz, "<<mpaf_fmt2str(afs->output.format,strbuf,200)
-	<<" af_bps="<<sh_audio->af_bps<<std::endl;
+	<<" af_bps="<<sh.af_bps<<std::endl;
 
-    priv->afi->afilter=afs;
+    priv.afi.afilter=afs;
     return MPXP_Ok;
 }
 
  /* Init audio filters */
-MPXP_Rc mpca_init_filters(audio_decoder_t& opaque,
-	unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
+MPXP_Rc AD_Interface::init_filters(unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
 	unsigned out_samplerate, unsigned out_channels, mpaf_format_e out_format,
-	unsigned out_minsize, unsigned out_maxsize){
-    decaudio_priv_t* priv = reinterpret_cast<decaudio_priv_t*>(opaque.ad_private);
-    sh_audio_t* sh_audio = priv->parent;
+	unsigned out_minsize, unsigned out_maxsize) const {
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
+    sh_audio_t& sh = priv.parent;
     char strbuf[200];
-    af_stream_t* afs=priv->afi->afilter;
-    if(!afs) afs = af_new(sh_audio);
+    af_stream_t* afs=priv.afi.afilter;
+    if(!afs) afs = af_new(&sh);
 
     // input format: same as codec's output format:
     afs->input.rate   = in_samplerate;
@@ -252,7 +242,7 @@
 
     // let's autoprobe it!
     if(MPXP_Ok != af_init(afs,1)){
-	priv->afi->afilter=NULL;
+	priv.afi.afilter=NULL;
 	delete afs;
 	return MPXP_False; // failed :(
     }
@@ -261,80 +251,79 @@
     if(out_maxsize<out_minsize) out_maxsize=out_minsize;
     if(out_maxsize<8192) out_maxsize=MAX_OUTBURST; // not sure this is ok
 
-    sh_audio->af_bps = afs->output.rate*afs->output.nch*(afs->output.format&MPAF_BPS_MASK);
+    sh.af_bps = afs->output.rate*afs->output.nch*(afs->output.format&MPAF_BPS_MASK);
 
     mpxp_v<<"AF_init: af format: "<<afs->output.nch<<" ch, "<<afs->output.rate
-	<<" hz, "<<mpaf_fmt2str(afs->output.format,strbuf,200)<<" af_bps="<<sh_audio->af_bps<<std::endl;
+	<<" hz, "<<mpaf_fmt2str(afs->output.format,strbuf,200)<<" af_bps="<<sh.af_bps<<std::endl;
 
-    sh_audio->a_buffer_size=out_maxsize;
-    sh_audio->a_buffer=new char [sh_audio->a_buffer_size];
-    sh_audio->a_buffer_len=0;
+    sh.a_buffer_size=out_maxsize;
+    sh.a_buffer=new char [sh.a_buffer_size];
+    sh.a_buffer_len=0;
 
     af_showconf(afs->first);
-    priv->afi->afilter=afs;
-    priv->afi->afilter_inited=1;
+    priv.afi.afilter=afs;
+    priv.afi.afilter_inited=1;
     return MPXP_Ok;
 }
 
  /* Init audio filters */
-MPXP_Rc mpca_reinit_filters(audio_decoder_t& opaque,
-	unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
+MPXP_Rc AD_Interface::reinit_filters(unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
 	unsigned out_samplerate, unsigned out_channels, mpaf_format_e out_format,
-	unsigned out_minsize, unsigned out_maxsize)
+	unsigned out_minsize, unsigned out_maxsize) const
 {
-    decaudio_priv_t* priv = reinterpret_cast<decaudio_priv_t*>(opaque.ad_private);
-    if(priv->afi->afilter){
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
+    if(priv.afi.afilter){
 	mpxp_v<<"Uninit audio filters..."<<std::endl;
-	af_uninit(priv->afi->afilter);
-	delete priv->afi->afilter;
-	priv->afi->afilter=NULL;
+	af_uninit(priv.afi.afilter);
+	delete priv.afi.afilter;
+	priv.afi.afilter=NULL;
     }
-    return mpca_init_filters(opaque,in_samplerate,in_channels,
-				in_format,out_samplerate,
-				out_channels,out_format,
-				out_minsize,out_maxsize);
+    return init_filters(in_samplerate,in_channels,
+			in_format,out_samplerate,
+			out_channels,out_format,
+			out_minsize,out_maxsize);
 }
 
-unsigned mpca_decode(audio_decoder_t& opaque,unsigned char *buf,unsigned minlen,unsigned maxlen,unsigned buflen,float& pts)
+unsigned AD_Interface::run(unsigned char *buf,unsigned minlen,unsigned maxlen,unsigned buflen,float& pts) const
 {
-    decaudio_priv_t* priv = reinterpret_cast<decaudio_priv_t*>(opaque.ad_private);
-    sh_audio_t* sh_audio = priv->parent;
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
+    sh_audio_t& sh = priv.parent;
     unsigned len;
     unsigned cp_size,cp_tile;
 
-    if(!sh_audio->inited) return 0; // no codec
+    if(!sh.inited) return 0; // no codec
 
     if(minlen>maxlen) MSG_WARN(MSGTR_CODEC_XP_INT_ERR,minlen,maxlen);
-    if(sh_audio->af_buffer_len) {
-	cp_size=std::min(buflen,sh_audio->af_buffer_len);
-	memcpy(buf,sh_audio->af_buffer,cp_size);
-	pts = sh_audio->af_pts;
-	cp_tile=sh_audio->af_buffer_len-cp_size;
-	mpxp_dbg2<<"cache->buf "<<cp_size<<" bytes "<<pts<<" pts <PREDICTED PTS "<<(pts+(float)cp_tile/(float)sh_audio->af_bps)<<">"<<std::endl;
+    if(sh.af_buffer_len) {
+	cp_size=std::min(buflen,sh.af_buffer_len);
+	memcpy(buf,sh.af_buffer,cp_size);
+	pts = sh.af_pts;
+	cp_tile=sh.af_buffer_len-cp_size;
+	mpxp_dbg2<<"cache->buf "<<cp_size<<" bytes "<<pts<<" pts <PREDICTED PTS "<<(pts+(float)cp_tile/(float)sh.af_bps)<<">"<<std::endl;
 	if(cp_tile) {
-	    sh_audio->af_buffer=&sh_audio->af_buffer[cp_size];
-	    sh_audio->af_buffer_len=cp_tile;
-	    sh_audio->af_pts += (float)cp_size/(float)sh_audio->af_bps;
+	    sh.af_buffer=&sh.af_buffer[cp_size];
+	    sh.af_buffer_len=cp_tile;
+	    sh.af_pts += (float)cp_size/(float)sh.af_bps;
 	}
-	else sh_audio->af_buffer_len=0;
+	else sh.af_buffer_len=0;
 	return cp_size;
     }
-    if(sh_audio->af_bps>sh_audio->o_bps)
-	maxlen=std::min(maxlen,buflen*sh_audio->o_bps/sh_audio->af_bps);
-    len=priv->mpadec->run(buf, minlen, maxlen,pts);
-    if(len>buflen) MSG_WARN(MSGTR_CODEC_BUF_OVERFLOW,sh_audio->codec->driver_name,len,buflen);
-    mpxp_dbg2<<"decaudio: "<<len<<" bytes "<<pts<<" pts min "<<minlen<<" max "<<maxlen<<" buflen "<<buflen<<" o_bps="<<sh_audio->o_bps<<" f_bps="<<sh_audio->af_bps<<std::endl;
-    if(len==0 || !priv->afi->afilter) return 0; // EOF?
+    if(sh.af_bps>sh.o_bps)
+	maxlen=std::min(maxlen,buflen*sh.o_bps/sh.af_bps);
+    len=priv.mpadec->run(buf, minlen, maxlen,pts);
+    if(len>buflen) MSG_WARN(MSGTR_CODEC_BUF_OVERFLOW,sh.codec->driver_name,len,buflen);
+    mpxp_dbg2<<"decaudio: "<<len<<" bytes "<<pts<<" pts min "<<minlen<<" max "<<maxlen<<" buflen "<<buflen<<" o_bps="<<sh.o_bps<<" f_bps="<<sh.af_bps<<std::endl;
+    if(len==0 || !priv.afi.afilter) return 0; // EOF?
     // run the filters:
     mp_aframe_t*  afd;  // filter input
     mp_aframe_t* pafd; // filter output
-    afd=new_mp_aframe(	sh_audio->rate,
-			sh_audio->nch,
-			afmt2mpaf(sh_audio->afmt)
+    afd=new_mp_aframe(	sh.rate,
+			sh.nch,
+			afmt2mpaf(sh.afmt)
 			,0); // xp_idx
     afd->audio=buf;
     afd->len=len;
-    pafd=af_play(priv->afi->afilter,afd);
+    pafd=af_play(priv.afi.afilter,afd);
     afd->audio=NULL; // fake no buffer
 
     if(!pafd) {
@@ -349,36 +338,33 @@
     memcpy(buf,pafd->audio,cp_size);
     cp_tile=pafd->len-cp_size;
     if(cp_tile) {
-	sh_audio->af_buffer=&((char *)pafd->audio)[cp_size];
-	sh_audio->af_buffer_len=cp_tile;
-	sh_audio->af_pts = pts+(float)cp_size/(float)sh_audio->af_bps;
+	sh.af_buffer=&((char *)pafd->audio)[cp_size];
+	sh.af_buffer_len=cp_tile;
+	sh.af_pts = pts+(float)cp_size/(float)sh.af_bps;
 	mpxp_dbg2<<"decaudio: afilter->cache "<<cp_tile<<" bytes "<<pts<<" pts"<<std::endl;
-    } else sh_audio->af_buffer_len=0;
+    } else sh.af_buffer_len=0;
     if(pafd!=afd) free_mp_aframe(pafd);
     free_mp_aframe(afd);
     return cp_size;
 }
 
 /* Note: it is called once after seeking, to resync. */
-void mpca_resync_stream(audio_decoder_t& opaque)
+void AD_Interface::resync_stream() const
 {
-    decaudio_priv_t* priv = reinterpret_cast<decaudio_priv_t*>(opaque.ad_private);
-    sh_audio_t* sh_audio = priv->parent;
-    if(sh_audio) {
-	sh_audio->a_in_buffer_len=0; /* workaround */
-	if(sh_audio->inited && priv->mpadec) priv->mpadec->ctrl(ADCTRL_RESYNC_STREAM,NULL);
-    }
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
+    sh_audio_t& sh = priv.parent;
+    sh.a_in_buffer_len=0; /* workaround */
+    if(sh.inited && priv.mpadec) priv.mpadec->ctrl(ADCTRL_RESYNC_STREAM,NULL);
 }
 
 /* Note: it is called to skip (jump over) small amount (1/10 sec or 1 frame)
    of audio data - used to sync audio to video after seeking */
-void mpca_skip_frame(audio_decoder_t& opaque)
+void AD_Interface::skip_frame() const
 {
-    decaudio_priv_t* priv = reinterpret_cast<decaudio_priv_t*>(opaque.ad_private);
-    sh_audio_t* sh_audio = priv->parent;
+    decaudio_priv_t& priv = reinterpret_cast<decaudio_priv_t&>(ad_private);
+    sh_audio_t& sh = priv.parent;
     MPXP_Rc rc=MPXP_True;
-    if(sh_audio)
-    if(sh_audio->inited && priv->mpadec) rc=priv->mpadec->ctrl(ADCTRL_SKIP_FRAME,NULL);
-    if(rc!=MPXP_True) sh_audio->ds->fill_buffer();
+    if(sh.inited && priv.mpadec) rc=priv.mpadec->ctrl(ADCTRL_SKIP_FRAME,NULL);
+    if(rc!=MPXP_True) sh.ds->fill_buffer();
 }
 } // namespace	usr
\ No newline at end of file

Modified: mplayerxp/libmpcodecs/dec_audio.h
===================================================================
--- mplayerxp/libmpcodecs/dec_audio.h	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/dec_audio.h	2013-06-11 17:36:43 UTC (rev 652)
@@ -6,28 +6,29 @@
 
 struct codecs_st;
 namespace	usr {
-    struct audio_decoder_t {
-	Opaque*	ad_private;
-    };
+    class AD_Interface : public Opaque {
+	public:
+	    AD_Interface(sh_audio_t& sh_audio);
+	    virtual ~AD_Interface();
 
-    // dec_audio.c:
-    audio_decoder_t*		__FASTCALL__ mpca_init(sh_audio_t *sh_audio);
-    void			__FASTCALL__ mpca_uninit(audio_decoder_t& handle);
-    unsigned			__FASTCALL__ mpca_decode(audio_decoder_t& handle,unsigned char *buf,unsigned minlen,unsigned maxlen,unsigned buflen,float& pts);
-    void			__FASTCALL__ mpca_resync_stream(audio_decoder_t& handle);
-    void			__FASTCALL__ mpca_skip_frame(audio_decoder_t& handle);
+	    virtual unsigned		run(unsigned char *buf,unsigned minlen,unsigned maxlen,unsigned buflen,float& pts) const;
+	    virtual void		resync_stream() const;
+	    virtual void		skip_frame() const;
 
-    MPXP_Rc mpca_init_filters(audio_decoder_t& sh_audio,
-	unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
-	unsigned out_samplerate, unsigned out_channels,mpaf_format_e out_format,
-	unsigned out_minsize, unsigned out_maxsize);
-    MPXP_Rc mpca_preinit_filters(audio_decoder_t& sh_audio,
-	unsigned in_samplerate, unsigned in_channels, unsigned in_format,
-	unsigned& out_samplerate, unsigned& out_channels, unsigned& out_format);
-    MPXP_Rc mpca_reinit_filters(audio_decoder_t& sh_audio,
-	unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
-	unsigned out_samplerate, unsigned out_channels, mpaf_format_e out_format,
-	unsigned out_minsize, unsigned out_maxsize);
-    void afm_help(void);
+	    virtual MPXP_Rc		init_filters(unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
+						    unsigned out_samplerate, unsigned out_channels,mpaf_format_e out_format,
+						    unsigned out_minsize, unsigned out_maxsize) const;
+	    virtual MPXP_Rc		preinit_filters(unsigned in_samplerate, unsigned in_channels, unsigned in_format,
+						    unsigned& out_samplerate, unsigned& out_channels, unsigned& out_format) const;
+	    virtual MPXP_Rc		reinit_filters(unsigned in_samplerate, unsigned in_channels, mpaf_format_e in_format,
+						    unsigned out_samplerate, unsigned out_channels, mpaf_format_e out_format,
+						    unsigned out_minsize, unsigned out_maxsize) const;
+	    static void			print_help();
+	private:
+	    const ad_info_t*		find_driver(const std::string& name) const;
+	    Audio_Decoder*		probe_driver(sh_audio_t& sh,audio_filter_info_t& afi) const;
+
+	    Opaque&	ad_private;
+    };
 } //namespace usr
 #endif

Modified: mplayerxp/libmpcodecs/dec_video.cpp
===================================================================
--- mplayerxp/libmpcodecs/dec_video.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/dec_video.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -37,6 +37,7 @@
 #include "osdep/cpudetect.h"
 #include "vd_msg.h"
 
+#include "libvo2/video_out.h"
 // ===================================================================
 namespace usr	{
 vf_cfg_t vf_cfg; // Configuration for audio filters
@@ -48,162 +49,160 @@
 
 struct decvideo_priv_t : public Opaque {
     public:
-	decvideo_priv_t(libinput_t&);
+	decvideo_priv_t(libinput_t&,sh_video_t&);
 	virtual ~decvideo_priv_t();
 
-	sh_video_t*		parent;
+	sh_video_t&		parent;
+	libinput_t&		libinput;
+	put_slice_info_t&	psi;
 	Video_Decoder*		mpvdec;
-	libinput_t&		libinput;
 	vf_stream_t*		vfilter;
 	int			vfilter_inited;
-	put_slice_info_t*	psi;
+	unsigned		smp_num_cpus;
+	unsigned		use_vf_threads;
+	float			sub_last_pts;
 };
 
-decvideo_priv_t::decvideo_priv_t(libinput_t& _libinput)
-		:libinput(_libinput),
-		psi(new(zeromem) put_slice_info_t)
+decvideo_priv_t::decvideo_priv_t(libinput_t& _libinput,sh_video_t& p)
+		:parent(p)
+		,libinput(_libinput)
+		,psi(*new(zeromem) put_slice_info_t)
+		,smp_num_cpus(1)
+		,sub_last_pts(-303)
 {
 }
 
-decvideo_priv_t::~decvideo_priv_t() { delete psi; }
+decvideo_priv_t::~decvideo_priv_t() { delete &psi; }
 
-MPXP_Rc mpcv_get_quality_max(video_decoder_t& opaque,unsigned& quality){
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    if(priv->mpvdec){
-	MPXP_Rc ret=priv->mpvdec->ctrl(VDCTRL_QUERY_MAX_PP_LEVEL,&quality);
+MPXP_Rc VD_Interface::get_quality_max(unsigned& quality) const {
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    if(priv.mpvdec){
+	MPXP_Rc ret=priv.mpvdec->ctrl(VDCTRL_QUERY_MAX_PP_LEVEL,&quality);
 	if(ret>=MPXP_Ok) return ret;
     }
     return MPXP_False;
 }
 
-MPXP_Rc mpcv_set_quality(video_decoder_t& opaque,int quality){
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    if(priv->mpvdec)
-	return priv->mpvdec->ctrl(VDCTRL_SET_PP_LEVEL, (any_t*)(&quality));
+MPXP_Rc VD_Interface::set_quality(int quality) const {
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    if(priv.mpvdec) return priv.mpvdec->ctrl(VDCTRL_SET_PP_LEVEL, (any_t*)(&quality));
     return MPXP_False;
 }
 
-MPXP_Rc mpcv_set_colors(video_decoder_t& opaque,const std::string& item,int value)
+MPXP_Rc VD_Interface::set_colors(const std::string& item,int value) const
 {
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    vf_stream_t* vs=priv->vfilter;
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    vf_stream_t* vs=priv.vfilter;
     vf_equalizer_t eq;
     eq.item=item.c_str();
     eq.value=value*10;
     if(vf_control(vs,VFCTRL_SET_EQUALIZER,&eq)!=MPXP_True) {
-	if(priv->mpvdec) return priv->mpvdec->ctrl(VDCTRL_SET_EQUALIZER,(any_t*)item.c_str(),value);
+	if(priv.mpvdec) return priv.mpvdec->ctrl(VDCTRL_SET_EQUALIZER,(any_t*)item.c_str(),value);
     }
     return MPXP_False;
 }
 
-void mpcv_uninit(video_decoder_t& opaque){
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    sh_video_t* sh_video = priv->parent;
-    if(!sh_video->inited) { delete priv; delete &opaque; return; }
+VD_Interface::~VD_Interface(){
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    sh_video_t& sh_video = priv.parent;
+    if(!sh_video.inited) { delete &priv; return; }
     mpxp_v<<"uninit video ..."<<std::endl;
-    if(priv->vfilter && priv->vfilter_inited==1) vf_uninit(priv->vfilter);
-    delete priv->mpvdec;
-    sh_video->inited=0;
-    delete priv;
-    delete &opaque;
+    if(priv.vfilter && priv.vfilter_inited==1) vf_uninit(priv.vfilter);
+    delete priv.mpvdec;
+    sh_video.inited=0;
+    delete &priv;
 }
 
-#include "libvo2/video_out.h"
 #define MPDEC_THREAD_COND (VF_FLAGS_THREADS|VF_FLAGS_SLICES)
-static unsigned smp_num_cpus=1;
-static unsigned use_vf_threads=0;
 
-static void mpcv_print_codec_info(decvideo_priv_t& priv) {
-    sh_video_t* sh_video = priv.parent;
-    mpxp_ok<<"[VC] "<<(mp_conf.video_codec?"Forcing":"Selected")<<" decoder: ["<<sh_video->codec->codec_name
-	<<"] drv:"<<priv.mpvdec->get_probe_information().driver<<"."<<sh_video->codec->dll_name
-	<<" ("<<sh_video->src_w<<"x"<<sh_video->src_h<<" (aspect "<<sh_video->aspect<<") "<<sh_video->fps<<"fps"<<std::endl;
+void VD_Interface::print_codec_info() const {
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    sh_video_t& sh = priv.parent;
+    mpxp_ok<<"[VC] "<<(mp_conf.video_codec?"Forcing":"Selected")<<" decoder: ["<<sh.codec->codec_name
+	<<"] drv:"<<priv.mpvdec->get_probe_information().driver<<"."<<sh.codec->dll_name
+	<<" ("<<sh.src_w<<"x"<<sh.src_h<<" (aspect "<<sh.aspect<<") "<<sh.fps<<"fps"<<std::endl;
     // Yeah! We got it!
-    sh_video->inited=1;
-    priv.psi->vf_flags=vf_query_flags(priv.vfilter);
+    sh.inited=1;
+    priv.psi.vf_flags=vf_query_flags(priv.vfilter);
 #ifdef _OPENMP
     if(mp_conf.gomp) {
-	smp_num_cpus=omp_get_num_procs();
-	use_vf_threads=0;
-	if(((priv.psi->vf_flags&MPDEC_THREAD_COND)==MPDEC_THREAD_COND) && (smp_num_cpus>1)) use_vf_threads=1;
-	if(use_vf_threads)
-	    mpxp_status<<"[mpdec] will perform parallel video-filter on "<<smp_num_cpus<<" CPUs"<<std::endl;
+	priv.smp_num_cpus=omp_get_num_procs();
+	priv.use_vf_threads=0;
+	if(((priv.psi.vf_flags&MPDEC_THREAD_COND)==MPDEC_THREAD_COND) && (priv.smp_num_cpus>1)) priv.use_vf_threads=1;
+	if(priv.use_vf_threads)
+	    mpxp_status<<"[mpdec] will perform parallel video-filter on "<<priv.smp_num_cpus<<" CPUs"<<std::endl;
     }
 #else
     mpxp_v<<"[mpdec] GOMP was not compiled-in! Using single threaded video filtering!"<<std::endl;
 #endif
 }
 
-video_decoder_t* mpcv_init(sh_video_t *sh_video,const std::string& codecname,const std::string& family,int status,libinput_t&libinput){
+VD_Interface::VD_Interface(sh_video_t& sh,const std::string& codecname,const std::string& family,int status,libinput_t&libinput)
+	    :vd_private(*new(zeromem) decvideo_priv_t(libinput,sh))
+{
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
     UNUSED(codecname);
     UNUSED(status);
-    sh_video->codec=NULL;
-    video_decoder_t* handle=new(zeromem) video_decoder_t;
-    decvideo_priv_t* priv = new(zeromem) decvideo_priv_t(libinput);
-    priv->parent=sh_video;
-    handle->vd_private=priv;
+    sh.codec=NULL;
     std::string vfm=family;
 
     MP_UNIT("init_video_filters");
-    if(priv->vfilter_inited<=0) {
+    if(priv.vfilter_inited<=0) {
 	vf_conf_t conf;
-	conf.w=sh_video->src_w;
-	conf.h=sh_video->src_h;
-	conf.fourcc=sh_video->fourcc; // may be NULL ???
-	priv->vfilter=vf_init(libinput,&conf);
-	priv->vfilter_inited=1;
+	conf.w=sh.src_w;
+	conf.h=sh.src_h;
+	conf.fourcc=sh.fourcc; // may be NULL ???
+	priv.vfilter=vf_init(libinput,&conf);
+	priv.vfilter_inited=1;
     }
 
     if(!vfm.empty()) {
-	const vd_info_t* vi=vfm_find_driver(vfm);
+	const vd_info_t* vi=find_driver(vfm);
 	try{
-	    priv->mpvdec=vi->query_interface(*handle,*sh_video,*priv->psi,sh_video->fourcc);
+	    priv.mpvdec=vi->query_interface(*this,sh,priv.psi,sh.fourcc);
 	} catch(const bad_format_exception&) {
 	    MSG_ERR(MSGTR_CODEC_CANT_INITV);
-	    delete priv->mpvdec;
+	    delete priv.mpvdec;
 	    goto bye;
 	}
     }
-    else priv->mpvdec = vfm_probe_driver(*handle,*sh_video,*priv->psi);
-    if(!priv->mpvdec) {
+    else priv.mpvdec = probe_driver(sh,priv.psi);
+    if(!priv.mpvdec) {
 bye:
-	delete handle;
-	delete priv;
-	return NULL;
+	throw missing_driver_exception();
     }
 
-    video_probe_t probe = priv->mpvdec->get_probe_information();
+    video_probe_t probe = priv.mpvdec->get_probe_information();
     vfm=probe.driver;
     /* fake struct codecs_st*/
-    sh_video->codec=new(zeromem) struct codecs_st;
-    strcpy(sh_video->codec->dll_name,probe.codec_dll);
-    strcpy(sh_video->codec->driver_name,probe.driver);
-    strcpy(sh_video->codec->codec_name,sh_video->codec->dll_name);
-    memcpy(sh_video->codec->outfmt,probe.pix_fmt,sizeof(probe.pix_fmt));
+    sh.codec=new(zeromem) struct codecs_st;
+    strcpy(sh.codec->dll_name,probe.codec_dll);
+    strcpy(sh.codec->driver_name,probe.driver);
+    strcpy(sh.codec->codec_name,sh.codec->dll_name);
+    memcpy(sh.codec->outfmt,probe.pix_fmt,sizeof(probe.pix_fmt));
 
-    vf_showlist(priv->vfilter);
+    vf_showlist(priv.vfilter);
 
-    mpcv_print_codec_info(*priv);
-    return handle;
+    print_codec_info();
 }
 
-void mpcodecs_draw_image(video_decoder_t& opaque,mp_image_t *mpi)
+void VD_Interface::draw_image(const mp_image_t* mpi) const
 {
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
     vf_stream_t* s;
     const unsigned h_step=16;
     unsigned num_slices = mpi->h/h_step;
-    s=priv->vfilter;
+    s=priv.vfilter;
 
   if(!(mpi->flags&(MP_IMGFLAG_DRAW_CALLBACK))){
     if(mpi->h%h_step) num_slices++;
-    if(priv->psi->vf_flags&VF_FLAGS_SLICES)
+    if(priv.psi.vf_flags&VF_FLAGS_SLICES)
     {
 	unsigned j,i,y;
 	mp_image_t *ampi[num_slices];
 	static int hello_printed=0;
 	if(!hello_printed) {
-		mpxp_ok<<"[VC] using "<<smp_num_cpus<<" threads for video filters"<<std::endl;
+		mpxp_ok<<"[VC] using "<<priv.smp_num_cpus<<" threads for video filters"<<std::endl;
 		hello_printed=1;
 	}
 	y=0;
@@ -213,10 +212,10 @@
 	    y+=h_step;
 	}
 #ifdef _OPENMP
-	if(use_vf_threads && (num_slices>smp_num_cpus)) {
-	    for(j=0;j<num_slices;j+=smp_num_cpus) {
+	if(priv.use_vf_threads && (num_slices>priv.smp_num_cpus)) {
+	    for(j=0;j<num_slices;j+=priv.smp_num_cpus) {
 #pragma omp parallel for shared(s) private(i)
-		for(i=j;i<smp_num_cpus;i++) {
+		for(i=j;i<priv.smp_num_cpus;i++) {
 		    mpxp_dbg2<<"parallel: dec_video.put_slice["<<ampi[i]->width<<"x"<<ampi[i]->height
 			<<"] "<<ampi[i]->x<<" "<<ampi[i]->y<<" "<<ampi[i]->w<<" "<<ampi[i]->h<<std::endl;
 		    vf_put_slice(s,ampi[i]);
@@ -241,34 +240,34 @@
 	for(i=0;i<num_slices;i++) free_mp_image(ampi[i]);
     } else {
 	mpxp_dbg2<<"Put whole frame["<<mpi->width<<"x"<<mpi->height<<"]"<<std::endl;
-	vf_put_slice(s,mpi);
+	mp_image_t dmpi=*mpi;
+	vf_put_slice(s,&dmpi);
     }
     free_mp_image(mpi);
   }
 }
 
-static void update_subtitle(video_decoder_t& opaque,float v_pts,unsigned idx);
-int mpcv_decode(video_decoder_t& opaque,const enc_frame_t& frame){
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
+int VD_Interface::run(const enc_frame_t& frame) const {
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
     vf_stream_t* s;
     mp_image_t *mpi=NULL;
     unsigned int t;
     unsigned int t2;
     double tt;
 
-    s=priv->vfilter;
+    s=priv.vfilter;
 
     t=GetTimer();
     vf_control(s,VFCTRL_START_FRAME,NULL);
 
-    priv->psi->active_slices=0;
-    mpi=priv->mpvdec->run(frame);
+    priv.psi.active_slices=0;
+    mpi=priv.mpvdec->run(frame);
     mpxp_dbg2<<"decvideo: decoding video "<<frame.len<<" bytes"<<std::endl;
-    while(priv->psi->active_slices!=0) yield_timeslice();
+    while(priv.psi.active_slices!=0) yield_timeslice();
 /* ------------------------ frame decoded. -------------------- */
 
     if(!mpi) return 0; // error / skipped frame
-    mpcodecs_draw_image(opaque,mpi);
+    draw_image(mpi);
 
     t2=GetTimer();t=t2-t;
     tt = t*0.000001f;
@@ -280,7 +279,7 @@
     }
 
     if(frame.flags) return 0;
-    update_subtitle(opaque,frame.pts,mpi->xp_idx);
+    update_subtitle(frame.pts,mpi->xp_idx);
     mpxp_context().video().output->flush_page(dae_curr_vdecoded(mpxp_context().engine().xp_core));
 
     t2=GetTimer()-t2;
@@ -296,31 +295,27 @@
     return 1;
 }
 
-void mpcv_resync_stream(video_decoder_t& opaque)
+void VD_Interface::resync_stream() const
 {
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    sh_video_t* sh_video = priv->parent;
-    if(sh_video)
-    if(sh_video->inited && priv->mpvdec) priv->mpvdec->ctrl(VDCTRL_RESYNC_STREAM,NULL);
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    sh_video_t& sh = priv.parent;
+    if(sh.inited && priv.mpvdec) priv.mpvdec->ctrl(VDCTRL_RESYNC_STREAM,NULL);
 }
 
-#ifdef USE_SUB
-static float sub_last_pts = -303;
-#endif
-static void update_subtitle(video_decoder_t& opaque,float v_pts,unsigned xp_idx)
+void VD_Interface::update_subtitle(float v_pts,unsigned xp_idx) const
 {
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    sh_video_t* sh_video = priv->parent;
-    Demuxer_Stream *d_dvdsub=sh_video->ds->demuxer->sub;
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    sh_video_t& sh = priv.parent;
+    Demuxer_Stream *d_dvdsub=sh.ds->demuxer->sub;
 #ifdef USE_SUB
   // find sub
   if(mpxp_context().subtitles && v_pts>0){
       float pts=v_pts;
-      if(mp_conf.sub_fps==0) mp_conf.sub_fps=sh_video->fps;
+      if(mp_conf.sub_fps==0) mp_conf.sub_fps=sh.fps;
       MP_UNIT("find_sub");
-      if (pts > sub_last_pts || pts < sub_last_pts-1.0 ) {
+      if (pts > priv.sub_last_pts || pts < priv.sub_last_pts-1.0 ) {
 	 find_sub(mpxp_context().subtitles,sub_uses_time?(100*pts):(pts*mp_conf.sub_fps),mpxp_context().video().output); // FIXME! frame counter...
-	 sub_last_pts = pts;
+	 priv.sub_last_pts = pts;
       }
       MP_UNIT(NULL);
   }
@@ -356,36 +351,34 @@
   }
 }
 
-#include "libvo2/video_out.h"
-
-MPXP_Rc mpcodecs_config_vf(video_decoder_t& opaque, int w, int h){
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    sh_video_t* sh = priv->parent;
+MPXP_Rc VD_Interface::config_vf(int w, int h) const {
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    sh_video_t& sh = priv.parent;
     int i,j;
     unsigned int out_fmt=0;
     int screen_size_x=0;//SCREEN_SIZE_X;
     int screen_size_y=0;//SCREEN_SIZE_Y;
-    vf_stream_t* s=priv->vfilter;
+    vf_stream_t* s=priv.vfilter;
     vf_conf_t conf;
     int palette=0;
 
-    if(!(sh->src_w && sh->src_h))
-	mpxp_warn<<"VDec: driver "<<sh->codec->codec_name<<" didn't set sh->src_w and sh->src_h, trying to workaround!"<<std::endl;
-    /* XXX: HACK, if sh->disp_* aren't set,
+    if(!(sh.src_w && sh.src_h))
+	mpxp_warn<<"VDec: driver "<<sh.codec->codec_name<<" didn't set sh.src_w and sh.src_h, trying to workaround!"<<std::endl;
+    /* XXX: HACK, if sh.disp_* aren't set,
      * but we have w and h, set them :: atmos */
-    if(!sh->src_w && w)
-	sh->src_w=w;
-    if(!sh->src_h && h)
-	sh->src_h=h;
+    if(!sh.src_w && w)
+	sh.src_w=w;
+    if(!sh.src_h && h)
+	sh.src_h=h;
 
     mpxp_v<<"VDec: vo config request - "<<w<<" x "<<h<<std::endl;
 
-    if(vf_config(s,sh->src_w,sh->src_h,
-		sh->src_w,sh->src_h,
+    if(vf_config(s,sh.src_w,sh.src_h,
+		sh.src_w,sh.src_h,
 		mpxp_context().video().output->flags,
 		out_fmt)==0){
 		    MSG_WARN(MSGTR_CannotInitVO);
-		    priv->vfilter_inited=-1;
+		    priv.vfilter_inited=-1;
 		    return MPXP_False;
     }
 
@@ -394,16 +387,16 @@
     j=-1;
     for(i=0;i<CODECS_MAX_OUTFMT;i++){
 	int flags;
-	out_fmt=sh->codec->outfmt[i];
+	out_fmt=sh.codec->outfmt[i];
 	if(out_fmt==0xFFFFFFFF||out_fmt==0x0) continue;
 	flags=vf_query_format(s,out_fmt,w,h);
 	mpxp_dbg2<<"vo_debug[step i="<<i<<"]: query("<<vo_format_name(out_fmt)<<" "<<w<<"x"<<h<<") returned 0x"<<std::hex<<flags<<" for:"<<std::endl;
 	if(mp_conf.verbose>1) vf_showlist(s);
 	if((flags&VFCAP_CSP_SUPPORTED_BY_HW) || ((flags&VFCAP_CSP_SUPPORTED) && j<0)){
 	    // check (query) if codec really support this outfmt...
-	    sh->outfmtidx=j; // pass index to the control() function this way
-	    if(priv->mpvdec->ctrl(VDCTRL_QUERY_FORMAT,&out_fmt)==MPXP_False) {
-		mpxp_dbg2<<"vo_debug: codec["<<priv->mpvdec->get_probe_information().driver<<"] query_format("<<vo_format_name(out_fmt)<<") returned FALSE"<<std::endl;
+	    sh.outfmtidx=j; // pass index to the control() function this way
+	    if(priv.mpvdec->ctrl(VDCTRL_QUERY_FORMAT,&out_fmt)==MPXP_False) {
+		mpxp_dbg2<<"vo_debug: codec["<<priv.mpvdec->get_probe_information().driver<<"] query_format("<<vo_format_name(out_fmt)<<") returned FALSE"<<std::endl;
 		continue;
 	    }
 	    j=i;
@@ -411,8 +404,8 @@
 	    if(flags&VFCAP_CSP_SUPPORTED_BY_HW) break;
 	} else
 	if(!palette && !(mpxp_context().video().output->flags&3) && (out_fmt==IMGFMT_RGB8||out_fmt==IMGFMT_BGR8)){
-	    sh->outfmtidx=j; // pass index to the control() function this way
-	    if(priv->mpvdec->ctrl(VDCTRL_QUERY_FORMAT,&out_fmt)!=MPXP_False)
+	    sh.outfmtidx=j; // pass index to the control() function this way
+	    if(priv.mpvdec->ctrl(VDCTRL_QUERY_FORMAT,&out_fmt)!=MPXP_False)
 		palette=1;
 	}
     }
@@ -422,23 +415,23 @@
 	    int ind;
 	    mpxp_warn<<"Can't find colorspace for: ";
 	    for(ind=0;ind<CODECS_MAX_OUTFMT;ind++) {
-		if(sh->codec->outfmt[ind]==0xFFFFFFFF||
-		    sh->codec->outfmt[ind]==0x0) break;
-		mpxp_warn<<"'"<<vo_format_name(sh->codec->outfmt[ind])<<"' "<<std::endl;
+		if(sh.codec->outfmt[ind]==0xFFFFFFFF||
+		    sh.codec->outfmt[ind]==0x0) break;
+		mpxp_warn<<"'"<<vo_format_name(sh.codec->outfmt[ind])<<"' "<<std::endl;
 	    }
 	    mpxp_warn<<"Trying -vf fmtcvt..."<<std::endl;
-	    conf.w=sh->src_w;
-	    conf.h=sh->src_h;
-	    conf.fourcc=sh->codec->outfmt[sh->outfmtidx];
+	    conf.w=sh.src_w;
+	    conf.h=sh.src_h;
+	    conf.fourcc=sh.codec->outfmt[sh.outfmtidx];
 	    vf_prepend_filter(s,"fmtcvt",&conf);
 	    goto csp_again;
 	} else
 	if(palette==1){
 	    mpxp_v<<"vd: Trying -vf palette..."<<std::endl;
 	    palette=-1;
-	    conf.w=sh->src_w;
-	    conf.h=sh->src_h;
-	    conf.fourcc=sh->codec->outfmt[sh->outfmtidx];
+	    conf.w=sh.src_w;
+	    conf.h=sh.src_h;
+	    conf.fourcc=sh.codec->outfmt[sh.outfmtidx];
 	    vf_prepend_filter(s,"palette",&conf);
 	    goto csp_again;
 	} else {
@@ -447,45 +440,45 @@
 	    if(strcmp(vf_get_first_name(s),"fmtcvt")==0) vf_remove_first(s);
 	}
 	MSG_WARN(MSGTR_VOincompCodec);
-	priv->vfilter_inited=-1;
+	priv.vfilter_inited=-1;
 	return MPXP_False;	// failed
     }
 
-    out_fmt=sh->codec->outfmt[j];
-    sh->outfmtidx=j;
+    out_fmt=sh.codec->outfmt[j];
+    sh.outfmtidx=j;
 
     // autodetect flipping
     if(vo_conf.flip==0){
 	mpxp_context().video().output->FLIP_UNSET();
-	if(sh->codec->outflags[j]&CODECS_FLAG_FLIP)
-	    if(!(sh->codec->outflags[j]&CODECS_FLAG_NOFLIP))
+	if(sh.codec->outflags[j]&CODECS_FLAG_FLIP)
+	    if(!(sh.codec->outflags[j]&CODECS_FLAG_NOFLIP))
 		mpxp_context().video().output->FLIP_SET();
     }
     if(mpxp_context().video().output->flags&VFCAP_FLIPPED) mpxp_context().video().output->FLIP_REVERT();
     if(mpxp_context().video().output->FLIP() && !(mpxp_context().video().output->flags&VFCAP_FLIP)){
 	// we need to flip, but no flipping filter avail.
-	conf.w=sh->src_w;
-	conf.h=sh->src_h;
+	conf.w=sh.src_w;
+	conf.h=sh.src_h;
 	conf.fourcc=out_fmt;
 	vf_prepend_filter(s,"flip",&conf);
     }
 
     // time to do aspect ratio corrections...
 
-    if(vo_conf.movie_aspect>-1.0) sh->aspect = vo_conf.movie_aspect; // cmdline overrides autodetect
+    if(vo_conf.movie_aspect>-1.0) sh.aspect = vo_conf.movie_aspect; // cmdline overrides autodetect
     if(vo_conf.image_width||vo_conf.image_height){
 	screen_size_x = vo_conf.image_width;
 	screen_size_y = vo_conf.image_height;
 	if(!vo_conf.vidmode){
 	    if(!screen_size_x) screen_size_x=1;
 	    if(!screen_size_y) screen_size_y=1;
-	    if(screen_size_x<=8) screen_size_x*=sh->src_w;
-	    if(screen_size_y<=8) screen_size_y*=sh->src_h;
+	    if(screen_size_x<=8) screen_size_x*=sh.src_w;
+	    if(screen_size_y<=8) screen_size_y*=sh.src_h;
 	}
     } else {
 	// check source format aspect, calculate prescale ::atmos
-	screen_size_x=sh->src_w;
-	screen_size_y=sh->src_h;
+	screen_size_x=sh.src_w;
+	screen_size_y=sh.src_h;
 	if(vo_conf.image_zoom>=0.001){
 	    if(vo_conf.image_zoom<=8){
 	    // -xy means x+y scale
@@ -494,37 +487,37 @@
 	    } else {
 	    // -xy means forced width while keeping correct aspect
 		screen_size_x=vo_conf.image_zoom;
-		screen_size_y=vo_conf.image_zoom*sh->src_h/sh->src_w;
+		screen_size_y=vo_conf.image_zoom*sh.src_h/sh.src_w;
 	    }
 	}
-	if(sh->aspect>0.01){
+	if(sh.aspect>0.01){
 	    int _w;
-	    mpxp_v<<"Movie-Aspect is "<<sh->aspect<<":1 - prescaling to correct movie aspect."<<std::endl;
-	    _w=(int)((float)screen_size_y*sh->aspect); _w+=_w%2; // round
+	    mpxp_v<<"Movie-Aspect is "<<sh.aspect<<":1 - prescaling to correct movie aspect."<<std::endl;
+	    _w=(int)((float)screen_size_y*sh.aspect); _w+=_w%2; // round
 	    // we don't like horizontal downscale || user forced width:
 	    if(_w<screen_size_x || vo_conf.image_zoom>8){
-		screen_size_y=(int)((float)screen_size_x*(1.0/sh->aspect));
+		screen_size_y=(int)((float)screen_size_x*(1.0/sh.aspect));
 		screen_size_y+=screen_size_y%2; // round
-		if(unsigned(screen_size_y)<sh->src_h) // Do not downscale verticaly
-		    screen_size_y=sh->src_h;
+		if(unsigned(screen_size_y)<sh.src_h) // Do not downscale verticaly
+		    screen_size_y=sh.src_h;
 	    } else screen_size_x=_w; // keep new width
 	} else {
 	    mpxp_v<<"Movie-Aspect is undefined - no prescaling applied."<<std::endl;
 	}
     }
 
-    mpxp_v<<"vf->config("<<sh->src_w<<"x"<<sh->src_h<<"->"<<screen_size_x<<"x"<<screen_size_y<<",flags=0x"<<std::hex
+    mpxp_v<<"vf->config("<<sh.src_w<<"x"<<sh.src_h<<"->"<<screen_size_x<<"x"<<screen_size_y<<",flags=0x"<<std::hex
 	<<mpxp_context().video().output->flags<<",'"<<"MPlayerXP"<<"',"<<vo_format_name(out_fmt)<<std::endl;
 
-    if(vf_config(s,sh->src_w,sh->src_h,
+    if(vf_config(s,sh.src_w,sh.src_h,
 		screen_size_x,screen_size_y,
 		mpxp_context().video().output->flags,
 		out_fmt)==0){
 		    MSG_WARN(MSGTR_CannotInitVO);
-		    priv->vfilter_inited=-1;
+		    priv.vfilter_inited=-1;
 		    return MPXP_False;
     }
-    mpxp_dbg2<<"vf->config("<<sh->src_w<<"x"<<sh->src_h<<"->"<<screen_size_x<<"x"<<screen_size_y
+    mpxp_dbg2<<"vf->config("<<sh.src_w<<"x"<<sh.src_h<<"->"<<screen_size_x<<"x"<<screen_size_y
 	<<",flags="<<mpxp_context().video().output->flags<<",'"<<vo_format_name(out_fmt)<<"')"<<std::endl;
     return MPXP_True;
 }
@@ -533,20 +526,21 @@
 // mp_imgflag: buffer requirements (read/write, preserve, stride limits), see xmp_image.h
 // returns NULL or allocated mp_image_t*
 // Note: buffer allocation may be moved to mpcodecs_config_vf() later...
-mp_image_t* mpcodecs_get_image(video_decoder_t& opaque, int mp_imgtype, int mp_imgflag,int w, int h){
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    sh_video_t* sh = priv->parent;
-    vf_stream_t* s = priv->vfilter;
-    mp_image_t* mpi=vf_get_new_image(s,sh->codec->outfmt[sh->outfmtidx],mp_imgtype,mp_imgflag,w,h,dae_curr_vdecoded(mpxp_context().engine().xp_core));
+mp_image_t* VD_Interface::get_image(int mp_imgtype, int mp_imgflag,int w, int h) const {
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    sh_video_t& sh = priv.parent;
+    vf_stream_t* s = priv.vfilter;
+    mp_image_t* mpi=vf_get_new_image(s,sh.codec->outfmt[sh.outfmtidx],mp_imgtype,mp_imgflag,w,h,dae_curr_vdecoded(mpxp_context().engine().xp_core));
     mpi->x=mpi->y=0;
     if(mpi->xp_idx==XP_IDX_INVALID)
 	mpxp_v<<"[mpcodecs_get_image] Incorrect mpi->xp_idx. Be ready for segfault!"<<std::endl;
     return mpi;
 }
 
-void mpcodecs_draw_slice(video_decoder_t& opaque, mp_image_t*mpi) {
-    decvideo_priv_t* priv=reinterpret_cast<decvideo_priv_t*>(opaque.vd_private);
-    vf_stream_t* vf = priv->vfilter;
-    vf_put_slice(vf,mpi);
+void VD_Interface::draw_slice(const mp_image_t* mpi) const {
+    decvideo_priv_t& priv=reinterpret_cast<decvideo_priv_t&>(vd_private);
+    vf_stream_t* vf = priv.vfilter;
+    mp_image_t dmpi = *mpi;
+    vf_put_slice(vf,&dmpi);
 }
 } // namespace	usr
\ No newline at end of file

Modified: mplayerxp/libmpcodecs/dec_video.h
===================================================================
--- mplayerxp/libmpcodecs/dec_video.h	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/dec_video.h	2013-06-11 17:36:43 UTC (rev 652)
@@ -5,21 +5,34 @@
 
 namespace	usr {
     struct libinput_t;
+    class Video_Decoder;
+    struct vd_info_t;
+    struct put_slice_info_t;
 
-    struct video_decoder_t {
-	Opaque*	vd_private;
-    };
+    class VD_Interface : public Opaque {
+	public:
+	    VD_Interface(sh_video_t& sh_video, const std::string& codec_name,const std::string& family,int status,libinput_t&libinput);
+	    virtual ~VD_Interface();
 
-// dec_video.c:
-    video_decoder_t*	__FASTCALL__ mpcv_init(sh_video_t *sh_video, const std::string& codec_name,const std::string& family,int status,libinput_t&libinput);
-    void		__FASTCALL__ mpcv_uninit(video_decoder_t& handle);
-    int			__FASTCALL__ mpcv_decode(video_decoder_t& handle,const enc_frame_t& frame);
+	    virtual int		run(const enc_frame_t& frame) const;
 
-    MPXP_Rc		__FASTCALL__ mpcv_get_quality_max(video_decoder_t& handle,unsigned& quality);
-    MPXP_Rc		__FASTCALL__ mpcv_set_quality(video_decoder_t& handle,int quality);
-    MPXP_Rc		__FASTCALL__ mpcv_set_colors(video_decoder_t& handle,const std::string& item,int value);
-    void		__FASTCALL__ mpcv_resync_stream(video_decoder_t& handle);
+	    virtual MPXP_Rc	get_quality_max(unsigned& quality) const;
+	    virtual MPXP_Rc	set_quality(int quality) const;
+	    virtual MPXP_Rc	set_colors(const std::string& item,int value) const;
+	    virtual void	resync_stream() const;
 
-    void		vfm_help(void);
+	    virtual MPXP_Rc	config_vf(int w, int h) const;
+	    virtual mp_image_t*	get_image(int mp_imgtype, int mp_imgflag,int w, int h) const;
+	    virtual void	draw_slice(const mp_image_t*) const;
+	    virtual void	draw_image(const mp_image_t*) const;
+	    static void		print_help();
+	private:
+	    void		print_codec_info() const;
+	    void		update_subtitle(float v_pts,unsigned idx) const;
+	    const vd_info_t*	find_driver(const std::string& name);
+	    Video_Decoder*	probe_driver(sh_video_t& sh,put_slice_info_t& psi);
+
+	    Opaque&		vd_private;
+    };
 } // namepsace	usr
 #endif

Modified: mplayerxp/libmpcodecs/vd.cpp
===================================================================
--- mplayerxp/libmpcodecs/vd.cpp	2013-06-11 14:37:50 UTC (rev 651)
+++ mplayerxp/libmpcodecs/vd.cpp	2013-06-11 17:36:43 UTC (rev 652)
@@ -73,7 +73,7 @@
 	    cfg.register_options(mpcodecs_vd_drivers[i]->options);
 }
 
-const vd_info_t* vfm_find_driver(const std::string& name) {
+const vd_info_t* VD_Interface::find_driver(const std::string& name) {
     unsigned i;
     for (i=0; mpcodecs_vd_drivers[i] != &vd_null_info; i++)
 	if(name==mpcodecs_vd_drivers[i]->driver_name) {
@@ -82,13 +82,13 @@
     return NULL;
 }
 
-Video_Decoder* vfm_probe_driver(video_decoder_t& handle,sh_video_t& sh,put_slice_info_t& psi) {
+Video_Decoder* VD_Interface::probe_driver(sh_video_t& sh,put_slice_info_t& psi) {
     unsigned i;
     Video_Decoder* drv=NULL;
     for (i=0; mpcodecs_vd_drivers[i] != &vd_null_info; i++) {
 	mpxp_v<<"Probing: "<<mpcodecs_vd_drivers[i]->driver_name<<std::endl;
 	try {
-	    drv = mpcodecs_vd_drivers[i]->query_interface(handle,sh,psi,sh.fourcc);
+	    drv = mpcodecs_vd_drivers[i]->query_interface(*this,sh,psi,sh.fourcc);
 	    mpxp_v<<"ok"<<std::endl;
 	    mpxp_v<<"Driver: "<<mpcodecs_vd_drivers[i]->driver_name<<" supports these outfmt for ";
 		fourcc(mpxp_v,sh.fourcc);
@@ -110,7 +110,7 @@
     return drv;
 }
 
-void vfm_help() {
+void VD_Interface::print_help() {
     unsigned i;
     mpxp_info<<"Available video codec families/drivers:"<<st...
 
[truncated message content]