[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[601] mplayerxp
Brought to you by:
olov
Menu
▾
▴
[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[601] mplayerxp
|
From: <nic...@us...> - 2012-12-25 16:17:47
|
Revision: 601
http://mplayerxp.svn.sourceforge.net/mplayerxp/?rev=601&view=rev
Author: nickols_k
Date: 2012-12-25 16:17:37 +0000 (Tue, 25 Dec 2012)
Log Message:
-----------
minor security patches
Modified Paths:
--------------
mplayerxp/libmpcodecs/ad_faad.cpp
mplayerxp/libmpcodecs/ad_mp3.cpp
mplayerxp/libmpcodecs/ad_real.cpp
mplayerxp/libmpcodecs/codecs_ld.cpp
mplayerxp/libmpcodecs/codecs_ld.h
mplayerxp/libmpcodecs/vd_divx4.cpp
mplayerxp/libmpcodecs/vd_libmpeg2.cpp
mplayerxp/libmpcodecs/vd_real.cpp
mplayerxp/libmpcodecs/vd_xanim.cpp
mplayerxp/libmpcodecs/vd_xvid.cpp
mplayerxp/nls/mpxp_help-en.h
mplayerxp/nls/mpxp_help-ru.h
Modified: mplayerxp/libmpcodecs/ad_faad.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_faad.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/ad_faad.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -35,17 +35,7 @@
LIBAD_EXTERN(faad)
-struct faad_private_t : public Opaque {
- faad_private_t();
- virtual ~faad_private_t();
- float pts;
- sh_audio_t* sh;
- audio_filter_info_t* afi;
-};
-faad_private_t::faad_private_t() {}
-faad_private_t::~faad_private_t() {}
-
static const audio_probe_t probes[] = {
{ "faad", "libfaad"SLIBSUFFIX, 0xFF, ACodecStatus_Working, {AFMT_FLOAT32, AFMT_S24_LE, AFMT_S16_LE} },
{ "faad", "libfaad"SLIBSUFFIX, 0x4143, ACodecStatus_Working, {AFMT_FLOAT32, AFMT_S24_LE, AFMT_S16_LE} },
@@ -124,62 +114,64 @@
#endif
#endif
/* library output formats */
-#define FAAD_FMT_16BIT 1
-#define FAAD_FMT_24BIT 2
-#define FAAD_FMT_32BIT 3
-#define FAAD_FMT_FLOAT 4
-#define FAAD_FMT_FIXED FAAD_FMT_FLOAT
-#define FAAD_FMT_DOUBLE 5
+enum {
+ FAAD_FMT_16BIT=1,
+ FAAD_FMT_24BIT=2,
+ FAAD_FMT_32BIT=3,
+ FAAD_FMT_FLOAT=4,
+ FAAD_FMT_FIXED=FAAD_FMT_FLOAT,
+ FAAD_FMT_DOUBLE=5
+};
+struct faad_private_t : public Opaque {
+ faad_private_t();
+ virtual ~faad_private_t();
-static NeAACDecHandle (*NEAACDECAPI NeAACDecOpen_ptr)(unsigned);
-#define NeAACDecOpen(a) (*NeAACDecOpen_ptr)(a)
-static NeAACDecConfigurationPtr (*NEAACDECAPI NeAACDecGetCurrentConfiguration_ptr)(NeAACDecHandle hDecoder);
-#define NeAACDecGetCurrentConfiguration(a) (*NeAACDecGetCurrentConfiguration_ptr)(a)
-static unsigned char NEAACDECAPI (*NeAACDecSetConfiguration_ptr)(NeAACDecHandle hDecoder,
+ float pts;
+ sh_audio_t* sh;
+ audio_filter_info_t* afi;
+ any_t* dll_handle;
+ NeAACDecHandle (*NEAACDECAPI NeAACDecOpen_ptr)(unsigned);
+ NeAACDecConfigurationPtr (*NEAACDECAPI NeAACDecGetCurrentConfiguration_ptr)(NeAACDecHandle hDecoder);
+ unsigned char NEAACDECAPI (*NeAACDecSetConfiguration_ptr)(NeAACDecHandle hDecoder,
NeAACDecConfigurationPtr config);
-#define NeAACDecSetConfiguration(a,b) (*NeAACDecSetConfiguration_ptr)(a,b)
-static long (*NEAACDECAPI NeAACDecInit_ptr)(NeAACDecHandle hDecoder,
+ long (*NEAACDECAPI NeAACDecInit_ptr)(NeAACDecHandle hDecoder,
unsigned char *buffer,
unsigned long buffer_size,
unsigned long *samplerate,
unsigned char *channels);
-#define NeAACDecInit(a,b,c,d,e) (*NeAACDecInit_ptr)(a,b,c,d,e)
-static char (*NEAACDECAPI NeAACDecInit2_ptr)(NeAACDecHandle hDecoder, unsigned char *pBuffer,
+ char (*NEAACDECAPI NeAACDecInit2_ptr)(NeAACDecHandle hDecoder, unsigned char *pBuffer,
unsigned long SizeOfDecoderSpecificInfo,
unsigned long *samplerate, unsigned char *channels);
-#define NeAACDecInit2(a,b,c,d,e) (*NeAACDecInit2_ptr)(a,b,c,d,e)
-static void (*NEAACDECAPI NeAACDecClose_ptr)(NeAACDecHandle hDecoder);
-#define NeAACDecClose(a) (*NeAACDecClose_ptr)(a)
-static any_t* (*NEAACDECAPI NeAACDecDecode_ptr)(NeAACDecHandle hDecoder,
+ void (*NEAACDECAPI NeAACDecClose_ptr)(NeAACDecHandle hDecoder);
+ any_t* (*NEAACDECAPI NeAACDecDecode_ptr)(NeAACDecHandle hDecoder,
NeAACDecFrameInfo *hInfo,
unsigned char *buffer,
unsigned long buffer_size);
-#define NeAACDecDecode(a,b,c,d) (*NeAACDecDecode_ptr)(a,b,c,d)
-static char* (*NEAACDECAPI NeAACDecGetErrorMessage_ptr)(unsigned char errcode);
-#define NeAACDecGetErrorMessage(a) (*NeAACDecGetErrorMessage_ptr)(a)
+ char* (*NEAACDECAPI NeAACDecGetErrorMessage_ptr)(unsigned char errcode);
+ NeAACDecHandle NeAAC_hdec;
+ NeAACDecFrameInfo NeAAC_finfo;
+};
+faad_private_t::faad_private_t() {}
+faad_private_t::~faad_private_t() {
+ (*NeAACDecClose_ptr)(NeAAC_hdec);
+}
-//#define AAC_DUMP_COMPRESSED
-
-static NeAACDecHandle NeAAC_hdec;
-static NeAACDecFrameInfo NeAAC_finfo;
-
-static any_t*dll_handle;
-static MPXP_Rc load_dll(const char *libname)
+static MPXP_Rc load_dll(faad_private_t& priv,const char *libname)
{
- if(!(dll_handle=ld_codec(libname,mpcodecs_ad_faad.info->url))) return MPXP_False;
- NeAACDecOpen_ptr = (any_t* (*)(unsigned))ld_sym(dll_handle,"NeAACDecOpen");
- NeAACDecGetCurrentConfiguration_ptr = (NeAACDecConfiguration* (*)(any_t*))ld_sym(dll_handle,"NeAACDecGetCurrentConfiguration");
- NeAACDecSetConfiguration_ptr = (unsigned char (*)(any_t*,NeAACDecConfiguration*))ld_sym(dll_handle,"NeAACDecSetConfiguration");
- NeAACDecInit_ptr = (long (*)(any_t*,unsigned char*,unsigned long,unsigned long*,unsigned char*))ld_sym(dll_handle,"NeAACDecInit");
- NeAACDecInit2_ptr = (char (*)(any_t*,unsigned char *,unsigned long,unsigned long*,unsigned char*))ld_sym(dll_handle,"NeAACDecInit2");
- NeAACDecClose_ptr = (void (*)(any_t*))ld_sym(dll_handle,"NeAACDecClose");
- NeAACDecDecode_ptr = (any_t* (*)(any_t*,NeAACDecFrameInfo*,unsigned char *,unsigned long))ld_sym(dll_handle,"NeAACDecDecode");
- NeAACDecGetErrorMessage_ptr = (char* (*)(unsigned char))ld_sym(dll_handle,"NeAACDecGetErrorMessage");
- return (NeAACDecOpen_ptr && NeAACDecGetCurrentConfiguration_ptr &&
- NeAACDecInit_ptr && NeAACDecInit2_ptr && NeAACDecGetCurrentConfiguration_ptr &&
- NeAACDecClose_ptr && NeAACDecDecode_ptr && NeAACDecGetErrorMessage_ptr)?
+ if(!(priv.dll_handle=ld_codec(libname,mpcodecs_ad_faad.info->url))) return MPXP_False;
+ priv.NeAACDecOpen_ptr = (any_t* (*)(unsigned))ld_sym(priv.dll_handle,"NeAACDecOpen");
+ priv.NeAACDecGetCurrentConfiguration_ptr = (NeAACDecConfiguration* (*)(any_t*))ld_sym(priv.dll_handle,"NeAACDecGetCurrentConfiguration");
+ priv.NeAACDecSetConfiguration_ptr = (unsigned char (*)(any_t*,NeAACDecConfiguration*))ld_sym(priv.dll_handle,"NeAACDecSetConfiguration");
+ priv.NeAACDecInit_ptr = (long (*)(any_t*,unsigned char*,unsigned long,unsigned long*,unsigned char*))ld_sym(priv.dll_handle,"NeAACDecInit");
+ priv.NeAACDecInit2_ptr = (char (*)(any_t*,unsigned char *,unsigned long,unsigned long*,unsigned char*))ld_sym(priv.dll_handle,"NeAACDecInit2");
+ priv.NeAACDecClose_ptr = (void (*)(any_t*))ld_sym(priv.dll_handle,"NeAACDecClose");
+ priv.NeAACDecDecode_ptr = (any_t* (*)(any_t*,NeAACDecFrameInfo*,unsigned char *,unsigned long))ld_sym(priv.dll_handle,"NeAACDecDecode");
+ priv.NeAACDecGetErrorMessage_ptr = (char* (*)(unsigned char))ld_sym(priv.dll_handle,"NeAACDecGetErrorMessage");
+ return (priv.NeAACDecOpen_ptr && priv.NeAACDecGetCurrentConfiguration_ptr &&
+ priv.NeAACDecInit_ptr && priv.NeAACDecInit2_ptr && priv.NeAACDecGetCurrentConfiguration_ptr &&
+ priv.NeAACDecClose_ptr && priv.NeAACDecDecode_ptr && priv.NeAACDecGetErrorMessage_ptr)?
MPXP_Ok:MPXP_False;
}
@@ -191,7 +183,7 @@
faad_private_t* priv = new(zeromem) faad_private_t;
priv->sh = sh;
priv->afi = &afi;
- if(load_dll(probe.codec_dll)!=MPXP_Ok) {
+ if(load_dll(*priv,probe.codec_dll)!=MPXP_Ok) {
delete priv;
return NULL;
}
@@ -207,7 +199,7 @@
float pts;
int NeAAC_init;
NeAACDecConfigurationPtr NeAAC_conf;
- if(!(NeAAC_hdec = NeAACDecOpen(mpxp_context().mplayer_accel))) {
+ if(!(priv.NeAAC_hdec = (*priv.NeAACDecOpen_ptr)(mpxp_context().mplayer_accel))) {
MSG_WARN("FAAD: Failed to open the decoder!\n"); // XXX: deal with cleanup!
return MPXP_False;
}
@@ -217,7 +209,7 @@
sh->codecdata = (unsigned char*)(sh->wf+1);
MSG_DBG2("FAAD: codecdata extracted from WAVEFORMATEX\n");
}
- NeAAC_conf = NeAACDecGetCurrentConfiguration(NeAAC_hdec);
+ NeAAC_conf = (*priv.NeAACDecGetCurrentConfiguration_ptr)(priv.NeAAC_hdec);
if(sh->rate) NeAAC_conf->defSampleRate = sh->rate;
#ifdef WORDS_BIGENDIAN
#define NeAAC_FMT32 AFMT_S32_BE
@@ -240,28 +232,28 @@
NeAAC_conf->outputFormat=FAAD_FMT_16BIT;
}
/* Set the default object type and samplerate */
- NeAACDecSetConfiguration(NeAAC_hdec, NeAAC_conf);
+ (*priv.NeAACDecSetConfiguration_ptr)(priv.NeAAC_hdec, NeAAC_conf);
if(!sh->codecdata_len) {
sh->a_in_buffer_len = demux_read_data_r(*sh->ds, reinterpret_cast<unsigned char*>(sh->a_in_buffer), sh->a_in_buffer_size,pts);
/* init the codec */
- NeAAC_init = NeAACDecInit(NeAAC_hdec, reinterpret_cast<unsigned char*>(sh->a_in_buffer),
+ NeAAC_init = (*priv.NeAACDecInit_ptr)(priv.NeAAC_hdec, reinterpret_cast<unsigned char*>(sh->a_in_buffer),
sh->a_in_buffer_len, &NeAAC_samplerate,
&NeAAC_channels);
sh->a_in_buffer_len -= (NeAAC_init > 0)?NeAAC_init:0; // how many bytes init consumed
// XXX FIXME: shouldn't we memcpy() here in a_in_buffer ?? --A'rpi
} else { // We have ES DS in codecdata
- NeAAC_init = NeAACDecInit2(NeAAC_hdec, sh->codecdata,
+ NeAAC_init = (*priv.NeAACDecInit2_ptr)(priv.NeAAC_hdec, sh->codecdata,
sh->codecdata_len,
&NeAAC_samplerate,
&NeAAC_channels);
}
if(NeAAC_init < 0) {
MSG_WARN("FAAD: Failed to initialize the decoder!\n"); // XXX: deal with cleanup!
- NeAACDecClose(NeAAC_hdec);
+ (*priv.NeAACDecClose_ptr)(priv.NeAAC_hdec);
// XXX: mp_free a_in_buffer here or in uninit?
return MPXP_False;
} else {
- NeAAC_conf = NeAACDecGetCurrentConfiguration(NeAAC_hdec);
+ NeAAC_conf = (*priv.NeAACDecGetCurrentConfiguration_ptr)(priv.NeAAC_hdec);
sh->nch = NeAAC_channels;
sh->rate = NeAAC_samplerate;
switch(NeAAC_conf->outputFormat){
@@ -282,12 +274,7 @@
return MPXP_Ok;
}
-static void uninit(Opaque& ctx)
-{
- UNUSED(ctx);
- MSG_V("FAAD: Closing decoder!\n");
- NeAACDecClose(NeAAC_hdec);
-}
+static void uninit(Opaque& ctx) { UNUSED(ctx); }
static MPXP_Rc control_ad(Opaque& ctx,int cmd,any_t* arg, ...)
{
@@ -328,20 +315,20 @@
if(!sh->codecdata_len){
// raw aac stream:
do {
- NeAAC_sample_buffer = NeAACDecDecode(NeAAC_hdec, &NeAAC_finfo, reinterpret_cast<unsigned char *>(sh->a_in_buffer+j), sh->a_in_buffer_len);
+ NeAAC_sample_buffer = (*priv.NeAACDecDecode_ptr)(priv.NeAAC_hdec, &priv.NeAAC_finfo, reinterpret_cast<unsigned char *>(sh->a_in_buffer+j), sh->a_in_buffer_len);
/* update buffer index after NeAACDecDecode */
- if(NeAAC_finfo.bytesconsumed >= (unsigned)sh->a_in_buffer_len) {
+ if(priv.NeAAC_finfo.bytesconsumed >= (unsigned)sh->a_in_buffer_len) {
sh->a_in_buffer_len=0;
} else {
- sh->a_in_buffer_len-=NeAAC_finfo.bytesconsumed;
- memcpy(sh->a_in_buffer,&sh->a_in_buffer[NeAAC_finfo.bytesconsumed],sh->a_in_buffer_len);
- priv.pts=FIX_APTS(sh,priv.pts,NeAAC_finfo.bytesconsumed);
+ sh->a_in_buffer_len-=priv.NeAAC_finfo.bytesconsumed;
+ memcpy(sh->a_in_buffer,&sh->a_in_buffer[priv.NeAAC_finfo.bytesconsumed],sh->a_in_buffer_len);
+ priv.pts=FIX_APTS(sh,priv.pts,priv.NeAAC_finfo.bytesconsumed);
}
- if(NeAAC_finfo.error > 0) {
+ if(priv.NeAAC_finfo.error > 0) {
MSG_WARN("FAAD: error: %s, trying to resync!\n",
- NeAACDecGetErrorMessage(NeAAC_finfo.error));
+ (*priv.NeAACDecGetErrorMessage_ptr)(priv.NeAAC_finfo.error));
j++;
} else
break;
@@ -351,21 +338,21 @@
unsigned char* bufptr=NULL;
int buflen=ds_get_packet_r(*sh->ds, &bufptr,pts);
if(buflen<=0) break;
- NeAAC_sample_buffer = NeAACDecDecode(NeAAC_hdec, &NeAAC_finfo, bufptr, buflen);
+ NeAAC_sample_buffer = (*priv.NeAACDecDecode_ptr)(priv.NeAAC_hdec, &priv.NeAAC_finfo, bufptr, buflen);
// printf("NeAAC decoded %d of %d (err: %d) \n",NeAAC_finfo.bytesconsumed,buflen,NeAAC_finfo.error);
}
- if(NeAAC_finfo.error > 0) {
+ if(priv.NeAAC_finfo.error > 0) {
MSG_WARN("FAAD: Failed to decode frame: %s \n",
- NeAACDecGetErrorMessage(NeAAC_finfo.error));
- } else if (NeAAC_finfo.samples == 0) {
+ (*priv.NeAACDecGetErrorMessage_ptr)(priv.NeAAC_finfo.error));
+ } else if (priv.NeAAC_finfo.samples == 0) {
MSG_DBG2("FAAD: Decoded zero samples!\n");
} else {
/* XXX: samples already multiplied by channels! */
MSG_DBG2("FAAD: Successfully decoded frame (%d Bytes)!\n",
- afmt2bps(sh->afmt)*NeAAC_finfo.samples);
- memcpy(buf+len,NeAAC_sample_buffer, afmt2bps(sh->afmt)*NeAAC_finfo.samples);
- len += afmt2bps(sh->afmt)*NeAAC_finfo.samples;
+ afmt2bps(sh->afmt)*priv.NeAAC_finfo.samples);
+ memcpy(buf+len,NeAAC_sample_buffer, afmt2bps(sh->afmt)*priv.NeAAC_finfo.samples);
+ len += afmt2bps(sh->afmt)*priv.NeAAC_finfo.samples;
//printf("FAAD: buffer: %d bytes consumed: %d \n", k, NeAAC_finfo.bytesconsumed);
}
}
Modified: mplayerxp/libmpcodecs/ad_mp3.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_mp3.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/ad_mp3.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -176,68 +176,7 @@
MPG123_LSEEK_FAILED /**< Low-level seek failed. */
};
-static void (*mpg123_init_ptr)(void);
-#define mpg123_init() (*mpg123_init_ptr)()
-static void (*mpg123_exit_ptr)(void);
-#define mpg123_exit() (*mpg123_exit_ptr)()
-static mpg123_handle * (*mpg123_new_ptr)(const char* decoder, int *error);
-#define mpg123_new(a,b) (*mpg123_new_ptr)(a,b)
-static void (*mpg123_delete_ptr)(mpg123_handle *mh);
-#define mpg123_delete(a) (*mpg123_delete_ptr)(a)
-static const char* (*mpg123_plain_strerror_ptr)(int errcode);
-#define mpg123_plain_strerror(a) (*mpg123_plain_strerror_ptr)(a)
-static int (*mpg123_open_feed_ptr)(mpg123_handle *mh);
-#define mpg123_open_feed(a) (*mpg123_open_feed_ptr)(a)
-static int (*mpg123_close_ptr)(mpg123_handle *mh);
-#define mpg123_close(a) (*mpg123_close_ptr)(a)
-static int (*mpg123_read_ptr)(mpg123_handle *mh, unsigned char *outmemory, size_t outmemsize, size_t *done);
-#define mpg123_read(a,b,c,d) (*mpg123_read_ptr)(a,b,c,d)
-static int (*mpg123_feed_ptr)(mpg123_handle *mh, const unsigned char *in, size_t size);
-#define mpg123_feed(a,b,c) (*mpg123_feed_ptr)(a,b,c)
-static int (*mpg123_decode_ptr)(mpg123_handle *mh, const unsigned char *inmemory, size_t inmemsize,
- unsigned char *outmemory, size_t outmemsize, size_t *done);
-#define mpg123_decode(a,b,c,d,e,f) (*mpg123_decode_ptr)(a,b,c,d,e,f)
-static int (*mpg123_getformat_ptr)(mpg123_handle *mh, long *rate, int *channels, int *encoding);
-#define mpg123_getformat(a,b,c,d) (*mpg123_getformat_ptr)(a,b,c,d)
-static int (*mpg123_param_ptr)(mpg123_handle *mh, enum mpg123_parms type, long value, double fvalue);
-#define mpg123_param(a,b,c,d) (*mpg123_param_ptr)(a,b,c,d)
-static int (*mpg123_info_ptr)(mpg123_handle *mh, struct mpg123_frameinfo *mi);
-#define mpg123_info(a,b) (*mpg123_info_ptr)(a,b)
-static const char* (*mpg123_current_decoder_ptr)(mpg123_handle *mh);
-#define mpg123_current_decoder(a) (*mpg123_current_decoder_ptr)(a)
-static int (*mpg123_decode_frame_ptr)(mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes);
-#define mpg123_decode_frame(a,b,c,d) (*mpg123_decode_frame_ptr)(a,b,c,d)
-static off_t (*mpg123_tell_stream_ptr)(mpg123_handle *mh);
-#define mpg123_tell_stream(a) (*mpg123_tell_stream_ptr)(a)
-
-static any_t*dll_handle;
-static MPXP_Rc load_dll(const char *libname) {
- if(!(dll_handle=ld_codec(libname,mpcodecs_ad_mp3.info->url))) return MPXP_False;
- mpg123_init_ptr = (void (*)())ld_aliased_sym(dll_handle,"mpg123_init","mpg123_init_64");
- mpg123_exit_ptr = (void (*)())ld_aliased_sym(dll_handle,"mpg123_exit","mpg123_exit_64");
- mpg123_new_ptr = (mpg123_handle* (*)(const char*,int*))ld_aliased_sym(dll_handle,"mpg123_new","mpg123_new_64");
- mpg123_delete_ptr = (void (*)(mpg123_handle*))ld_aliased_sym(dll_handle,"mpg123_delete","mpg123_delete_64");
- mpg123_plain_strerror_ptr = (const char* (*)(int))ld_aliased_sym(dll_handle,"mpg123_plain_strerror","mpg123_plain_strerror_64");
- mpg123_open_feed_ptr = (int (*)(mpg123_handle*))ld_aliased_sym(dll_handle,"mpg123_open_feed","mpg123_open_feed_64");
- mpg123_close_ptr = (int (*)(mpg123_handle*))ld_aliased_sym(dll_handle,"mpg123_close","mpg123_close_64");
- mpg123_getformat_ptr = (int (*)(mpg123_handle*,long*,int*,int*))ld_aliased_sym(dll_handle,"mpg123_getformat","mpg123_getformat_64");
- mpg123_param_ptr = (int (*)(mpg123_handle*,mpg123_parms,long,double))ld_aliased_sym(dll_handle,"mpg123_param","mpg123_param_64");
- mpg123_info_ptr = (int (*)(mpg123_handle*,mpg123_frameinfo*))ld_aliased_sym(dll_handle,"mpg123_info","mpg123_info_64");
- mpg123_current_decoder_ptr = (const char* (*)(mpg123_handle*))ld_aliased_sym(dll_handle,"mpg123_current_decoder","mpg123_current_decoder_64");
- mpg123_decode_ptr = (int (*)(mpg123_handle*,const unsigned char*,size_t,unsigned char*,size_t,size_t*))ld_aliased_sym(dll_handle,"mpg123_decode","mpg123_decode_64");
- mpg123_read_ptr = (int (*)(mpg123_handle*,unsigned char*,size_t,size_t*))ld_aliased_sym(dll_handle,"mpg123_read","mpg123_read_64");
- mpg123_feed_ptr = (int (*)(mpg123_handle*,const unsigned char*,size_t))ld_aliased_sym(dll_handle,"mpg123_feed","mpg123_feed_64");
- mpg123_tell_stream_ptr = (off_t (*)(mpg123_handle*))ld_aliased_sym(dll_handle,"mpg123_tell_stream","mpg123_tell_stream_64");
- mpg123_decode_frame_ptr = (int (*)(mpg123_handle*,off_t*,unsigned char**,size_t*))ld_aliased_sym(dll_handle,"mpg123_decode_frame","mpg123_decode_frame_64");
- return (mpg123_decode_ptr && mpg123_init_ptr && mpg123_exit_ptr &&
- mpg123_new_ptr && mpg123_delete_ptr && mpg123_plain_strerror_ptr &&
- mpg123_open_feed_ptr && mpg123_close_ptr && mpg123_getformat_ptr &&
- mpg123_param_ptr && mpg123_info_ptr && mpg123_current_decoder_ptr &&
- mpg123_read_ptr && mpg123_feed_ptr && mpg123_decode_frame_ptr && mpg123_tell_stream_ptr)?
- MPXP_Ok:MPXP_False;
-}
-
struct mp3_private_t : public Opaque {
mp3_private_t();
virtual ~mp3_private_t();
@@ -246,16 +185,62 @@
off_t pos;
float pts;
sh_audio_t* sh;
+ any_t* dll_handle;
+ void (*mpg123_init_ptr)(void);
+ void (*mpg123_exit_ptr)(void);
+ mpg123_handle * (*mpg123_new_ptr)(const char* decoder, int *error);
+ void (*mpg123_delete_ptr)(mpg123_handle *mh);
+
+ const char* (*mpg123_plain_strerror_ptr)(int errcode);
+ int (*mpg123_open_feed_ptr)(mpg123_handle *mh);
+ int (*mpg123_close_ptr)(mpg123_handle *mh);
+ int (*mpg123_read_ptr)(mpg123_handle *mh, unsigned char *outmemory, size_t outmemsize, size_t *done);
+ int (*mpg123_feed_ptr)(mpg123_handle *mh, const unsigned char *in, size_t size);
+ int (*mpg123_decode_ptr)(mpg123_handle *mh, const unsigned char *inmemory, size_t inmemsize,
+ unsigned char *outmemory, size_t outmemsize, size_t *done);
+ int (*mpg123_getformat_ptr)(mpg123_handle *mh, long *rate, int *channels, int *encoding);
+ int (*mpg123_param_ptr)(mpg123_handle *mh, enum mpg123_parms type, long value, double fvalue);
+ int (*mpg123_info_ptr)(mpg123_handle *mh, struct mpg123_frameinfo *mi);
+ const char* (*mpg123_current_decoder_ptr)(mpg123_handle *mh);
+ int (*mpg123_decode_frame_ptr)(mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes);
+ off_t (*mpg123_tell_stream_ptr)(mpg123_handle *mh);
};
mp3_private_t::mp3_private_t() {}
mp3_private_t::~mp3_private_t() {
if(mh) {
- mpg123_close(mh);
- mpg123_delete(mh);
- mpg123_exit();
+ (*mpg123_close_ptr)(mh);
+ (*mpg123_delete_ptr)(mh);
+ (*mpg123_exit_ptr)();
}
+ if(dll_handle) ::dlclose(dll_handle);
}
+static MPXP_Rc load_dll(mp3_private_t& priv,const char *libname) {
+ if(!(priv.dll_handle=ld_codec(libname,mpcodecs_ad_mp3.info->url))) return MPXP_False;
+ priv.mpg123_init_ptr = (void (*)())ld_aliased_sym(priv.dll_handle,"mpg123_init","mpg123_init_64");
+ priv.mpg123_exit_ptr = (void (*)())ld_aliased_sym(priv.dll_handle,"mpg123_exit","mpg123_exit_64");
+ priv.mpg123_new_ptr = (mpg123_handle* (*)(const char*,int*))ld_aliased_sym(priv.dll_handle,"mpg123_new","mpg123_new_64");
+ priv.mpg123_delete_ptr = (void (*)(mpg123_handle*))ld_aliased_sym(priv.dll_handle,"mpg123_delete","mpg123_delete_64");
+ priv.mpg123_plain_strerror_ptr = (const char* (*)(int))ld_aliased_sym(priv.dll_handle,"mpg123_plain_strerror","mpg123_plain_strerror_64");
+ priv.mpg123_open_feed_ptr = (int (*)(mpg123_handle*))ld_aliased_sym(priv.dll_handle,"mpg123_open_feed","mpg123_open_feed_64");
+ priv.mpg123_close_ptr = (int (*)(mpg123_handle*))ld_aliased_sym(priv.dll_handle,"mpg123_close","mpg123_close_64");
+ priv.mpg123_getformat_ptr = (int (*)(mpg123_handle*,long*,int*,int*))ld_aliased_sym(priv.dll_handle,"mpg123_getformat","mpg123_getformat_64");
+ priv.mpg123_param_ptr = (int (*)(mpg123_handle*,mpg123_parms,long,double))ld_aliased_sym(priv.dll_handle,"mpg123_param","mpg123_param_64");
+ priv.mpg123_info_ptr = (int (*)(mpg123_handle*,mpg123_frameinfo*))ld_aliased_sym(priv.dll_handle,"mpg123_info","mpg123_info_64");
+ priv.mpg123_current_decoder_ptr = (const char* (*)(mpg123_handle*))ld_aliased_sym(priv.dll_handle,"mpg123_current_decoder","mpg123_current_decoder_64");
+ priv.mpg123_decode_ptr = (int (*)(mpg123_handle*,const unsigned char*,size_t,unsigned char*,size_t,size_t*))ld_aliased_sym(priv.dll_handle,"mpg123_decode","mpg123_decode_64");
+ priv.mpg123_read_ptr = (int (*)(mpg123_handle*,unsigned char*,size_t,size_t*))ld_aliased_sym(priv.dll_handle,"mpg123_read","mpg123_read_64");
+ priv.mpg123_feed_ptr = (int (*)(mpg123_handle*,const unsigned char*,size_t))ld_aliased_sym(priv.dll_handle,"mpg123_feed","mpg123_feed_64");
+ priv.mpg123_tell_stream_ptr = (off_t (*)(mpg123_handle*))ld_aliased_sym(priv.dll_handle,"mpg123_tell_stream","mpg123_tell_stream_64");
+ priv.mpg123_decode_frame_ptr = (int (*)(mpg123_handle*,off_t*,unsigned char**,size_t*))ld_aliased_sym(priv.dll_handle,"mpg123_decode_frame","mpg123_decode_frame_64");
+ return (priv.mpg123_decode_ptr && priv.mpg123_init_ptr && priv.mpg123_exit_ptr &&
+ priv.mpg123_new_ptr && priv.mpg123_delete_ptr && priv.mpg123_plain_strerror_ptr &&
+ priv.mpg123_open_feed_ptr && priv.mpg123_close_ptr && priv.mpg123_getformat_ptr &&
+ priv.mpg123_param_ptr && priv.mpg123_info_ptr && priv.mpg123_current_decoder_ptr &&
+ priv.mpg123_read_ptr && priv.mpg123_feed_ptr && priv.mpg123_decode_frame_ptr && priv.mpg123_tell_stream_ptr)?
+ MPXP_Ok:MPXP_False;
+}
+
static const audio_probe_t probes[] = {
{ "mp3lib", "libmpg123"SLIBSUFFIX, 0x50, ACodecStatus_Working, {AFMT_FLOAT32, AFMT_S16_LE} },
{ "mp3lib", "libmpg123"SLIBSUFFIX, 0x55, ACodecStatus_Working, {AFMT_FLOAT32, AFMT_S16_LE} },
@@ -280,8 +265,8 @@
{
UNUSED(afi);
sh->audio_out_minsize=9216;
- if(load_dll(probe.codec_dll)!=MPXP_Ok) return NULL;
mp3_private_t* priv = new(zeromem) mp3_private_t;
+ if(load_dll(*priv,probe.codec_dll)!=MPXP_Ok) { delete priv; return NULL; }
priv->sh = sh;
return priv;
}
@@ -298,40 +283,40 @@
struct mpg123_frameinfo fi;
sh_audio_t* sh = priv.sh;
sh->afmt=AFMT_FLOAT32;
- mpg123_init();
- priv.mh = mpg123_new(NULL,&err);
+ (*priv.mpg123_init_ptr)();
+ priv.mh = (*priv.mpg123_new_ptr)(NULL,&err);
if(err) {
err_exit:
- MSG_ERR("mpg123_init: %s\n",mpg123_plain_strerror(err));
- if(priv.mh) mpg123_delete(priv.mh);
- mpg123_exit();
+ MSG_ERR("mpg123_init: %s\n",(*priv.mpg123_plain_strerror_ptr)(err));
+ if(priv.mh) (*priv.mpg123_delete_ptr)(priv.mh);
+ (*priv.mpg123_exit_ptr)();
return MPXP_False;
}
- if((err=mpg123_open_feed(priv.mh))!=0) goto err_exit;
+ if((err=(*priv.mpg123_open_feed_ptr)(priv.mh))!=0) goto err_exit;
param = MPG123_FORCE_STEREO|MPG123_FORCE_FLOAT;
if(!mp_conf.verbose) param|=MPG123_QUIET;
- mpg123_param(priv.mh,MPG123_FLAGS,param,0);
+ (*priv.mpg123_param_ptr)(priv.mh,MPG123_FLAGS,param,0);
// Decode first frame (to get header filled)
err=MPG123_NEED_MORE;
len=0;
while(err==MPG123_NEED_MORE) {
indata_size=ds_get_packet_r(*sh->ds,&indata,pts);
- mpg123_feed(priv.mh,indata,indata_size);
- err=mpg123_read(priv.mh,reinterpret_cast<unsigned char*>(sh->a_buffer),sh->a_buffer_size,&done);
+ (*priv.mpg123_feed_ptr)(priv.mh,indata,indata_size);
+ err=(*priv.mpg123_read_ptr)(priv.mh,reinterpret_cast<unsigned char*>(sh->a_buffer),sh->a_buffer_size,&done);
len+=done;
}
sh->a_buffer_len=len;
if(err!=MPG123_NEW_FORMAT) {
- MSG_ERR("mpg123_init: within [%d] can't retrieve stream property: %s\n",indata_size,mpg123_plain_strerror(err));
- mpg123_close(priv.mh);
- mpg123_delete(priv.mh);
- mpg123_exit();
+ MSG_ERR("mpg123_init: within [%d] can't retrieve stream property: %s\n",indata_size,(*priv.mpg123_plain_strerror_ptr)(err));
+ (*priv.mpg123_close_ptr)(priv.mh);
+ (*priv.mpg123_delete_ptr)(priv.mh);
+ (*priv.mpg123_exit_ptr)();
return MPXP_False;
}
- mpg123_getformat(priv.mh, &rate, &nch, &enc);
+ (*priv.mpg123_getformat_ptr)(priv.mh, &rate, &nch, &enc);
sh->rate = rate;
sh->nch = nch;
- mpg123_info(priv.mh,&fi);
+ (*priv.mpg123_info_ptr)(priv.mh,&fi);
sh->i_bps=((fi.abr_rate?fi.abr_rate:fi.bitrate)/8)*1000;
// Prints first frame header in ascii.
static const char *modes[4] = { "Stereo", "Joint-Stereo", "Dual-Channel", "Mono" };
@@ -352,16 +337,11 @@
,fi.flags&MPG123_ORIGINAL?"Yes":"No"
,fi.flags&MPG123_CRC?"Yes":"No"
,fi.flags&MPG123_PRIVATE?"Yes":"No"
- ,fi.emphasis,mpg123_current_decoder(priv.mh));
+ ,fi.emphasis,(*priv.mpg123_current_decoder_ptr)(priv.mh));
return MPXP_Ok;
}
-void uninit(Opaque& ctx)
-{
- UNUSED(ctx);
- if(dll_handle) dlclose(dll_handle);
- dll_handle=NULL;
-}
+void uninit(Opaque& ctx) { UNUSED(ctx); }
MPXP_Rc control_ad(Opaque& ctx,int cmd,any_t* arg, ...)
{
@@ -395,11 +375,11 @@
*/
MSG_DBG2("mp3_decode start: pts=%f\n",pts);
do {
- cpos = mpg123_tell_stream(priv.mh);
+ cpos = (*priv.mpg123_tell_stream_ptr)(priv.mh);
pts = priv.pts+((float)(cpos-priv.pos)/sh->i_bps);
- err=mpg123_decode_frame(priv.mh,&offset,&outdata,&done);
+ err=(*priv.mpg123_decode_frame_ptr)(priv.mh,&offset,&outdata,&done);
if(!((err==MPG123_OK)||(err==MPG123_NEED_MORE))) {
- MSG_ERR("mpg123_read = %s done = %u minlen = %u\n",mpg123_plain_strerror(err),done,minlen);
+ MSG_ERR("mpg123_read = %s done = %u minlen = %u\n",(*priv.mpg123_plain_strerror_ptr)(err),done,minlen);
}
if(err==MPG123_OK) {
MSG_DBG2("ad_mp3.decode: copy %u bytes from %p\n",done,outdata);
@@ -409,9 +389,9 @@
float apts=0.;
indata_size=ds_get_packet_r(*sh->ds,&indata,apts);
if(indata_size<0) return 0;
- priv.pos = mpg123_tell_stream(priv.mh);
+ priv.pos = (*priv.mpg123_tell_stream_ptr)(priv.mh);
priv.pts = apts;
- mpg123_feed(priv.mh,indata,indata_size);
+ (*priv.mpg123_feed_ptr)(priv.mh,indata,indata_size);
}
}while(err==MPG123_NEED_MORE);
MSG_DBG2("mp3_decode: %i->%i [%i...%i] pts=%f\n",indata_size,done,minlen,maxlen,pts);
Modified: mplayerxp/libmpcodecs/ad_real.cpp
===================================================================
--- mplayerxp/libmpcodecs/ad_real.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/ad_real.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -28,34 +28,6 @@
LIBAD_EXTERN(real)
-
-static any_t*handle=NULL;
-
-any_t*__builtin_new(unsigned long size) {
- return mp_malloc(size);
-}
-
-/* required for cook's uninit: */
-void __builtin_delete(any_t* ize) {
- delete ize;
-}
-
-#if defined(__FreeBSD__) || defined(__NetBSD__)
-any_t* __ctype_b=NULL;
-#endif
-
-static uint32_t (*raCloseCodec)(uint32_t);
-static uint32_t (*raDecode)(any_t*,any_t*,uint32_t,any_t*,any_t*,uint32_t);
-static uint32_t (*raFreeDecoder)(uint32_t);
-static any_t* (*raGetFlavorProperty)(any_t*,uint32_t,uint32_t,any_t*);
-//static uint32_t (*raGetNumberOfFlavors2)(void);
-static uint32_t (*raInitDecoder)(any_t*,any_t*);
-static uint32_t (*raOpenCodec2)(any_t*,any_t*);
-static uint32_t (*raOpenCodec)(any_t*);
-static uint32_t (*raSetFlavor)(any_t*,uint32_t);
-static void (*raSetDLLAccessPath)(uint32_t);
-static void (*raSetPwd)(char*,char*);
-
typedef struct {
int samplerate;
short bits;
@@ -75,11 +47,23 @@
any_t*internal;
float pts;
sh_audio_t* sh;
+ any_t* handle;
+ uint32_t (*raCloseCodec)(uint32_t);
+ uint32_t (*raDecode)(any_t*,any_t*,uint32_t,any_t*,any_t*,uint32_t);
+ uint32_t (*raFreeDecoder)(uint32_t);
+ any_t* (*raGetFlavorProperty)(any_t*,uint32_t,uint32_t,any_t*);
+ uint32_t (*raInitDecoder)(any_t*,any_t*);
+ uint32_t (*raOpenCodec2)(any_t*,any_t*);
+ uint32_t (*raOpenCodec)(any_t*);
+ uint32_t (*raSetFlavor)(any_t*,uint32_t);
+ void (*raSetDLLAccessPath)(uint32_t);
+ void (*raSetPwd)(char*,char*);
};
areal_private_t::areal_private_t() {}
areal_private_t::~areal_private_t() {
if (raFreeDecoder) raFreeDecoder(long(internal));
if (raCloseCodec) raCloseCodec(long(internal));
+ if(handle) ::dlclose(handle);
}
static const audio_probe_t probes[] = {
@@ -99,24 +83,24 @@
return NULL;
}
-static MPXP_Rc load_dll(const char* name)
+static MPXP_Rc load_dll(areal_private_t& priv,const char* name)
{
- if(!(handle = dlopen (name, RTLD_LAZY))) return MPXP_False;
+ if(!(priv.handle = ::dlopen (name, RTLD_LAZY))) return MPXP_False;
- raCloseCodec = (uint32_t (*)(uint32_t))ld_sym(handle, "RACloseCodec");
- raDecode = (uint32_t (*)(any_t*,any_t*,uint32_t,any_t*,any_t*,uint32_t))ld_sym(handle, "RADecode");
- raFreeDecoder = (uint32_t (*)(uint32_t))ld_sym(handle, "RAFreeDecoder");
- raGetFlavorProperty = (any_t* (*)(any_t*,uint32_t,uint32_t,any_t*))ld_sym(handle, "RAGetFlavorProperty");
- raOpenCodec = (uint32_t (*)(any_t*))ld_sym(handle, "RAOpenCodec");
- raOpenCodec2 = (uint32_t (*)(any_t*,any_t*))ld_sym(handle, "RAOpenCodec2");
- raInitDecoder = (uint32_t (*)(any_t*,any_t*))ld_sym(handle, "RAInitDecoder");
- raSetFlavor = (uint32_t (*)(any_t*,uint32_t))ld_sym(handle, "RASetFlavor");
- raSetDLLAccessPath = (void (*)(uint32_t))ld_sym(handle, "SetDLLAccessPath");
- raSetPwd = (void (*)(char*,char*))ld_sym(handle, "RASetPwd"); /* optional, used by SIPR */
+ priv.raCloseCodec = (uint32_t (*)(uint32_t))ld_sym(priv.handle, "RACloseCodec");
+ priv.raDecode = (uint32_t (*)(any_t*,any_t*,uint32_t,any_t*,any_t*,uint32_t))ld_sym(priv.handle, "RADecode");
+ priv.raFreeDecoder = (uint32_t (*)(uint32_t))ld_sym(priv.handle, "RAFreeDecoder");
+ priv.raGetFlavorProperty = (any_t* (*)(any_t*,uint32_t,uint32_t,any_t*))ld_sym(priv.handle, "RAGetFlavorProperty");
+ priv.raOpenCodec = (uint32_t (*)(any_t*))ld_sym(priv.handle, "RAOpenCodec");
+ priv.raOpenCodec2 = (uint32_t (*)(any_t*,any_t*))ld_sym(priv.handle, "RAOpenCodec2");
+ priv.raInitDecoder = (uint32_t (*)(any_t*,any_t*))ld_sym(priv.handle, "RAInitDecoder");
+ priv.raSetFlavor = (uint32_t (*)(any_t*,uint32_t))ld_sym(priv.handle, "RASetFlavor");
+ priv.raSetDLLAccessPath = (void (*)(uint32_t))ld_sym(priv.handle, "SetDLLAccessPath");
+ priv.raSetPwd = (void (*)(char*,char*))ld_sym(priv.handle, "RASetPwd"); /* optional, used by SIPR */
- return (raCloseCodec && raDecode && raFreeDecoder &&
- raGetFlavorProperty && (raOpenCodec2||raOpenCodec) && raSetFlavor &&
- raInitDecoder)?MPXP_Ok:MPXP_False;
+ return (priv.raCloseCodec && priv.raDecode && priv.raFreeDecoder &&
+ priv.raGetFlavorProperty && (priv.raOpenCodec2||priv.raOpenCodec) && priv.raSetFlavor &&
+ priv.raInitDecoder)?MPXP_Ok:MPXP_False;
}
static Opaque* preinit(const audio_probe_t& probe,sh_audio_t *sh,audio_filter_info_t& afi){
@@ -128,9 +112,8 @@
any_t* prop;
char path[4096];
char cpath[4096];
- areal_private_t *priv;
- if(load_dll(probe.codec_dll)!=MPXP_Ok) return NULL;
- priv=new(zeromem) areal_private_t;
+ areal_private_t *priv=new(zeromem) areal_private_t;
+ if(load_dll(*priv,probe.codec_dll)!=MPXP_Ok) { delete priv; return NULL; }
priv->sh = sh;
char *end;
@@ -145,14 +128,14 @@
}
path[strlen(path)+1]=0;
- if(raSetDLLAccessPath)
- raSetDLLAccessPath(long(path));
+ if(priv->raSetDLLAccessPath)
+ (*priv->raSetDLLAccessPath)(long(path));
- if(raOpenCodec2) {
+ if(priv->raOpenCodec2) {
strcat(cpath,"/");
- result=raOpenCodec2(&priv->internal,cpath);
+ result=(*priv->raOpenCodec2)(&priv->internal,cpath);
}
- else result=raOpenCodec(&priv->internal);
+ else result=(*priv->raOpenCodec)(&priv->internal);
if(result){
MSG_WARN("Decoder open failed, error code: 0x%X\n",result);
delete priv;
@@ -173,35 +156,35 @@
((short*)(sh->wf+1))[4], // codec data length
((char*)(sh->wf+1))+10 // extras
};
- result=raInitDecoder(priv->internal,&init_data);
+ result=(*priv->raInitDecoder)(priv->internal,&init_data);
if(result){
MSG_WARN("Decoder init failed, error code: 0x%X\n",result);
delete priv;
return NULL;
}
- if(raSetPwd){
+ if(priv->raSetPwd){
// used by 'SIPR'
- raSetPwd(reinterpret_cast<char*>(priv->internal),const_cast<char*>("Ardubancel Quazanga")); // set password... lol.
+ (*priv->raSetPwd)(reinterpret_cast<char*>(priv->internal),const_cast<char*>("Ardubancel Quazanga")); // set password... lol.
}
- result=raSetFlavor(priv->internal,((short*)(sh->wf+1))[2]);
+ result=(*priv->raSetFlavor)(priv->internal,((short*)(sh->wf+1))[2]);
if(result){
MSG_WARN("Decoder flavor setup failed, error code: 0x%X\n",result);
delete priv;
return NULL;
}
- prop=raGetFlavorProperty(priv->internal,((short*)(sh->wf+1))[2],0,&len);
+ prop=(*priv->raGetFlavorProperty)(priv->internal,((short*)(sh->wf+1))[2],0,&len);
MSG_INFO("Audio codec: [%d] %s\n",((short*)(sh->wf+1))[2],prop);
- prop=raGetFlavorProperty(priv->internal,((short*)(sh->wf+1))[2],1,&len);
+ prop=(*priv->raGetFlavorProperty)(priv->internal,((short*)(sh->wf+1))[2],1,&len);
if(prop){
sh->i_bps=((*((int*)prop))+4)/8;
MSG_INFO("Audio bitrate: %5.3f kbit/s (%d bps) \n",(*((int*)prop))*0.001f,sh->i_bps);
} else sh->i_bps=sh->wf->nAvgBytesPerSec;
-// prop=raGetFlavorProperty(priv->internal,((short*)(sh->wf+1))[2],0x13,&len);
+// prop=(*priv->raGetFlavorProperty)(priv->internal,((short*)(sh->wf+1))[2],0x13,&len);
// MSG_INFO("Samples/block?: %d \n",(*((int*)prop)));
sh->audio_out_minsize=128000; // no idea how to get... :(
@@ -292,7 +275,7 @@
}
else pts=priv.pts;
- result=raDecode(priv.internal, sh->a_in_buffer+sh->a_in_buffer_size-sh->a_in_buffer_len, sh->wf->nBlockAlign,
+ result=(*priv.raDecode)(priv.internal, sh->a_in_buffer+sh->a_in_buffer_size-sh->a_in_buffer_len, sh->wf->nBlockAlign,
buf, &len, -1);
if((int)len<0) len=0;
sh->a_in_buffer_len-=sh->wf->nBlockAlign;
Modified: mplayerxp/libmpcodecs/codecs_ld.cpp
===================================================================
--- mplayerxp/libmpcodecs/codecs_ld.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/codecs_ld.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -13,17 +13,17 @@
#include "mpxp_help.h"
#include "global_msg.h"
-any_t* ld_codec(const char *name,const char *url_hint)
+namespace mpxp {
+any_t* ld_codec(const std::string& name,const std::string& url_hint)
{
- any_t*dll_handle;
- if(!(dll_handle=dlopen(name,RTLD_LAZY|RTLD_GLOBAL)))
- {
- MSG_FATAL(MSGTR_CODEC_CANT_LOAD_DLL,name,dlerror());
- if(url_hint) MSG_HINT(MSGTR_CODEC_DLL_HINT,url_hint);
- return NULL;
- }
- MSG_V(MSGTR_CODEC_DLL_OK,name);
- return dll_handle;
+ any_t*dll_handle;
+ if(!(dll_handle=::dlopen(name.c_str(),RTLD_LAZY|RTLD_GLOBAL))) {
+ mpxp_fatal<<"[codec_ld] "<<MSGTR_CODEC_CANT_LOAD_DLL<<":"<<name<<" {"<<dlerror()<<"}"<<std::endl;
+ if(!url_hint.empty()) mpxp_hint<<"[codec_ld] "<<MSGTR_CODEC_DLL_HINT<<":"<<url_hint<<std::endl;
+ return NULL;
+ }
+ mpxp_v<<"[codec_ld] "<<MSGTR_CODEC_DLL_OK<<":"<<name<<std::endl;
+ return dll_handle;
}
#if 0
@@ -37,29 +37,30 @@
}
#endif
-any_t* ld_sym(any_t*handle,const char *sym_name)
+any_t* ld_sym(any_t*handle,const std::string& sym_name)
{
- any_t*rval;
- if(!(rval=dlsym(handle,sym_name))) {
- MSG_ERR(MSGTR_CODEC_DLL_SYM_ERR,sym_name);
- }
- return rval;
+ any_t*rval;
+ if(!(rval=::dlsym(handle,sym_name.c_str()))) {
+ mpxp_err<<"[codec_ld] "<<MSGTR_CODEC_DLL_SYM_ERR<<":"<<sym_name<<std::endl;
+ }
+ return rval;
}
-any_t* ld_aliased_sym(any_t*handle,const char *sym_name,...)
+any_t* ld_aliased_sym(any_t*handle,const std::string& sym_name,...)
{
- any_t*rval=dlsym(handle,sym_name);
- if(!rval) {
- const char *alias;
- va_list list;
- va_start( list, sym_name );
- do {
- alias = va_arg(list, const char *);
- if(alias) rval = dlsym(handle,alias);
- if(rval) break;
- }while(alias);
- va_end( list );
- }
- if(!rval) MSG_ERR(MSGTR_CODEC_DLL_SYM_ERR,sym_name);
- return rval;
+ any_t*rval=::dlsym(handle,sym_name.c_str());
+ if(!rval) {
+ const char *alias;
+ va_list list;
+ va_start( list, sym_name );
+ do {
+ alias = va_arg(list, const char *);
+ if(alias) rval = ::dlsym(handle,alias);
+ if(rval) break;
+ }while(alias);
+ va_end( list );
+ }
+ if(!rval) mpxp_err<<"[codec_ld] "<<MSGTR_CODEC_DLL_SYM_ERR<<":"<<sym_name<<std::endl;
+ return rval;
}
+} // namespace mpxp
Modified: mplayerxp/libmpcodecs/codecs_ld.h
===================================================================
--- mplayerxp/libmpcodecs/codecs_ld.h 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/codecs_ld.h 2012-12-25 16:17:37 UTC (rev 601)
@@ -1,18 +1,15 @@
/*
codecs_ld - light interface to codec loader
*/
-
#ifndef __CODECS_LD
#define __CODECS_LD
-
#include "mpxp_config.h"
+#include <string>
-extern any_t* ld_codec(const char *name,const char *url_hint);
-/*extern char * codec_name( const char *name );*/
-
-extern any_t* ld_sym(any_t*handle,const char *sym_name);
-extern any_t* ld_aliased_sym(any_t*handle,const char *sym_name,...);
-#if defined(__OpenBSD__) && !defined(__ELF__)
-#define dlsym(h,s) ld_sym(h, "_" s)
+namespace mpxp {
+ extern any_t* ld_codec(const std::string& name,const std::string& url_hint);
+/* extern char * codec_name( const char *name );*/
+ extern any_t* ld_sym(any_t*handle,const std::string& sym_name);
+ extern any_t* ld_aliased_sym(any_t*handle,const std::string& sym_name,...);
+} // namespace mpxp
#endif
-#endif
Modified: mplayerxp/libmpcodecs/vd_divx4.cpp
===================================================================
--- mplayerxp/libmpcodecs/vd_divx4.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/vd_divx4.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -142,15 +142,15 @@
int resync;
sh_video_t* sh;
video_decoder_t* parent;
+ any_t* dll_handle;
+ LibQDecoreFunction* (*getDecore_ptr)(unsigned long format);
};
divx4_private_t::divx4_private_t() {}
divx4_private_t::~divx4_private_t() {
- decoder(pHandle, DEC_OPT_RELEASE, 0, 0);
+ if(pHandle) decoder(pHandle, DEC_OPT_RELEASE, 0, 0);
+ if(dll_handle) ::dlclose(dll_handle);
}
-static LibQDecoreFunction* (*getDecore_ptr)(unsigned long format);
-static any_t*dll_handle;
-
static const video_probe_t probes[] = {
{ "divx", "libdivx"SLIBSUFFIX,FOURCC_TAG('D','Y','U','V'), VCodecStatus_Working, {IMGFMT_YV12, IMGFMT_I420}, {VideoFlag_None, VideoFlag_None } },
{ "divx", "libdivx"SLIBSUFFIX,FOURCC_TAG('D','I','V','3'), VCodecStatus_Working, {IMGFMT_YV12, IMGFMT_I420}, {VideoFlag_None, VideoFlag_None } },
@@ -174,7 +174,6 @@
// to set/get/query special features/parameters
static MPXP_Rc control_vd(Opaque& ctx,int cmd,any_t* arg,...){
divx4_private_t& priv=static_cast<divx4_private_t&>(ctx);
- sh_video_t* sh = priv.sh;
switch(cmd){
case VDCTRL_QUERY_MAX_PP_LEVEL:
*((unsigned*)arg)=100;
@@ -215,17 +214,17 @@
}
-static int load_lib( const char *libname )
+static int load_lib(divx4_private_t& priv, const char *libname )
{
- if(!(dll_handle=ld_codec(libname,mpcodecs_vd_divx4.info->url))) return 0;
- getDecore_ptr = (LibQDecoreFunction* (*)(unsigned long))ld_sym(dll_handle,"getDecore");
- return getDecore_ptr != NULL;
+ if(!(priv.dll_handle=ld_codec(libname,mpcodecs_vd_divx4.info->url))) return 0;
+ priv.getDecore_ptr = (LibQDecoreFunction* (*)(unsigned long))ld_sym(priv.dll_handle,"getDecore");
+ return priv.getDecore_ptr != NULL;
}
static Opaque* preinit(const video_probe_t& probe,sh_video_t *sh,put_slice_info_t& psi){
UNUSED(psi);
- if(!load_lib(probe.codec_dll)) return NULL;
divx4_private_t* priv = new(zeromem) divx4_private_t;
+ if(!load_lib(*priv,probe.codec_dll)) { delete priv; return NULL; }
priv->sh=sh;
return priv;
}
@@ -246,7 +245,7 @@
MSG_ERR("Unsupported out_fmt: 0x%X\n",sh->codec->outfmt[sh->outfmtidx]);
return MPXP_False;
}
- if(!(priv.decoder=getDecore_ptr(sh->fourcc))) {
+ if(!(priv.decoder=priv.getDecore_ptr(sh->fourcc))) {
char *fcc=(char *)&(sh->fourcc);
MSG_ERR("Can't find decoder for %c%c%c%c fourcc\n",fcc[0],fcc[1],fcc[2],fcc[3]);
return MPXP_False;
@@ -270,10 +269,7 @@
}
// uninit driver
-static void uninit(Opaque& ctx){
- UNUSED(ctx);
- dlclose(dll_handle);
-}
+static void uninit(Opaque& ctx){ UNUSED(ctx); }
// decode a frame
static mp_image_t* decode(Opaque& ctx,const enc_frame_t& frame){
Modified: mplayerxp/libmpcodecs/vd_libmpeg2.cpp
===================================================================
--- mplayerxp/libmpcodecs/vd_libmpeg2.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/vd_libmpeg2.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -205,23 +205,6 @@
STATE_SEQUENCE_MODIFIED = 11
} mpeg2_state_t;
-static mpeg2dec_t* (*mpeg2_init_ptr) (unsigned);
-#define mpeg2_init(a) (*mpeg2_init_ptr)(a)
-static void (*mpeg2_close_ptr) (mpeg2dec_t * mpeg2dec);
-#define mpeg2_close(a) (*mpeg2_close_ptr)(a)
-static const mpeg2_info_t * (*mpeg2_info_ptr) (mpeg2dec_t * mpeg2dec);
-#define mpeg2_info(a) (*mpeg2_info_ptr)(a)
-static int (*mpeg2_parse_ptr) (mpeg2dec_t * mpeg2dec);
-#define mpeg2_parse(a) (*mpeg2_parse_ptr)(a)
-static void (*mpeg2_buffer_ptr) (mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end);
-#define mpeg2_buffer(a,b,c) (*mpeg2_buffer_ptr)(a,b,c)
-static void (*mpeg2_set_buf_ptr) (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], any_t* id);
-#define mpeg2_set_buf(a,b,c) (*mpeg2_set_buf_ptr)(a,b,c)
-static int (*mpeg2_stride_ptr) (mpeg2dec_t * mpeg2dec, int stride);
-#define mpeg2_stride(a,b) (*mpeg2_stride_ptr)(a,b)
-static void (*mpeg2_reset_ptr) (mpeg2dec_t * mpeg2dec, int full_reset);
-#define mpeg2_reset(a,b) (*mpeg2_reset_ptr)(a,b)
-
struct libmpeg2_private_t : public Opaque {
libmpeg2_private_t();
virtual ~libmpeg2_private_t();
@@ -229,27 +212,36 @@
sh_video_t* sh;
video_decoder_t* parent;
mpeg2dec_t* mpeg2dec;
+ any_t* dll_handle;
+ mpeg2dec_t* (*mpeg2_init_ptr) (unsigned);
+ void (*mpeg2_close_ptr) (mpeg2dec_t * mpeg2dec);
+ const mpeg2_info_t * (*mpeg2_info_ptr) (mpeg2dec_t * mpeg2dec);
+ int (*mpeg2_parse_ptr) (mpeg2dec_t * mpeg2dec);
+ void (*mpeg2_buffer_ptr) (mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end);
+ void (*mpeg2_set_buf_ptr) (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], any_t* id);
+ int (*mpeg2_stride_ptr) (mpeg2dec_t * mpeg2dec, int stride);
+ void (*mpeg2_reset_ptr) (mpeg2dec_t * mpeg2dec, int full_reset);
};
libmpeg2_private_t::libmpeg2_private_t() {}
libmpeg2_private_t::~libmpeg2_private_t() {
- if(mpeg2dec) mpeg2_close(mpeg2dec);
+ if(mpeg2dec) (*mpeg2_close_ptr)(mpeg2dec);
+ if(dll_handle) ::dlclose(dll_handle);
}
-static any_t*dll_handle;
-static MPXP_Rc load_lib( const char *libname )
+static MPXP_Rc load_lib(libmpeg2_private_t& priv, const char *libname )
{
- if(!(dll_handle=ld_codec(libname,mpcodecs_vd_libmpeg2.info->url))) return MPXP_False;
- mpeg2_init_ptr = (mpeg2dec_t* (*)(unsigned int))ld_sym(dll_handle,"mpeg2_init");
- mpeg2_close_ptr = (void (*)(mpeg2dec_t*))ld_sym(dll_handle,"mpeg2_close");
- mpeg2_info_ptr = (const mpeg2_info_t* (*)(mpeg2dec_t*))ld_sym(dll_handle,"mpeg2_info");
- mpeg2_parse_ptr = (int (*)(mpeg2dec_t*))ld_sym(dll_handle,"mpeg2_parse");
- mpeg2_buffer_ptr = (void (*)(mpeg2dec_t*,uint8_t*,uint8_t*))ld_sym(dll_handle,"mpeg2_buffer");
- mpeg2_set_buf_ptr = (void (*)(mpeg2dec_t*,uint8_t**,any_t*))ld_sym(dll_handle,"mpeg2_set_buf");
- mpeg2_stride_ptr = (int (*)(mpeg2dec_t*,int))ld_sym(dll_handle,"mpeg2_stride");
- mpeg2_reset_ptr = (void (*)(mpeg2dec_t*,int))ld_sym(dll_handle,"mpeg2_reset");
- return (mpeg2_init_ptr && mpeg2_close_ptr && mpeg2_info_ptr &&
- mpeg2_parse_ptr && mpeg2_buffer_ptr && mpeg2_set_buf_ptr &&
- mpeg2_stride_ptr && mpeg2_reset_ptr)?MPXP_Ok:MPXP_False;
+ if(!(priv.dll_handle=ld_codec(libname,mpcodecs_vd_libmpeg2.info->url))) return MPXP_False;
+ priv.mpeg2_init_ptr = (mpeg2dec_t* (*)(unsigned int))ld_sym(priv.dll_handle,"mpeg2_init");
+ priv.mpeg2_close_ptr = (void (*)(mpeg2dec_t*))ld_sym(priv.dll_handle,"mpeg2_close");
+ priv.mpeg2_info_ptr = (const mpeg2_info_t* (*)(mpeg2dec_t*))ld_sym(priv.dll_handle,"mpeg2_info");
+ priv.mpeg2_parse_ptr = (int (*)(mpeg2dec_t*))ld_sym(priv.dll_handle,"mpeg2_parse");
+ priv.mpeg2_buffer_ptr = (void (*)(mpeg2dec_t*,uint8_t*,uint8_t*))ld_sym(priv.dll_handle,"mpeg2_buffer");
+ priv.mpeg2_set_buf_ptr = (void (*)(mpeg2dec_t*,uint8_t**,any_t*))ld_sym(priv.dll_handle,"mpeg2_set_buf");
+ priv.mpeg2_stride_ptr = (int (*)(mpeg2dec_t*,int))ld_sym(priv.dll_handle,"mpeg2_stride");
+ priv.mpeg2_reset_ptr = (void (*)(mpeg2dec_t*,int))ld_sym(priv.dll_handle,"mpeg2_reset");
+ return (priv.mpeg2_init_ptr && priv.mpeg2_close_ptr && priv.mpeg2_info_ptr &&
+ priv.mpeg2_parse_ptr && priv.mpeg2_buffer_ptr && priv.mpeg2_set_buf_ptr &&
+ priv.mpeg2_stride_ptr && priv.mpeg2_reset_ptr)?MPXP_Ok:MPXP_False;
}
// to set/get/query special features/parameters
@@ -258,7 +250,7 @@
switch(cmd) {
case VDCTRL_RESYNC_STREAM:
/*lib starts looking for the next sequence header.*/
- mpeg2_reset(priv.mpeg2dec,1);
+ (*priv.mpeg2_reset_ptr)(priv.mpeg2dec,1);
return MPXP_True;
case VDCTRL_QUERY_FORMAT:
if (*((int*)arg) == IMGFMT_YV12)
@@ -271,8 +263,8 @@
static Opaque* preinit(const video_probe_t& probe,sh_video_t *sh,put_slice_info_t& psi){
UNUSED(psi);
- if(!load_lib(probe.codec_dll)) return NULL;
libmpeg2_private_t* priv = new(zeromem) libmpeg2_private_t;
+ if(!load_lib(*priv,probe.codec_dll)) { delete priv; return NULL; }
priv->sh=sh;
return priv;
}
@@ -281,17 +273,14 @@
libmpeg2_private_t& priv=static_cast<libmpeg2_private_t&>(ctx);
sh_video_t* sh = priv.sh;
priv.parent=&opaque;
- if(!(priv.mpeg2dec=mpeg2_init(mpxp_context().mplayer_accel))) {
+ if(!(priv.mpeg2dec=(*priv.mpeg2_init_ptr)(mpxp_context().mplayer_accel))) {
return MPXP_False;
}
return mpcodecs_config_vf(opaque,sh->src_w,sh->src_h);
}
// uninit driver
-static void uninit(Opaque& ctx){
- UNUSED(ctx);
- dlclose(dll_handle);
-}
+static void uninit(Opaque& ctx){ UNUSED(ctx); }
static void draw_frame(mp_image_t *mpi,video_decoder_t& sh,unsigned w,const mpeg2_fbuf_t *src)
{
@@ -313,18 +302,18 @@
int state,buf;
if(frame.len<=0) return NULL; // skipped null frame
- _info=mpeg2_info(priv.mpeg2dec);
+ _info=(*priv.mpeg2_info_ptr)(priv.mpeg2dec);
mpi=NULL;
buf=0;
MSG_DBG2("len=%u ***mpeg2_info***\n",frame.len);
while(1)
{
- state=mpeg2_parse(priv.mpeg2dec);
+ state=(*priv.mpeg2_parse_ptr)(priv.mpeg2dec);
MSG_DBG2("%i=mpeg2_parse\n",state);
switch(state)
{
case STATE_BUFFER:
- mpeg2_buffer(priv.mpeg2dec,reinterpret_cast<uint8_t*>(frame.data),reinterpret_cast<uint8_t*>(frame.data)+frame.len);
+ (*priv.mpeg2_buffer_ptr)(priv.mpeg2dec,reinterpret_cast<uint8_t*>(frame.data),reinterpret_cast<uint8_t*>(frame.data)+frame.len);
buf++;
if(buf>2) return NULL; /* parsing of the passed buffer finished, return. */
break;
@@ -338,7 +327,7 @@
#endif
mpi=mpcodecs_get_image(*priv.parent,MP_IMGTYPE_EXPORT, MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_DRAW_CALLBACK
,_info->sequence->width,_info->sequence->height);
- mpeg2_stride(priv.mpeg2dec,mpi->stride[0]);
+ (*priv.mpeg2_stride_ptr)(priv.mpeg2dec,mpi->stride[0]);
break;
case STATE_SLICE:
case STATE_END:
@@ -347,7 +336,7 @@
MSG_DBG2("display=%X discard=%X current=%X mpi=%X\n",_info->display_fbuf,_info->discard_fbuf,_info->current_fbuf,mpi);
/* Workaround for broken (badly demuxed) streams.
Reset libmpeg2 to start decoding at the next picture. */
- if(state==STATE_END) mpeg2_reset(priv.mpeg2dec,0);
+ if(state==STATE_END) (*priv.mpeg2_reset_ptr)(priv.mpeg2dec,0);
if (_info->display_fbuf && mpi)
{
mpi->pict_type=_info->current_picture->flags&PIC_MASK_CODING_TYPE;
Modified: mplayerxp/libmpcodecs/vd_real.cpp
===================================================================
--- mplayerxp/libmpcodecs/vd_real.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/vd_real.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -72,12 +72,6 @@
uint32_t timestamp;
};
-uint32_t (*rvyuv_custom_message)(cmsg_data_t*,any_t*);
-uint32_t (*rvyuv_free)(any_t*);
-uint32_t (*rvyuv_hive_message)(uint32_t,uint32_t);
-uint32_t (*rvyuv_init)(any_t*,any_t*);
-uint32_t (*rvyuv_transform)(char*, char*,transform_in_t*,unsigned int*,any_t*);
-
#if 0
any_t*__builtin_vec_new(unsigned long size) {
return mp_malloc(size);
@@ -101,11 +95,16 @@
sh_video_t* sh;
video_decoder_t* parent;
any_t* rv_handle;
+ uint32_t (*rvyuv_custom_message)(cmsg_data_t*,any_t*);
+ uint32_t (*rvyuv_free)(any_t*);
+ uint32_t (*rvyuv_hive_message)(uint32_t,uint32_t);
+ uint32_t (*rvyuv_init)(any_t*,any_t*);
+ uint32_t (*rvyuv_transform)(char*, char*,transform_in_t*,unsigned int*,any_t*);
};
vreal_private_t::vreal_private_t() {}
vreal_private_t::~vreal_private_t() {
if(rvyuv_free) rvyuv_free(handle);
- if(rv_handle) dlclose(rv_handle);
+ if(rv_handle) ::dlclose(rv_handle);
}
// to set/get/query special features/parameters
@@ -132,34 +131,34 @@
any_t*handle;
char *error;
- priv.rv_handle = handle = dlopen (path, RTLD_LAZY);
+ priv.rv_handle = handle = ::dlopen (path, RTLD_LAZY);
if (!handle) {
MSG_ERR("DLError: %s\n",dlerror());
return 0;
}
- rvyuv_custom_message = (uint32_t (*)(cmsg_data_t*,any_t*))ld_sym(handle, "RV20toYUV420CustomMessage");
- if ((error = dlerror()) != NULL) {
+ priv.rvyuv_custom_message = (uint32_t (*)(cmsg_data_t*,any_t*))ld_sym(handle, "RV20toYUV420CustomMessage");
+ if ((error = ::dlerror()) != NULL) {
MSG_ERR( "ld_sym(rvyuvCustomMessage): %s\n", error);
return 0;
}
- rvyuv_free = (uint32_t (*)(any_t*))ld_sym(handle, "RV20toYUV420Free");
- if ((error = dlerror()) != NULL) {
+ priv.rvyuv_free = (uint32_t (*)(any_t*))ld_sym(handle, "RV20toYUV420Free");
+ if ((error = ::dlerror()) != NULL) {
MSG_ERR( "ld_sym(rvyuvFree): %s\n", error);
return 0;
}
- rvyuv_hive_message = (uint32_t (*)(uint32_t,uint32_t))ld_sym(handle, "RV20toYUV420HiveMessage");
- if ((error = dlerror()) != NULL) {
+ priv.rvyuv_hive_message = (uint32_t (*)(uint32_t,uint32_t))ld_sym(handle, "RV20toYUV420HiveMessage");
+ if ((error = ::dlerror()) != NULL) {
MSG_ERR( "ld_sym(rvyuvHiveMessage): %s\n", error);
return 0;
}
- rvyuv_init = (uint32_t (*)(any_t*,any_t*))ld_sym(handle, "RV20toYUV420Init");
- if ((error = dlerror()) != NULL) {
+ priv.rvyuv_init = (uint32_t (*)(any_t*,any_t*))ld_sym(handle, "RV20toYUV420Init");
+ if ((error = ::dlerror()) != NULL) {
MSG_ERR( "ld_sym(rvyuvInit): %s\n", error);
return 0;
}
- rvyuv_transform = (uint32_t (*)(char*,char*,transform_in_t*,unsigned int*,any_t*))ld_sym(handle, "RV20toYUV420Transform");
- if ((error = dlerror()) != NULL) {
+ priv.rvyuv_transform = (uint32_t (*)(char*,char*,transform_in_t*,unsigned int*,any_t*))ld_sym(handle, "RV20toYUV420Transform");
+ if ((error = ::dlerror()) != NULL) {
MSG_ERR( "ld_sym(rvyuvTransform): %s\n", error);
return 0;
}
@@ -205,7 +204,7 @@
// only I420 supported
if(!mpcodecs_config_vf(opaque,sh->src_w,sh->src_h)) return MPXP_False;
// init codec:
- result=(*rvyuv_init)(&init_data, &priv.handle);
+ result=(*priv.rvyuv_init)(&init_data, &priv.handle);
if (result){
MSG_ERR("Couldn't open RealVideo codec, error code: 0x%X \n",result);
return MPXP_False;
@@ -215,7 +214,7 @@
uint32_t cmsg24[4]={sh->src_w,sh->src_h,sh->src_w,sh->src_h};
/* FIXME: Broken for 64-bit pointers */
cmsg_data_t cmsg_data={0x24,1+(extrahdr[1]&7), &cmsg24[0]};
- (*rvyuv_custom_message)(&cmsg_data,priv.handle);
+ (*priv.rvyuv_custom_message)(&cmsg_data,priv.handle);
}
MSG_V("INFO: RealVideo codec init OK!\n");
return MPXP_Ok;
@@ -250,7 +249,7 @@
sh->src_w, sh->src_h);
if(mpi->flags&MP_IMGFLAG_DIRECT) mpi->flags|=MP_IMGFLAG_RENDERED;
- result=(*rvyuv_transform)(const_cast<char *>(dp_data), reinterpret_cast<char*>(mpi->planes[0]), &transform_in,
+ result=(*priv.rvyuv_transform)(const_cast<char *>(dp_data), reinterpret_cast<char*>(mpi->planes[0]), &transform_in,
transform_out, priv.handle);
return (result?NULL:mpi);
Modified: mplayerxp/libmpcodecs/vd_xanim.cpp
===================================================================
--- mplayerxp/libmpcodecs/vd_xanim.cpp 2012-12-25 14:21:19 UTC (rev 600)
+++ mplayerxp/libmpcodecs/vd_xanim.cpp 2012-12-25 16:17:37 UTC (rev 601)
@@ -192,9 +192,8 @@
};
static const int XA_CLOSE_FUNCS=5;
-int xa_close_func = 0;
-typedef struct xacodec_driver {
+struct xacodec_driver_t {
XA_DEC_INFO* decinfo;
any_t* file_handler;
long (*iq_func)(XA_CODEC_HDR *codec_hdr);
@@ -202,16 +201,16 @@
unsigned int dsize, XA_DEC_INFO *dec_info);
any_t* close_func[XA_CLOSE_FUNCS];
xacodec_image_t image;
-} xacodec_driver_t;
+};
-xacodec_driver_t *xacodec_driver = NULL;
-
struct xa_private_t : public Opaque {
xa_private_t();
virtual ~xa_private_t();
sh_video_t* sh;
video_decoder_t* parent;
+ xacodec_driver_t* xacodec_driver;
+ int xa_close_func;
};
xa_private_t::xa_private_t() {}
xa_private_t::~xa_private_t() {}
@@ -233,39 +232,39 @@
/* 0 is no debug (needed by 3ivX) */
long xa_debug = 0;
-int xacodec_exit(void);
-void TheEnd1(char *err_mess)
+int xacodec_exit(xa_private_t&);
+void TheEnd1(xa_private_t& priv,const char *err_mess)
{
XA_Print("error: %s - exiting\n", err_mess);
- xacodec_exit();
+ xacodec_exit(priv);
return;
}
-void XA_Add_Func_To_Free_Chain(XA_ANIM_HDR *anim_hdr, void (*function)())
+void XA_Add_Func_To_Free_Chain(xa_private_t& priv,XA_ANIM_HDR *anim_hdr, void (*function)())
{
// XA_Print("XA_Add_Func_To_Free_Chain('anim_hdr: %08x', 'function: %08x')",
// anim_hdr, function);
- xacodec_driver->close_func[xa_close_func] = (any_t*)function;
- if (xa_close_func+1 < XA_CLOSE_FUNCS)
- xa_close_func++;
+ priv.xacodec_driver->close_func[priv.xa_close_func] = (any_t*)function;
+ if (priv.xa_close_func+1 < XA_CLOSE_FUNCS)
+ priv.xa_close_func++;
return;
}
/* end of crap */
/* load, init and query */
-int xacodec_init(char *filename, xacodec_driver_t *codec_driver)
+int xacodec_init(const char *filename, xacodec_driver_t *codec_driver)
{
any_t*(*what_the)();
- char *error;
+ const char *error;
XAVID_MOD_HDR *mod_hdr;
XAVID_FUNC_HDR *func;
unsigned int i;
- codec_driver->file_handler = dlopen(filename, RTLD_NOW|RTLD_GLOBAL);
+ codec_driver->file_handler = ::dlopen(filename, RTLD_NOW|RTLD_GLOBAL);
if (!codec_driver->file_handler) {
- error = dlerror();
+ error = ::dlerror();
if (error)
MSG_FATAL( "xacodec: failed to dlopen %s while %s\n", filename, error);
else
@@ -274,7 +273,7 @@
}
what_the = (any_t* (*)())ld_sym(codec_driver->file_handler, "What_The");
- if ((error = dlerror()) != NULL) {
+ if ((error = ::dlerror()) != NULL) {
MSG_FATAL( "xacodec: failed to init %s while %s\n", filename, error);
dlclose(codec_driver->file_handler);
return 0;
@@ -368,39 +367,40 @@
const char *xacodec_def_path = "/usr/lib/xanim/mods";
-int xacodec_init_video(sh_video_t *vidinfo, int out_format)
+static int xacodec_init_video(xa_private_t& priv, int out_format)
{
char dll[1024];
XA_CODEC_HDR codec_hdr;
int i;
+ sh_video_t* sh_video = priv.sh;
- xacodec_driver = (xacodec_driver_t*)mp_realloc(xacodec_driver, sizeof(struct xacodec_driver));
- if (xacodec_driver == NULL) {
+ priv.xacodec_driver = (xacodec_driver_t*)mp_realloc(priv.xacodec_driver, sizeof(struct xacodec_driver_t));
+ if (priv.xacodec_driver == NULL) {
MSG_FATAL( "xacodec: memory allocation error: %s\n",
strerror(errno));
return 0;
}
- xacodec_driver->iq_func = NULL;
- xacodec_driver->dec_func = NULL;
+ priv.xacodec_driver->iq_func = NULL;
+ priv.xacodec_driver->dec_func = NULL;
for (i=0; i < XA_CLOSE_FUNCS; i++)
- xacodec_driver->close_func[i] = NULL;
+ priv.xacodec_driver->close_func[i] = NULL;
if (getenv("XANIM_MOD_DIR"))
- xacodec_def_path = getenv("XANIM_MOD_DIR");
+ xacodec_def_path = ::getenv("XANIM_MOD_DIR");
- snprintf(dll, 1024, "%s/%s", xacodec_def_path, vidinfo->codec->dll_name);
- if (xacodec_init(dll, xacodec_driver) == 0)
+ snprintf(dll, 1024, "%s/%s", xacodec_def_path, sh_video->codec->dll_name);
+ if (xacodec_init(dll, priv.xacodec_driver) == 0)
return 0;
codec_hdr.xapi_rev = XAVID_API_REV;
codec_hdr.anim_hdr = mp_malloc(4096);
- codec_hdr.description = vidinfo->codec->s_info;
- codec_hdr.compression = bswap_32(vidinfo->bih->biCompression);
+ codec_hdr.description = sh_video->codec->s_info;
+ codec_hdr.compression = bswap_32(sh_video->bih->biCompression);
codec_hdr.decoder = NULL;
- codec_hdr.x = vidinfo->bih->biWidth; /* ->src_w */
- codec_hdr.y = vidinfo->bih->biHeight; /* ->src_h */
+ codec_hdr.x = sh_video->bih->biWidth; /* ->src_w */
+ codec_hdr.y = sh_video->bih->biHeight; /* ->src_h */
/* extra fields to store palette */
codec_hdr.avi_ctab_flag = 0;
codec_hdr.avi_read_ext = NULL;
@@ -450,38 +450,38 @@
MSG_INFO( "xacodec: querying for input %dx%d %dbit [fourcc: %4x] (%s)...\n",
codec_hdr.x, codec_hdr.y, codec_hdr.depth, codec_hdr.compression, codec_hdr.description);
- if (xacodec_query(xacodec_driver, &codec_hdr) == 0)
+ if (xacodec_query(priv.xacodec_driver, &codec_hdr) == 0)
return 0;
// delete codec_hdr.anim_hdr;
- xacodec_driver->decinfo = new(zeromem) XA_DEC_INFO;
- if (xacodec_driver->decinfo == NULL) {
+ priv.xacodec_driver->decinfo = new(zeromem) XA_DEC_INFO;
+ if (priv.xacodec_driver->decinfo == NULL) {
MSG_FATAL( "xacodec: memory allocation error: %s\n",
strerror(errno));
return 0;
}
- xacodec_driver->decinfo->cmd = 0;
- xacodec_driver->decinfo->skip_flag = 0;
- xacodec_driver->decinfo->imagex = xacodec_driver->decinfo->xe = codec_hdr.x;
- xacodec_driver->decinfo->imagey = xacodec_driver->decinfo->ye = codec_hdr.y;
- xacodec_driver->decinfo->imaged = codec_hdr.depth;
- xacodec_driver->decinfo->chdr = NULL;
- xacodec_driver->decinfo->map_flag = 0; /* xaFALSE */
- xacodec_driver->decinfo->map = NULL;
- xacodec_driver->decinfo->xs = xacodec_driver->decinfo->ys = 0;
- xacodec_driver->decinfo->special = 0;
- xacodec_driver->decinfo->extra = codec_hdr.extra;
+ priv.xacodec_driver->decinfo->cmd = 0;
+ priv.xacodec_driver->decinfo->skip_flag = 0;
+ priv.xacodec_driver->decinfo->imagex = priv.xacodec_driver->decinfo->xe = codec_hdr.x;
+ priv.xacodec_driver->decinfo->imagey = priv.xacodec_driver->decinfo->ye = codec_hdr.y;
+ priv.xacodec_driver->decinfo->imaged = codec_hdr.depth;
+ priv.xacodec_driver->decinfo->chdr = NULL;
+ priv.xacodec_driver->decinfo->map_flag = 0; /* xaFALSE */
+ priv.xacodec_driver->decinfo->map = NULL;
+ priv.xacodec_driver->decinfo...
[truncated message content] |
