DllLoader::DllLoader(const char *sDll, bool bTrack, bool bSystemDll, bool bLoadSymbols, Export* exps) : LibraryLoader(sDll)
{
ImportDirTable = 0;
m_pExportHead = NULL;
m_pStaticExports = exps;
m_bTrack = bTrack;
m_bSystemDll = bSystemDll;
m_pDlls = NULL;
if(!bSystemDll)
{
// Initialize FS segment, important for quicktime dll's
#if defined(USE_LDT_KEEPER)
m_ldt_fs = Setup_LDT_Keeper();
#endif
}
DllLoaderContainer::RegisterDll(this);
if (m_bTrack) tracker_dll_add(this);
m_bLoadSymbols=bLoadSymbols;
m_bUnloadSymbols=false;
/* system dll's are never loaded in any way, so let's just use the pointer */
/* to this object as their base address */
if (m_bSystemDll)
hModule = (HMODULE)this;
}
static int load_dll( char *libname )
{
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
vqf_dll = LoadLibraryA(libname);
if( vqf_dll == NULL )
{
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "failed loading dll\n" );
return 0;
}
TvqInitialize = GetProcAddress(vqf_dll,"TvqInitialize");
TvqTerminate = GetProcAddress(vqf_dll,"TvqTerminate");
TvqGetVectorInfo = GetProcAddress(vqf_dll,"TvqGetVectorInfo");
TvqDecodeFrame = GetProcAddress(vqf_dll,"TvqDecodeFrame");
TvqWtypeToBtype = GetProcAddress(vqf_dll,"TvqWtypeToBtype");
TvqUpdateVectorInfo = GetProcAddress(vqf_dll,"TvqUpdateVectorInfo");
TvqCheckVersion = GetProcAddress(vqf_dll,"TvqCheckVersion");
TvqGetConfInfo = GetProcAddress(vqf_dll,"TvqGetConfInfo");
TvqGetFrameSize = GetProcAddress(vqf_dll,"TvqGetFrameSize");
TvqGetNumFixedBitsPerFrame = GetProcAddress(vqf_dll,"TvqGetNumFixedBitsPerFrame");
return TvqInitialize && TvqTerminate && TvqGetVectorInfo &&
TvqDecodeFrame && TvqWtypeToBtype && TvqUpdateVectorInfo &&
TvqCheckVersion && TvqGetConfInfo && TvqGetFrameSize &&
TvqGetNumFixedBitsPerFrame;
}
static int load_syms_windows(char *path) {
void *handle;
mp_msg(MSGT_DECVIDEO,MSGL_V, "opening win32 dll '%s'\n", path);
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
handle = LoadLibraryA(path);
mp_msg(MSGT_DECVIDEO,MSGL_V,"win32 real codec handle=%p \n",handle);
if (!handle) {
mp_msg(MSGT_DECVIDEO,MSGL_WARN,"Error loading dll\n");
return 0;
}
wrvyuv_custom_message = GetProcAddress(handle, "RV20toYUV420CustomMessage");
wrvyuv_free = GetProcAddress(handle, "RV20toYUV420Free");
wrvyuv_init = GetProcAddress(handle, "RV20toYUV420Init");
wrvyuv_transform = GetProcAddress(handle, "RV20toYUV420Transform");
if(wrvyuv_custom_message &&
wrvyuv_free &&
wrvyuv_init &&
wrvyuv_transform)
{
dll_type = 1;
rv_handle = handle;
return 1;
}
mp_msg(MSGT_DECVIDEO,MSGL_WARN,"Error resolving symbols! (version incompatibility?)\n");
FreeLibrary(handle);
return 0; // error
}
static GstStateChangeReturn
dmo_audiodec_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn res;
DMOAudioDec *dec = (DMOAudioDec *) element;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
dec->ldt_fs = Setup_LDT_Keeper ();
break;
default:
break;
}
res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
if (dec->ctx) {
Check_FS_Segment ();
DMO_AudioDecoder_Destroy (dec->ctx);
dec->ctx = NULL;
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
Restore_LDT_Keeper (dec->ldt_fs);
break;
default:
break;
}
return res;
}
static void * load_syms(decoder_t *p_dec, const char *path)
{
void *handle;
msg_Dbg( p_dec, "opening win32 dll '%s'", path);
#ifdef LOADER
Setup_LDT_Keeper();
#endif
handle = LoadLibraryA(path);
msg_Dbg( p_dec, "win32 real codec handle=%p",handle);
if (!handle)
{
msg_Err( p_dec, "Error loading dll");
return NULL;
}
wrvyuv_custom_message = GetProcAddress(handle, "RV20toYUV420CustomMessage");
wrvyuv_free = GetProcAddress(handle, "RV20toYUV420Free");
wrvyuv_init = GetProcAddress(handle, "RV20toYUV420Init");
wrvyuv_transform = GetProcAddress(handle, "RV20toYUV420Transform");
if (wrvyuv_custom_message && wrvyuv_free && wrvyuv_init && wrvyuv_transform)
{
dll_type = 1;
return handle;
}
msg_Err( p_dec, "Error resolving symbols! (version incompatibility?)");
FreeLibrary(handle);
return NULL; // error
}
DllLoader::DllLoader(const char *sDll, bool bTrack, bool bSystemDll, bool bLoadSymbols, Export* exps) : LibraryLoader(sDll)
{
ImportDirTable = 0;
m_pExportHead = NULL;
m_pStaticExports = exps;
m_bTrack = bTrack;
m_bSystemDll = bSystemDll;
m_pDlls = NULL;
if(!bSystemDll)
{
// Initialize FS segment, important for quicktime dll's
#if defined(_XBOX)
// is it really needed?
static void* fs_seg = NULL;
if (fs_seg == NULL)
{
CLog::Log(LOGDEBUG, "Initializing FS_SEG..");
fs_seg = malloc(0x1000);
RtlZeroMemory(fs_seg, 0x1000);
__asm {
mov eax, fs_seg;
mov fs: [18h], eax;
xor eax, eax
}
CLog::Log(LOGDEBUG, "FS segment @ 0x%x", fs_seg);
}
#elif defined(USE_LDT_KEEPER)
m_ldt_fs = Setup_LDT_Keeper();
#endif
}
/*****************************************************************************
* QTAudioInit:
*****************************************************************************/
static int QTAudioInit( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
#ifdef SYS_DARWIN
p_sys->SoundConverterOpen = (void*)SoundConverterOpen;
p_sys->SoundConverterClose = (void*)SoundConverterClose;
p_sys->SoundConverterSetInfo = (void*)SoundConverterSetInfo;
p_sys->SoundConverterGetBufferSizes = (void*)SoundConverterGetBufferSizes;
p_sys->SoundConverterConvertBuffer = (void*)SoundConverterConvertBuffer;
p_sys->SoundConverterBeginConversion= (void*)SoundConverterBeginConversion;
p_sys->SoundConverterEndConversion = (void*)SoundConverterEndConversion;
#else
#ifdef LOADER
p_sys->ldt_fs = Setup_LDT_Keeper();
#endif /* LOADER */
p_sys->qtml = LoadLibraryA( "qtmlClient.dll" );
if( p_sys->qtml == NULL )
{
msg_Dbg( p_dec, "failed loading qtmlClient.dll" );
return VLC_EGENERIC;
}
p_sys->InitializeQTML = (void *)GetProcAddress( p_sys->qtml, "InitializeQTML" );
p_sys->TerminateQTML = (void *)GetProcAddress( p_sys->qtml, "TerminateQTML" );
p_sys->SoundConverterOpen = (void *)GetProcAddress( p_sys->qtml, "SoundConverterOpen" );
p_sys->SoundConverterClose = (void *)GetProcAddress( p_sys->qtml, "SoundConverterClose" );
p_sys->SoundConverterSetInfo = (void *)GetProcAddress( p_sys->qtml, "SoundConverterSetInfo" );
p_sys->SoundConverterGetBufferSizes = (void *)GetProcAddress( p_sys->qtml, "SoundConverterGetBufferSizes" );
p_sys->SoundConverterConvertBuffer = (void *)GetProcAddress( p_sys->qtml, "SoundConverterConvertBuffer" );
p_sys->SoundConverterEndConversion = (void *)GetProcAddress( p_sys->qtml, "SoundConverterEndConversion" );
p_sys->SoundConverterBeginConversion= (void *)GetProcAddress( p_sys->qtml, "SoundConverterBeginConversion");
if( p_sys->InitializeQTML == NULL )
{
msg_Err( p_dec, "failed getting proc address InitializeQTML" );
return VLC_EGENERIC;
}
if( p_sys->SoundConverterOpen == NULL ||
p_sys->SoundConverterClose == NULL ||
p_sys->SoundConverterSetInfo == NULL ||
p_sys->SoundConverterGetBufferSizes == NULL ||
p_sys->SoundConverterConvertBuffer == NULL ||
p_sys->SoundConverterEndConversion == NULL ||
p_sys->SoundConverterBeginConversion == NULL )
{
msg_Err( p_dec, "failed getting proc address" );
return VLC_EGENERIC;
}
msg_Dbg( p_dec, "Standard init done" );
#endif /* else SYS_DARWIN */
return VLC_SUCCESS;
}
static int vf_open(vf_instance_t *vf, char* args){
OSErr cres = 1;
vf->config=config;
vf->default_caps=VFCAP_CONSTANT;
vf->control=control;
vf->query_format=query_format;
vf->put_image=put_image;
vf->priv=malloc(sizeof(struct vf_priv_s));
memset(vf->priv,0,sizeof(struct vf_priv_s));
vf->priv->mux=(muxer_stream_t*)args;
mux_v->bih=calloc(1, sizeof(*mux_v->bih)+MAX_IDSIZE);
mux_v->bih->biSize=sizeof(*mux_v->bih)+MAX_IDSIZE;
mux_v->bih->biWidth=0;
mux_v->bih->biHeight=0;
mux_v->bih->biCompression=format;
mux_v->bih->biPlanes=1;
mux_v->bih->biBitCount=24;
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
//preload quicktime.qts to avoid the problems caused by the hardcoded path inside the dll
qtime_qts = LoadLibraryA("QuickTime.qts");
if(!qtime_qts){
mp_msg(MSGT_MENCODER,MSGL_ERR,"unable to load QuickTime.qts\n" );
return 0;
}
handler = LoadLibraryA("qtmlClient.dll");
if(!handler){
mp_msg(MSGT_MENCODER,MSGL_ERR,"unable to load qtmlClient.dll\n");
return 0;
}
InitializeQTML = (OSErr (*)(long))GetProcAddress(handler, "InitializeQTML");
GetGWorldPixMap = (PixMapHandle (*)(GWorldPtr))GetProcAddress(handler, "GetGWorldPixMap");
QTNewGWorldFromPtr = (OSErr(*)(GWorldPtr *,OSType,const Rect *,CTabHandle,void*,GWorldFlags,void *,long))GetProcAddress(handler, "QTNewGWorldFromPtr");
NewHandleClear = (OSErr(*)(Size))GetProcAddress(handler, "NewHandleClear");
FindCodec = (OSErr (*)(CodecType,CodecComponent,CompressorComponent *,DecompressorComponent *))GetProcAddress(handler,"FindCodec");
CompressSequenceBegin = (OSErr(*)(ImageSequence *,PixMapHandle,PixMapHandle,const Rect *,const Rect *,short,CodecType,CompressorComponent,CodecQ,CodecQ,long,CTabHandle,CodecFlags,ImageDescriptionHandle))GetProcAddress(handler,"CompressSequenceBegin");
CompressSequenceFrame = (OSErr(*)(ImageSequence,PixMapHandle,const Rect *,CodecFlags,Ptr,long *,UInt8 *,ICMCompletionProcRecordPtr))GetProcAddress(handler,"CompressSequenceFrame");
GetMaxCompressionSize = (OSErr(*)(PixMapHandle,const Rect *,short,CodecQ,CodecType,CompressorComponent,long *))GetProcAddress(handler,"GetMaxCompressionSize");
CDSequenceEnd = (OSErr (*)(ImageSequence))GetProcAddress(handler,"CDSequenceEnd");
FindNextComponent = (Component (*)(Component,ComponentDescription*))GetProcAddress(handler, "FindNextComponent");
CountComponents = (long (*)(ComponentDescription*))GetProcAddress(handler, "CountComponents");
GetComponentInfo = (OSErr (*)(Component,ComponentDescription*,Handle,Handle,Handle))GetProcAddress(handler, "GetComponentInfo");
if(!InitializeQTML ||!CompressSequenceBegin){
mp_msg(MSGT_MENCODER,MSGL_ERR,"invalid qt DLL!\n");
return 0;
}
//printf("%i,%i,%i\n",mmioFOURCC('S','V','Q','1'),'SVQ1',bswap_32(mmioFOURCC('S','V','Q','1')));
cres=InitializeQTML(6+16);
mp_msg(MSGT_MENCODER,MSGL_DBG2,"InitializeQTML returned %i\n",cres);
return 1;
}
static int init(sh_video_t *sh)
{
int err;
char fname[MAX_PATH + 1] = "";
memset(&dsn, 0, sizeof(dsn));
#ifdef WIN32_LOADER
dsn.ldt_fs = Setup_LDT_Keeper();
#endif
dsn.hLib = LoadLibraryA("dshownative.dll");
if (!dsn.hLib)
{
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "[dshownative] Cannot find dshownative.dll: %ld\n", GetLastError());
return 0;
}
dsn.DSOpenVideoCodec = (funcDSOpenVideoCodec) GetProcAddress(dsn.hLib, "DSOpenVideoCodec");
dsn.DSCloseVideoCodec = (funcDSCloseVideoCodec) GetProcAddress(dsn.hLib, "DSCloseVideoCodec");
dsn.DSVideoDecode = (funcDSVideoDecode) GetProcAddress(dsn.hLib, "DSVideoDecode");
dsn.DSVideoResync = (funcDSVideoResync) GetProcAddress(dsn.hLib, "DSVideoResync");
dsn.DSStrError = (funcDSStrError) GetProcAddress(dsn.hLib, "DSStrError");
dsn.DSGetApiVersion = (funcDSGetApiVersion) GetProcAddress(dsn.hLib, "DSGetApiVersion");
if (!(dsn.DSOpenVideoCodec && dsn.DSCloseVideoCodec && dsn.DSVideoDecode && dsn.DSVideoResync && dsn.DSStrError && dsn.DSGetApiVersion))
{
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "[dshownative] dshownative dll symbol mismatch\n");
return 0;
}
if (dsn.DSGetApiVersion() != DSN_API_VERSION)
{
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "[dshownative] Incompatible API version\n");
return 0;
}
if (sh->ds->demuxer->filename)
GetFullPathNameA(sh->ds->demuxer->filename, MAX_PATH, fname, NULL);
if (!(dsn.codec = dsn.DSOpenVideoCodec(sh->codec->dll, sh->codec->guid, sh->bih,
sh->codec->outfmt[sh->outfmtidx], sh->fps, fname, is_mpegts_format, &err)))
{
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "[dshownative] Codec init failed: %s\n", dsn.DSStrError(err));
return 0;
}
if (!mpcodecs_config_vo(sh, sh->disp_w, sh->disp_h, IMGFMT_YUY2))
{
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "[dshownative] mpcodecs_config_vo() failed\n");
return 0;
}
special_codec = 1;
mp_msg(MSGT_DECVIDEO, MSGL_V, "INFO: [dshownative] video codec init OK.\n");
return 1;
}
static int init_dshow()
{
char *ext;
wait_time = 50;
ext = strrchr(filename, '.');
if(ext) {
if(!stricmp(ext, ".bik") || !stricmp(ext, ".avs"))
return 0;
if(!stricmp(ext, ".wmv") || !stricmp(ext, ".asf"))
wait_time = 1;
}
#ifdef WIN32_LOADER
ldt_fs = Setup_LDT_Keeper();
#endif
hLib = LoadLibraryA("dshownative.dll");
if(!hLib) {
mp_msg(MSGT_DEMUX, MSGL_V, "dshow demuxer: failed to load dshownative.dll\n");
return 0;
}
InitDShowGraphFromFile = (TInitDShowGraphFromFile)GetProcAddress(hLib,"InitDShowGraphFromFile");
StartGraph = (TGraphOperate)GetProcAddress(hLib,"StartGraph");
StopGraph = (TGraphOperate)GetProcAddress(hLib,"StopGraph");
DestroyGraph = (TGraphOperate)GetProcAddress(hLib,"DestroyGraph");
SeekGraph = (TSeekGraph)GetProcAddress(hLib,"SeekGraph");
GetGraphDuration = (TGetGraphDuration)GetProcAddress(hLib,"GetGraphDuration");
DSGetApiVersion = (funcDSGetApiVersion) GetProcAddress(hLib, "DSGetApiVersion");
if(!InitDShowGraphFromFile || !StartGraph || !StopGraph || !DSGetApiVersion ||
!DestroyGraph || !SeekGraph || !GetGraphDuration) {
FreeLibrary(hLib);
hLib = NULL;
return 0;
}
if (DSGetApiVersion() != DSN_API_VERSION) {
FreeLibrary(hLib);
hLib = NULL;
mp_msg(MSGT_DECVIDEO, MSGL_V, "dshow demuxer: Incompatible API version\n");
return 0;
}
if (!(g_pdgi = InitDShowGraphFromFile(filename, MEDIASUBTYPE_YV12, 0, 0, VideoCallBackProc,
AudioCallBackProc, &VideoInfo, &AudioInfo))) {
FreeLibrary(hLib);
hLib = NULL;
mp_msg(MSGT_DEMUX, MSGL_V, "dshow demuxer: failed to render %s\n", filename);
return 0;
}
return 1;
}
//DrvOpen(LPCSTR lpszDriverName, LPCSTR lpszSectionName, LPARAM lParam2)
HDRVR DrvOpen(LPARAM lParam2)
{
NPDRVR hDriver;
char unknown[0x124];
const char* filename = (const char*) ((ICOPEN*) lParam2)->pV1Reserved;
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
printf("Loading codec DLL: '%s'\n",filename);
hDriver = malloc(sizeof(DRVR));
if (!hDriver)
return (HDRVR) 0;
memset((void*)hDriver, 0, sizeof(DRVR));
#ifdef WIN32_LOADER
CodecAlloc();
Setup_FS_Segment();
#endif
hDriver->hDriverModule = LoadLibraryA(filename);
if (!hDriver->hDriverModule)
{
printf("Can't open library %s\n", filename);
DrvClose((HDRVR)hDriver);
return (HDRVR) 0;
}
hDriver->DriverProc = (DRIVERPROC) GetProcAddress(hDriver->hDriverModule,
"DriverProc");
if (!hDriver->DriverProc)
{
printf("Library %s is not a valid VfW/ACM codec\n", filename);
DrvClose((HDRVR)hDriver);
return (HDRVR) 0;
}
TRACE("DriverProc == %X\n", hDriver->DriverProc);
SendDriverMessage((HDRVR)hDriver, DRV_LOAD, 0, 0);
TRACE("DRV_LOAD Ok!\n");
SendDriverMessage((HDRVR)hDriver, DRV_ENABLE, 0, 0);
TRACE("DRV_ENABLE Ok!\n");
hDriver->dwDriverID = ++dwDrvID; // generate new id
// open driver and remmeber proper DriverID
hDriver->dwDriverID = SendDriverMessage((HDRVR)hDriver, DRV_OPEN, (LPARAM) unknown, lParam2);
TRACE("DRV_OPEN Ok!(%X)\n", hDriver->dwDriverID);
printf("Loaded DLL driver %s at %x\n", filename, hDriver->hDriverModule);
return (HDRVR)hDriver;
}
static int load_syms_windows(char *path) {
void *handle;
mp_msg(MSGT_DECVIDEO,MSGL_V, "opening win32 dll '%s'\n", path);
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
handle = LoadLibraryA(path);
mp_msg(MSGT_DECVIDEO,MSGL_V,"win32 real codec handle=%p \n",handle);
if (!handle) {
mp_msg(MSGT_DECVIDEO,MSGL_WARN,"Error loading dll\n");
return 0;
}
wrvyuv_custom_message = GetProcAddress(handle, "RV20toYUV420CustomMessage");
wrvyuv_free = GetProcAddress(handle, "RV20toYUV420Free");
wrvyuv_init = GetProcAddress(handle, "RV20toYUV420Init");
wrvyuv_transform = GetProcAddress(handle, "RV20toYUV420Transform");
if(wrvyuv_custom_message &&
wrvyuv_free &&
wrvyuv_init &&
wrvyuv_transform)
{
dll_type = 1;
rv_handle = handle;
#ifndef WIN32_LOADER
{
int patched = 0;
// drv43260.dll
if (wrvyuv_transform == (void *)0x634114d0) {
// patch away multithreaded decoding, it causes crashes
static const uint8_t oldcode[13] = {
0x83, 0xbb, 0xf8, 0x05, 0x00, 0x00, 0x01,
0x0f, 0x86, 0xd0, 0x00, 0x00, 0x00 };
static const uint8_t newcode[13] = {
0x31, 0xc0,
0x89, 0x83, 0xf8, 0x05, 0x00, 0x00,
0xe9, 0xd0, 0x00, 0x00, 0x00 };
patched = patch_dll((void *)0x634132fa, oldcode, newcode,
sizeof(oldcode));
}
if (!patched)
mp_msg(MSGT_DECVIDEO, MSGL_WARN, "Could not patch Real codec, this might crash on multi-CPU systems\n");
}
#endif
return 1;
}
mp_msg(MSGT_DECVIDEO,MSGL_WARN,"Error resolving symbols! (version incompatibility?)\n");
FreeLibrary(handle);
return 0; // error
}
static int load_syms_windows(char *path)
{
void *handle;
mp_msg(MSGT_DECVIDEO, MSGL_V, "opening win32 dll '%s'\n", path);
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
handle = LoadLibraryA(path);
if (!handle)
{
mp_msg(MSGT_DECVIDEO, MSGL_WARN, "Error loading dll\n");
return 0;
}
wraCloseCodec = GetProcAddress(handle, "RACloseCodec");
wraDecode = GetProcAddress(handle, "RADecode");
wraFreeDecoder = GetProcAddress(handle, "RAFreeDecoder");
wraOpenCodec = GetProcAddress(handle, "RAOpenCodec");
wraOpenCodec2 = GetProcAddress(handle, "RAOpenCodec2");
wraInitDecoder = GetProcAddress(handle, "RAInitDecoder");
wraSetFlavor = GetProcAddress(handle, "RASetFlavor");
wraSetDLLAccessPath = GetProcAddress(handle, "SetDLLAccessPath");
wraSetPwd = GetProcAddress(handle, "RASetPwd"); // optional, used by SIPR
if (wraCloseCodec && wraDecode && wraFreeDecoder &&
(wraOpenCodec || wraOpenCodec2) && wraSetFlavor &&
/*wraSetDLLAccessPath &&*/ wraInitDecoder)
{
rv_handle = handle;
dll_type = 1;
return 1;
}
mp_msg(MSGT_DECAUDIO,MSGL_WARN,"Cannot resolve symbols - incompatible dll: %s\n",path);
FreeLibrary(handle);
return 0;
}
int
_bmlw_setup (BMLDebugLogger logger)
{
ldt_fs = Setup_LDT_Keeper ();
TRACE (" wrapper initialized: 0x%p\n", ldt_fs);
//Check_FS_Segment(ldt_fs);
if (!(emu_dll = LoadDLL ("BuzzMachineLoader.dll"))) {
TRACE (" failed to load window bml\n");
return FALSE;
}
TRACE (" windows bml loaded\n");
if (!get_symbols (emu_dll, api, sizeof (api) / sizeof (api[0]))) {
return FALSE;
}
TRACE (" symbols connected\n");
BMLX (bmlw_set_logger (logger));
return TRUE;
}
int main(void) {
void *handler;
ComponentDescription desc;
Component (*FindNextComponent)(Component prev,ComponentDescription* desc);
long (*CountComponents)(ComponentDescription* desc);
OSErr (*InitializeQTML)(long flags);
OSErr (*EnterMovies)(void);
OSErr ret;
Setup_LDT_Keeper();
handler = LoadLibraryA("/usr/local/lib/codecs/qtmlClient.dll");
printf("***************************\n");
InitializeQTML = 0x1000c870; //GetProcAddress(handler, "InitializeQTML");
EnterMovies = 0x10003ac0; //GetProcAddress(handler, "EnterMovies");
FindNextComponent = 0x1000d5f0; //GetProcAddress(handler, "FindNextComponent");
CountComponents = 0x1000d5d0; //GetProcAddress(handler, "CountComponents");
// = GetProcAddress(handler, "");
printf("handler: %p, funcs: %p %p %p, %p\n", handler, InitializeQTML, EnterMovies, FindNextComponent,CountComponents);
ret=InitializeQTML(0);
printf("InitializeQTML->%d\n",ret);
ret=EnterMovies();
printf("EnterMovies->%d\n",ret);
memset(&desc,0,sizeof(desc));
desc.componentType= (((unsigned char)'S')<<24)|
(((unsigned char)'V')<<16)|
(((unsigned char)'Q')<<8)|
(((unsigned char)'5'));
desc.componentSubType=0;
desc.componentManufacturer=0;
desc.componentFlags=0;
desc.componentFlagsMask=0;
printf("Count = %ld\n",CountComponents(&desc));
exit(0);
}
static int OpenWin32Dll( decoder_t *p_dec, char *psz_path, char *psz_dll )
{
decoder_sys_t *p_sys = p_dec->p_sys;
void *handle = 0, *context = 0;
unsigned int i_result;
void *p_prop;
int i_prop;
wra_init_t init_data =
{
p_dec->fmt_in.audio.i_rate,
p_dec->fmt_in.audio.i_bitspersample,
p_dec->fmt_in.audio.i_channels,
100, /* quality */
p_dec->fmt_in.audio.i_blockalign, /* subpacket size */
p_dec->fmt_in.audio.i_blockalign, /* coded frame size */
p_dec->fmt_in.i_extra, p_dec->fmt_in.p_extra
};
msg_Dbg( p_dec, "opening win32 dll '%s'", psz_dll );
#ifdef LOADER
Setup_LDT_Keeper();
#endif
if( !(handle = LoadLibraryA( psz_dll )) )
{
msg_Dbg( p_dec, "couldn't load dll '%s'", psz_dll );
return VLC_EGENERIC;
}
p_sys->wraCloseCodec = GetProcAddress( handle, "RACloseCodec" );
p_sys->wraDecode = GetProcAddress( handle, "RADecode" );
p_sys->wraFlush = GetProcAddress( handle, "RAFlush" );
p_sys->wraFreeDecoder = GetProcAddress( handle, "RAFreeDecoder" );
p_sys->wraGetFlavorProperty =
GetProcAddress( handle, "RAGetFlavorProperty" );
p_sys->wraOpenCodec = GetProcAddress( handle, "RAOpenCodec" );
p_sys->wraOpenCodec2 = GetProcAddress( handle, "RAOpenCodec2" );
p_sys->wraInitDecoder = GetProcAddress( handle, "RAInitDecoder" );
p_sys->wraSetFlavor = GetProcAddress( handle, "RASetFlavor" );
p_sys->wraSetDLLAccessPath = GetProcAddress( handle, "SetDLLAccessPath" );
p_sys->wraSetPwd =
GetProcAddress( handle, "RASetPwd" ); // optional, used by SIPR
if( !(p_sys->wraOpenCodec || p_sys->wraOpenCodec2) ||
!p_sys->wraCloseCodec || !p_sys->wraInitDecoder ||
!p_sys->wraDecode || !p_sys->wraFreeDecoder ||
!p_sys->wraGetFlavorProperty || !p_sys->wraSetFlavor
/* || !p_sys->wraFlush || !p_sys->wraSetDLLAccessPath */ )
{
FreeLibrary( handle );
return VLC_EGENERIC;
}
if( p_sys->wraOpenCodec2 )
i_result = p_sys->wraOpenCodec2( &context, psz_path );
else
i_result = p_sys->wraOpenCodec( &context );
if( i_result )
{
msg_Err( p_dec, "decoder open failed, error code: 0x%x", i_result );
goto error_win32;
}
i_result = p_sys->wraInitDecoder( context, &init_data );
if( i_result )
{
msg_Err( p_dec, "decoder init failed, error code: 0x%x", i_result );
goto error_win32;
}
if( p_sys->i_codec_flavor >= 0 )
{
i_result = p_sys->wraSetFlavor( context, p_sys->i_codec_flavor );
if( i_result )
{
msg_Err( p_dec, "decoder flavor setup failed, error code: 0x%x",
i_result );
goto error_win32;
}
p_prop = p_sys->wraGetFlavorProperty( context, p_sys->i_codec_flavor,
0, &i_prop );
msg_Dbg( p_dec, "audio codec: [%d] %s",
p_sys->i_codec_flavor, (char *)p_prop );
p_prop = p_sys->wraGetFlavorProperty( context, p_sys->i_codec_flavor,
1, &i_prop );
if( p_prop )
{
int i_bps = ((*((int*)p_prop))+4)/8;
msg_Dbg( p_dec, "audio bitrate: %5.3f kbit/s (%d bps)",
(*((int*)p_prop))*0.001f, i_bps );
}
}
p_sys->context = context;
p_sys->win32_dll = handle;
return VLC_SUCCESS;
error_win32:
if( context ) p_sys->wraFreeDecoder( context );
if( context ) p_sys->wraCloseCodec( context );
FreeLibrary( handle );
return VLC_EGENERIC;
}
/*****************************************************************************
* QTVideoInit:
*****************************************************************************/
static int QTVideoInit( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
#ifdef __APPLE__
p_sys->FindNextComponent = (void*)FindNextComponent;
p_sys->OpenComponent = (void*)OpenComponent;
p_sys->ImageCodecInitialize = (void*)ImageCodecInitialize;
p_sys->ImageCodecGetCodecInfo = (void*)ImageCodecGetCodecInfo;
p_sys->ImageCodecPreDecompress = (void*)ImageCodecPreDecompress;
p_sys->ImageCodecBandDecompress = (void*)ImageCodecBandDecompress;
p_sys->GetGWorldPixMap = (void*)GetGWorldPixMap;
p_sys->QTNewGWorldFromPtr = (void*)QTNewGWorldFromPtr;
p_sys->NewHandleClear = (void*)NewHandleClear;
#else
#ifdef LOADER
p_sys->ldt_fs = Setup_LDT_Keeper();
#endif /* LOADER */
p_sys->qts = LoadLibraryA( "QuickTime.qts" );
if( p_sys->qts == NULL )
{
msg_Dbg( p_dec, "failed loading QuickTime.qts" );
return VLC_EGENERIC;
}
msg_Dbg( p_dec, "QuickTime.qts loaded" );
p_sys->qtml = LoadLibraryA( "qtmlClient.dll" );
if( p_sys->qtml == NULL )
{
msg_Dbg( p_dec, "failed loading qtmlClient.dll" );
return VLC_EGENERIC;
}
msg_Dbg( p_dec, "qtmlClient.dll loaded" );
/* (void*) to shut up gcc */
p_sys->InitializeQTML = (void*)GetProcAddress( p_sys->qtml, "InitializeQTML" );
p_sys->FindNextComponent = (void*)GetProcAddress( p_sys->qtml, "FindNextComponent" );
p_sys->OpenComponent = (void*)GetProcAddress( p_sys->qtml, "OpenComponent" );
p_sys->ImageCodecInitialize = (void*)GetProcAddress( p_sys->qtml, "ImageCodecInitialize" );
p_sys->ImageCodecGetCodecInfo = (void*)GetProcAddress( p_sys->qtml, "ImageCodecGetCodecInfo" );
p_sys->ImageCodecPreDecompress = (void*)GetProcAddress( p_sys->qtml, "ImageCodecPreDecompress" );
p_sys->ImageCodecBandDecompress = (void*)GetProcAddress( p_sys->qtml, "ImageCodecBandDecompress" );
p_sys->GetGWorldPixMap = (void*)GetProcAddress( p_sys->qtml, "GetGWorldPixMap" );
p_sys->QTNewGWorldFromPtr = (void*)GetProcAddress( p_sys->qtml, "QTNewGWorldFromPtr" );
p_sys->NewHandleClear = (void*)GetProcAddress( p_sys->qtml, "NewHandleClear" );
if( p_sys->InitializeQTML == NULL )
{
msg_Dbg( p_dec, "failed getting proc address InitializeQTML" );
return VLC_EGENERIC;
}
if( p_sys->FindNextComponent == NULL ||
p_sys->OpenComponent == NULL ||
p_sys->ImageCodecInitialize == NULL ||
p_sys->ImageCodecGetCodecInfo == NULL ||
p_sys->ImageCodecPreDecompress == NULL ||
p_sys->ImageCodecBandDecompress == NULL ||
p_sys->GetGWorldPixMap == NULL ||
p_sys->QTNewGWorldFromPtr == NULL ||
p_sys->NewHandleClear == NULL )
{
msg_Err( p_dec, "failed getting proc address" );
return VLC_EGENERIC;
}
#endif /* __APPLE__ */
return VLC_SUCCESS;
}
AVS_T *initAVS(const char *filename)
{
AVS_T *AVS = malloc (sizeof(AVS_T));
AVS_Value arg0 = avs_new_value_string(filename);
AVS_Value args = avs_new_value_array(&arg0, 1);
memset(AVS, 0, sizeof(AVS_T));
#ifdef WIN32_LOADER
AVS->ldt_fs = Setup_LDT_Keeper();
#endif
AVS->dll = LoadLibraryA("avisynth.dll");
if(!AVS->dll)
{
mp_msg(MSGT_DEMUX ,MSGL_V, "AVS: failed to load avisynth.dll\n");
goto avs_err;
}
/* Dynamic import of needed stuff from avisynth.dll */
IMPORT_FUNC(avs_create_script_environment);
IMPORT_FUNC(avs_invoke);
IMPORT_FUNC(avs_get_video_info);
IMPORT_FUNC(avs_take_clip);
IMPORT_FUNC(avs_release_clip);
IMPORT_FUNC(avs_get_frame);
IMPORT_FUNC(avs_release_video_frame);
IMPORT_FUNC(avs_get_audio);
AVS->avs_env = AVS->avs_create_script_environment(AVISYNTH_INTERFACE_VERSION);
if (!AVS->avs_env)
{
mp_msg(MSGT_DEMUX, MSGL_V, "AVS: avs_create_script_environment failed\n");
goto avs_err;
}
AVS->handler = AVS->avs_invoke(AVS->avs_env, "Import", args, 0);
if (avs_is_error(AVS->handler))
{
mp_msg(MSGT_DEMUX, MSGL_V, "AVS: Avisynth error: %s\n", avs_as_string(AVS->handler));
goto avs_err;
}
if (!avs_is_clip(AVS->handler))
{
mp_msg(MSGT_DEMUX, MSGL_V, "AVS: Avisynth doesn't return a clip\n");
goto avs_err;
}
return AVS;
avs_err:
if (AVS->dll) FreeLibrary(AVS->dll);
#ifdef WIN32_LOADER
Restore_LDT_Keeper(AVS->ldt_fs);
#endif
free(AVS);
return NULL;
}
// init driver
static int init(sh_video_t *sh){
#ifndef CONFIG_QUICKTIME
long result = 1;
#endif
ComponentResult cres;
ComponentDescription desc;
Component prev=NULL;
CodecInfo cinfo; // for ImageCodecGetCodecInfo()
ImageSubCodecDecompressCapabilities icap; // for ImageCodecInitialize()
codec_initialized = 0;
#ifdef CONFIG_QUICKTIME
EnterMovies();
#else
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
//preload quicktime.qts to avoid the problems caused by the hardcoded path inside the dll
qtime_qts = LoadLibraryA("QuickTime.qts");
if(!qtime_qts){
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"unable to load QuickTime.qts\n" );
return 0;
}
handler = LoadLibraryA("qtmlClient.dll");
if(!handler){
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"unable to load qtmlClient.dll\n");
return 0;
}
InitializeQTML = (OSErr (*)(long))GetProcAddress(handler, "InitializeQTML");
EnterMovies = (OSErr (*)(void))GetProcAddress(handler, "EnterMovies");
FindNextComponent = (Component (*)(Component,ComponentDescription*))GetProcAddress(handler, "FindNextComponent");
CountComponents = (long (*)(ComponentDescription*))GetProcAddress(handler, "CountComponents");
GetComponentInfo = (OSErr (*)(Component,ComponentDescription*,Handle,Handle,Handle))GetProcAddress(handler, "GetComponentInfo");
OpenComponent = (ComponentInstance (*)(Component))GetProcAddress(handler, "OpenComponent");
ImageCodecInitialize = (ComponentResult (*)(ComponentInstance,ImageSubCodecDecompressCapabilities *))GetProcAddress(handler, "ImageCodecInitialize");
ImageCodecGetCodecInfo = (ComponentResult (*)(ComponentInstance,CodecInfo *))GetProcAddress(handler, "ImageCodecGetCodecInfo");
ImageCodecBeginBand = (ComponentResult (*)(ComponentInstance,CodecDecompressParams *,ImageSubCodecDecompressRecord *,long))GetProcAddress(handler, "ImageCodecBeginBand");
ImageCodecPreDecompress = (ComponentResult (*)(ComponentInstance,CodecDecompressParams *))GetProcAddress(handler, "ImageCodecPreDecompress");
ImageCodecBandDecompress = (ComponentResult (*)(ComponentInstance,CodecDecompressParams *))GetProcAddress(handler, "ImageCodecBandDecompress");
GetGWorldPixMap = (PixMapHandle (*)(GWorldPtr))GetProcAddress(handler, "GetGWorldPixMap");
QTNewGWorldFromPtr = (OSErr(*)(GWorldPtr *,OSType,const Rect *,CTabHandle,void*,GWorldFlags,void *,long))GetProcAddress(handler, "QTNewGWorldFromPtr");
NewHandleClear = (OSErr(*)(Size))GetProcAddress(handler, "NewHandleClear");
// = GetProcAddress(handler, "");
if(!InitializeQTML || !EnterMovies || !FindNextComponent || !ImageCodecBandDecompress){
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"invalid qtmlClient.dll!\n");
return 0;
}
result=InitializeQTML(6+16);
// result=InitializeQTML(0);
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"InitializeQTML returned %li\n",result);
// result=EnterMovies();
// printf("EnterMovies->%d\n",result);
#endif /* CONFIG_QUICKTIME */
#if 0
memset(&desc,0,sizeof(desc));
while((prev=FindNextComponent(prev,&desc))){
ComponentDescription desc2;
unsigned char* c1=&desc2.componentType;
unsigned char* c2=&desc2.componentSubType;
memset(&desc2,0,sizeof(desc2));
// printf("juhee %p (%p)\n",prev,&desc);
GetComponentInfo(prev,&desc2,NULL,NULL,NULL);
mp_msg(MSGT_DECVIDEO,MSGL_DGB2,"DESC: %c%c%c%c/%c%c%c%c [0x%X/0x%X] 0x%X\n",
c1[3],c1[2],c1[1],c1[0],
c2[3],c2[2],c2[1],c2[0],
desc2.componentType,desc2.componentSubType,
desc2.componentFlags);
}
#endif
memset(&desc,0,sizeof(desc));
desc.componentType= (((unsigned char)'i')<<24)|
(((unsigned char)'m')<<16)|
(((unsigned char)'d')<<8)|
(((unsigned char)'c'));
#if 0
desc.componentSubType=
(((unsigned char)'S'<<24))|
(((unsigned char)'V')<<16)|
(((unsigned char)'Q')<<8)|
(((unsigned char)'3'));
#else
desc.componentSubType = bswap_32(sh->format);
#endif
desc.componentManufacturer=0;
desc.componentFlags=0;
desc.componentFlagsMask=0;
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"Count = %ld\n",CountComponents(&desc));
prev=FindNextComponent(NULL,&desc);
if(!prev){
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Cannot find requested component\n");
return 0;
}
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"Found it! ID = %p\n",prev);
ci=OpenComponent(prev);
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"ci=%p\n",ci);
memset(&icap,0,sizeof(icap));
cres=ImageCodecInitialize(ci,&icap);
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"ImageCodecInitialize->%#x size=%d (%d)\n",cres,icap.recordSize,icap.decompressRecordSize);
memset(&cinfo,0,sizeof(cinfo));
cres=ImageCodecGetCodecInfo(ci,&cinfo);
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"Flags: compr: 0x%X decomp: 0x%X format: 0x%X\n",
cinfo.compressFlags, cinfo.decompressFlags, cinfo.formatFlags);
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"Codec name: %.*s\n",((unsigned char*)&cinfo.typeName)[0],
((unsigned char*)&cinfo.typeName)+1);
//make a yuy2 gworld
OutBufferRect.top=0;
OutBufferRect.left=0;
OutBufferRect.right=sh->disp_w;
OutBufferRect.bottom=sh->disp_h;
//Fill the imagedescription for our SVQ3 frame
//we can probably get this from Demuxer
#if 0
framedescHandle=(ImageDescriptionHandle)NewHandleClear(sizeof(ImageDescription)+200);
printf("framedescHandle=%p *p=%p\n",framedescHandle,*framedescHandle);
{ FILE* f=fopen("/root/.wine/fake_windows/IDesc","r");
if(!f) printf("filenot found: IDesc\n");
fread(*framedescHandle,sizeof(ImageDescription)+200,1,f);
fclose(f);
}
#else
if(!sh->ImageDesc) sh->ImageDesc=(sh->bih+1); // hack for SVQ3-in-AVI
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"ImageDescription size: %d\n",((ImageDescription*)(sh->ImageDesc))->idSize);
framedescHandle=(ImageDescriptionHandle)NewHandleClear(((ImageDescription*)(sh->ImageDesc))->idSize);
memcpy(*framedescHandle,sh->ImageDesc,((ImageDescription*)(sh->ImageDesc))->idSize);
dump_ImageDescription(*framedescHandle);
#endif
//Find codecscomponent for video decompression
// result = FindCodec ('SVQ1',anyCodec,&compressor,&decompressor );
// printf("FindCodec SVQ1 returned:%i compressor: 0x%X decompressor: 0x%X\n",result,compressor,decompressor);
sh->context = (void *)kYUVSPixelFormat;
#if 1
{
int imgfmt = sh->codec->outfmt[sh->outfmtidx];
int qt_imgfmt;
switch(imgfmt)
{
case IMGFMT_YUY2:
qt_imgfmt = kYUVSPixelFormat;
break;
case IMGFMT_YVU9:
qt_imgfmt = 0x73797639; //kYVU9PixelFormat;
break;
case IMGFMT_YV12:
qt_imgfmt = 0x79343230;
break;
case IMGFMT_UYVY:
qt_imgfmt = kUYVY422PixelFormat;
break;
case IMGFMT_YVYU:
qt_imgfmt = kYVYU422PixelFormat;
imgfmt = IMGFMT_YUY2;
break;
case IMGFMT_RGB16:
qt_imgfmt = k16LE555PixelFormat;
break;
case IMGFMT_BGR24:
qt_imgfmt = k24BGRPixelFormat;
break;
case IMGFMT_BGR32:
qt_imgfmt = k32BGRAPixelFormat;
break;
case IMGFMT_RGB32:
qt_imgfmt = k32RGBAPixelFormat;
break;
default:
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Unknown requested csp\n");
return 0;
}
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"imgfmt: %s qt_imgfmt: %.4s\n", vo_format_name(imgfmt), (char *)&qt_imgfmt);
sh->context = (void *)qt_imgfmt;
if(!mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,imgfmt)) return 0;
}
#else
if(!mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,IMGFMT_YUY2)) return 0;
#endif
return 1;
}
int main(void) {
void *handler;
void *handler2;
void* theqtdp=NULL;
void* compcall=NULL;
void* compcallws=NULL;
ComponentResult (*dispatcher)(ComponentParameters *params, Globals glob);
ComponentResult ret;
ComponentParameters *params;
ComponentDescription desc;
void *globals=NULL;
//unsigned int esp=0;
//int i;
mp_msg_init();
//mp_msg_set_level(10);
Setup_LDT_Keeper();
printf("loading qts\n");
// handler = LoadLibraryA("/root/.wine/fake_windows/Windows/System/QuickTime.qts");
handler = LoadLibraryA("QuickTime.qts");
theqtdp = GetProcAddress(handler, "theQuickTimeDispatcher");
compcall = GetProcAddress(handler, "CallComponent");
compcallws = GetProcAddress(handler, "CallComponentFunctionWithStorage");
InitializeQTML = 0x6299e590;//GetProcAddress(handler, "InitializeQTML");
InitializeQTML(6+16);
printf("loading svq3\n");
handler2= LoadLibraryA("/root/.wine/fake_windows/Windows/System/QuickTime/QuickTimeEssentials.qtx");
printf("done\n");
dispatcher = GetProcAddress(handler2, "SMD_ComponentDispatch");
// handler = expLoadLibraryA("/usr/local/lib/codecs/On2_VP3.qtx");
// dispatcher = GetProcAddress(handler, "CDComponentDispatcher");
printf("handler: %p, dispatcher: %p theqtdp: %p\n", handler, dispatcher, theqtdp);
// printf("theQuickTimeDispatcher = %p\n",GetProcAddress(handler, "theQuickTimeDispatcher"));
// patch svq3 dll:
*((void**)0x63214c98) = NULL;
*((void**)0x63214c9c) = theqtdp; // theQt...
*((void**)0x63214ca0) = compcall; //0xdeadbeef; //dispatcher; // CallCOmponent_ptr
*((void**)0x63214ca4) = compcallws; //0xdeadbef2; //dispatcher; // CallComponentWithStorage_ptr
desc.componentType=0;
desc.componentSubType=0;
desc.componentManufacturer=0;
desc.componentFlags=0;
desc.componentFlagsMask=0;
params = malloc(sizeof(ComponentParameters)+2048);
params->flags = 0;
params->paramSize = 4;
params->what = kComponentOpenSelect;
params->params[0] = 0x830000; //0x820000|i; //(i<<16)|0x24; //0x820024;
ret = dispatcher(params, &globals);
printf("!!! CDComponentDispatch() => 0x%X glob=%p\n",ret,globals);
// memset(x_table,12,4*0x00001837);
//for(i=0;i<=255;i++){
// params->what = kComponentVersionSelect;
// params->what = kComponentRegisterSelect;
// params->what = kComponentOpenSelect;
// params->what = kComponentCanDoSelect;
printf("params: flags: %d, paramSize: %d, what: %d, params[0] = %x\n",
params->flags, params->paramSize, params->what, params->params[0]);
// __asm__ volatile ("movl %%esp, %0\n\t" : "=a" (esp) :: "memory" );
// printf("ESP=%p\n",esp);
*((void**)0x62b7d640) = &x_table[0]; //malloc(0x00001837 * 4); // ugly hack?
printf("params=%p &glob=%p x_table=%p\n",params,&globals, &x_table[0]);
ret = dispatcher(params, &globals);
// __asm__ volatile ("movl %%esp, %0\n\t" : "=a" (esp) :: "memory" );
// printf("ESP=%p\n",esp);
printf("!!! CDComponentDispatch() => %d glob=%p\n",ret,globals);
// if(ret!=-3000) break;
//}
// for(i=0;i<0x00001837;i++)
// if(x_table[i]) printf("x_table[0x%X] = %p\n",i,x_table[i]);
exit(0);
//return 0;
}
DMO_VideoDecoder * DMO_VideoDecoder_Open(char* dllname, GUID* guid, BITMAPINFOHEADER * format, int flip, int maxauto)
{
DMO_VideoDecoder *this;
HRESULT result;
ct* c;
int size;
int is_wvc1_video;
this = malloc(sizeof(DMO_VideoDecoder));
memset( this, 0, sizeof(DMO_VideoDecoder));
this->m_sVhdr2 = 0;
this->m_iLastQuality = -1;
this->m_iMaxAuto = maxauto;
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
//memset(&m_obh, 0, sizeof(m_obh));
//m_obh.biSize = sizeof(m_obh);
/*try*/
{
unsigned int bihs;
bihs = (format->biSize < (int) sizeof(BITMAPINFOHEADER)) ?
sizeof(BITMAPINFOHEADER) : format->biSize;
this->iv.m_bh = malloc(bihs);
memcpy(this->iv.m_bh, format, bihs);
this->iv.m_bh->biSize = bihs;
this->iv.m_State = STOP;
//this->iv.m_pFrame = 0;
this->iv.m_Mode = DIRECT;
this->iv.m_iDecpos = 0;
this->iv.m_iPlaypos = -1;
this->iv.m_fQuality = 0.0f;
this->iv.m_bCapable16b = true;
bihs += sizeof(VIDEOINFOHEADER) - sizeof(BITMAPINFOHEADER);
this->m_sVhdr = malloc(bihs);
memset(this->m_sVhdr, 0, bihs);
memcpy(&this->m_sVhdr->bmiHeader, this->iv.m_bh, this->iv.m_bh->biSize);
this->m_sVhdr->rcSource.left = this->m_sVhdr->rcSource.top = 0;
this->m_sVhdr->rcSource.right = this->m_sVhdr->bmiHeader.biWidth;
this->m_sVhdr->rcSource.bottom = this->m_sVhdr->bmiHeader.biHeight;
//this->m_sVhdr->rcSource.right = 0;
//this->m_sVhdr->rcSource.bottom = 0;
this->m_sVhdr->rcTarget = this->m_sVhdr->rcSource;
this->m_sOurType.majortype = MEDIATYPE_Video;
this->m_sOurType.subtype = MEDIATYPE_Video;
this->m_sOurType.subtype.f1 = this->m_sVhdr->bmiHeader.biCompression;
this->m_sOurType.formattype = FORMAT_VideoInfo;
this->m_sOurType.bFixedSizeSamples = false;
this->m_sOurType.bTemporalCompression = true;
this->m_sOurType.pUnk = 0;
this->m_sOurType.cbFormat = bihs;
this->m_sOurType.pbFormat = (char*)this->m_sVhdr;
if(is_mpegts_format) {
if(is_wvc1_video = is_wvc1(this->m_sVhdr->bmiHeader.biCompression)) {
this->m_sOurType.pbFormat = (char*)ConvertToWVC1(this->m_sVhdr, &size);
this->m_sOurType.cbFormat = size;
}
}
this->m_sVhdr2 = (VIDEOINFOHEADER*)(malloc(sizeof(VIDEOINFOHEADER)+12));
memcpy(this->m_sVhdr2, this->m_sVhdr, sizeof(VIDEOINFOHEADER));
memset((char*)this->m_sVhdr2 + sizeof(VIDEOINFOHEADER), 0, 12);
this->m_sVhdr2->bmiHeader.biCompression = 0;
this->m_sVhdr2->bmiHeader.biBitCount = 24;
// memset((char*)this->m_sVhdr2, 0, sizeof(VIDEOINFOHEADER)+12);
this->m_sVhdr2->rcTarget = this->m_sVhdr->rcTarget;
// this->m_sVhdr2->rcSource = this->m_sVhdr->rcSource;
memset(&this->m_sDestType, 0, sizeof(this->m_sDestType));
this->m_sDestType.majortype = MEDIATYPE_Video;
if(!strcasecmp(dllname, "wmvdecod.dll")) {
if(is_mpegts_format && is_wvc1_video)
this->m_sDestType.subtype = FORMAT_WVC1Video;
else
this->m_sDestType.subtype = GUID_NULL;
} else
this->m_sDestType.subtype = MEDIASUBTYPE_RGB24;
this->m_sDestType.formattype = FORMAT_VideoInfo;
this->m_sDestType.bFixedSizeSamples = true;
this->m_sDestType.bTemporalCompression = false;
this->m_sDestType.lSampleSize = labs(this->m_sVhdr2->bmiHeader.biWidth*this->m_sVhdr2->bmiHeader.biHeight
* ((this->m_sVhdr2->bmiHeader.biBitCount + 7) / 8));
this->m_sVhdr2->bmiHeader.biSizeImage = this->m_sDestType.lSampleSize;
this->m_sDestType.pUnk = 0;
this->m_sDestType.cbFormat = sizeof(VIDEOINFOHEADER);
this->m_sDestType.pbFormat = (char*)this->m_sVhdr2;
memset(&this->iv.m_obh, 0, sizeof(this->iv.m_obh));
memcpy(&this->iv.m_obh, this->iv.m_bh, sizeof(this->iv.m_obh) < (unsigned) this->iv.m_bh->biSize
? sizeof(this->iv.m_obh) : (unsigned) this->iv.m_bh->biSize);
this->iv.m_obh.biBitCount=24;
this->iv.m_obh.biSize = sizeof(BITMAPINFOHEADER);
this->iv.m_obh.biCompression = 0; //BI_RGB
//this->iv.m_obh.biHeight = labs(this->iv.m_obh.biHeight);
this->iv.m_obh.biSizeImage = labs(this->iv.m_obh.biWidth * this->iv.m_obh.biHeight)
* ((this->iv.m_obh.biBitCount + 7) / 8);
this->m_pDMO_Filter = DMO_FilterCreate(dllname, guid, &this->m_sOurType, &this->m_sDestType);
if (!this->m_pDMO_Filter)
{
fprintf(stderr, "Failed to create DMO filter\n");
return 0;
}
if (!flip)
{
this->iv.m_obh.biHeight *= -1;
this->m_sVhdr2->bmiHeader.biHeight = this->iv.m_obh.biHeight;
// result = this->m_pDMO_Filter->m_pOutputPin->vt->QueryAccept(this->m_pDMO_Filter->m_pOutputPin, &this->m_sDestType);
result = this->m_pDMO_Filter->m_pMedia->vt->SetOutputType(this->m_pDMO_Filter->m_pMedia, 0, &this->m_sDestType, DMO_SET_TYPEF_TEST_ONLY);
if (result)
{
fprintf(stderr, "Decoder does not support upside-down RGB frames\n");
this->iv.m_obh.biHeight *= -1;
this->m_sVhdr2->bmiHeader.biHeight = this->iv.m_obh.biHeight;
}
}
memcpy( &this->iv.m_decoder, &this->iv.m_obh, sizeof(this->iv.m_obh) );
switch (this->iv.m_bh->biCompression)
{
#if 0
case fccDIV3:
case fccDIV4:
case fccDIV5:
case fccDIV6:
case fccMP42:
case fccWMV2:
//YV12 seems to be broken for DivX :-) codec
// case fccIV50:
//produces incorrect picture
//m_Caps = (CAPS) (m_Caps & ~CAP_YV12);
//m_Caps = CAP_UYVY;//CAP_YUY2; // | CAP_I420;
//m_Caps = CAP_I420;
this->m_Caps = (CAP_YUY2 | CAP_UYVY);
break;
#endif
default:
this->m_Caps = CAP_NONE;
fprintf(stderr, "Decoder supports the following formats: ");
for (c = check; c->bits; c++)
{
this->m_sVhdr2->bmiHeader.biBitCount = c->bits;
this->m_sVhdr2->bmiHeader.biCompression = c->fcc;
this->m_sDestType.subtype = *c->subtype;
//result = this->m_pDMO_Filter->m_pOutputPin->vt->QueryAccept(this->m_pDMO_Filter->m_pOutputPin, &this->m_sDestType);
result = this->m_pDMO_Filter->m_pMedia->vt->SetOutputType(this->m_pDMO_Filter->m_pMedia, 0, &this->m_sDestType, DMO_SET_TYPEF_TEST_ONLY);
if (!result)
{
this->m_Caps = (this->m_Caps | c->cap);
if (c->name)
fprintf(stderr, "%s ", c->name);
else
fprintf(stderr, "%.4s ", (char*) &c->fcc);
}
}
fprintf(stderr, "\n");
}
if (this->m_Caps != CAP_NONE)
fprintf(stderr, "Decoder is capable of YUV output (flags 0x%x)\n", (int)this->m_Caps);
this->m_sVhdr2->bmiHeader.biBitCount = 24;
this->m_sVhdr2->bmiHeader.biCompression = 0;
this->m_sDestType.subtype = MEDIASUBTYPE_RGB24;
this->m_iMinBuffers = this->iv.VBUFSIZE;
}
/*catch (FatalError& error)
{
delete[] m_sVhdr;
delete[] m_sVhdr2;
delete m_pDMO_Filter;
throw;
}*/
return this;
}
DS_AudioDecoder * DS_AudioDecoder_Open(char* dllname, GUID* guid, WAVEFORMATEX* wf)
//DS_AudioDecoder * DS_AudioDecoder_Create(const CodecInfo * info, const WAVEFORMATEX* wf)
{
DS_AudioDecoder *this;
int sz;
WAVEFORMATEX* pWF;
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
Setup_FS_Segment();
#endif
this = malloc(sizeof(DS_AudioDecoder));
sz = 18 + wf->cbSize;
this->m_sVhdr = malloc(sz);
memcpy(this->m_sVhdr, wf, sz);
this->m_sVhdr2 = malloc(18);
memcpy(this->m_sVhdr2, this->m_sVhdr, 18);
pWF = (WAVEFORMATEX*)this->m_sVhdr2;
pWF->wFormatTag = 1;
pWF->wBitsPerSample = 16;
pWF->nBlockAlign = pWF->nChannels * (pWF->wBitsPerSample + 7) / 8;
pWF->cbSize = 0;
pWF->nAvgBytesPerSec = pWF->nBlockAlign * pWF->nSamplesPerSec;
memcpy(&this->in_fmt,wf,sizeof(WAVEFORMATEX));
memset(&this->m_sOurType, 0, sizeof(this->m_sOurType));
this->m_sOurType.majortype=MEDIATYPE_Audio;
this->m_sOurType.subtype=MEDIASUBTYPE_PCM;
this->m_sOurType.subtype.f1=wf->wFormatTag;
this->m_sOurType.formattype=FORMAT_WaveFormatEx;
this->m_sOurType.lSampleSize=wf->nBlockAlign;
this->m_sOurType.bFixedSizeSamples=1;
this->m_sOurType.bTemporalCompression=0;
this->m_sOurType.pUnk=0;
this->m_sOurType.cbFormat=sz;
this->m_sOurType.pbFormat=this->m_sVhdr;
memset(&this->m_sDestType, 0, sizeof(this->m_sDestType));
this->m_sDestType.majortype=MEDIATYPE_Audio;
this->m_sDestType.subtype=MEDIASUBTYPE_PCM;
// this->m_sDestType.subtype.f1=pWF->wFormatTag;
this->m_sDestType.formattype=FORMAT_WaveFormatEx;
this->m_sDestType.bFixedSizeSamples=1;
this->m_sDestType.bTemporalCompression=0;
this->m_sDestType.lSampleSize=pWF->nBlockAlign;
if (wf->wFormatTag == 0x130)
// ACEL hack to prevent memory corruption
// obviosly we are missing something here
this->m_sDestType.lSampleSize *= 288;
this->m_sDestType.pUnk=0;
this->m_sDestType.cbFormat=18; //pWF->cbSize;
this->m_sDestType.pbFormat=this->m_sVhdr2;
//print_wave_header(this->m_sVhdr, MSGL_V);
//print_wave_header(this->m_sVhdr2, MSGL_V);
/*try*/
{
memset(&sampleProcData, 0, sizeof(sampleProcData));
this->m_pDS_Filter = DS_FilterCreate(dllname, guid, &this->m_sOurType, &this->m_sDestType,&sampleProcData);
if( !this->m_pDS_Filter ) {
free(this);
return NULL;
}
//Commit should be done before binary codec start
this->m_pDS_Filter->m_pAll->vt->Commit(this->m_pDS_Filter->m_pAll);
this->m_pDS_Filter->Start(this->m_pDS_Filter);
}
/*
catch (FatalError& e)
{
e.PrintAll();
delete[] m_sVhdr;
delete[] m_sVhdr2;
delete m_pDS_Filter;
throw;
}
*/
return this;
}
/*****************************************************************************
* QTAudioInit:
*****************************************************************************/
static int QTAudioInit( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
#ifdef __APPLE__
p_sys->SoundConverterOpen = (void*)SoundConverterOpen;
p_sys->SoundConverterClose = (void*)SoundConverterClose;
p_sys->SoundConverterSetInfo = (void*)SoundConverterSetInfo;
p_sys->SoundConverterGetBufferSizes = (void*)SoundConverterGetBufferSizes;
p_sys->SoundConverterConvertBuffer = (void*)SoundConverterConvertBuffer;
p_sys->SoundConverterBeginConversion= (void*)SoundConverterBeginConversion;
p_sys->SoundConverterEndConversion = (void*)SoundConverterEndConversion;
#else
#ifdef LOADER
p_sys->ldt_fs = Setup_LDT_Keeper();
#endif /* LOADER */
p_sys->qts = LoadLibraryA( "QuickTime.qts" );
if( p_sys->qts == NULL )
{
msg_Dbg( p_dec, "failed loading QuickTime.qts" );
return VLC_EGENERIC;
}
p_sys->qtml = LoadLibraryA( "qtmlClient.dll" );
if( p_sys->qtml == NULL )
{
msg_Dbg( p_dec, "failed loading qtmlClient.dll" );
return VLC_EGENERIC;
}
// sunqueen modify start
p_sys->InitializeQTML = (OSErr (__cdecl *)(long))GetProcAddress( p_sys->qtml, "InitializeQTML" );
p_sys->TerminateQTML = (OSErr (__cdecl *)(void))GetProcAddress( p_sys->qtml, "TerminateQTML" );
p_sys->SoundConverterOpen = (int (__cdecl *)(const SoundComponentData *,const SoundComponentData *,SoundConverter *))GetProcAddress( p_sys->qtml, "SoundConverterOpen" );
p_sys->SoundConverterClose = (int (__cdecl *)(SoundConverter))GetProcAddress( p_sys->qtml, "SoundConverterClose" );
p_sys->SoundConverterSetInfo = (int (__cdecl *)(SoundConverter,OSType,void *))GetProcAddress( p_sys->qtml, "SoundConverterSetInfo" );
p_sys->SoundConverterGetBufferSizes = (int (__cdecl *)(SoundConverter,unsigned long,unsigned long *,unsigned long *,unsigned long *))GetProcAddress( p_sys->qtml, "SoundConverterGetBufferSizes" );
p_sys->SoundConverterConvertBuffer = (int (__cdecl *)(SoundConverter,const void *,unsigned long,void *,unsigned long *,unsigned long *))GetProcAddress( p_sys->qtml, "SoundConverterConvertBuffer" );
p_sys->SoundConverterEndConversion = (int (__cdecl *)(SoundConverter,void *,unsigned long *,unsigned long *))GetProcAddress( p_sys->qtml, "SoundConverterEndConversion" );
p_sys->SoundConverterBeginConversion= (int (__cdecl *)(SoundConverter))GetProcAddress( p_sys->qtml, "SoundConverterBeginConversion");
// sunqueen modify end
if( p_sys->InitializeQTML == NULL )
{
msg_Err( p_dec, "failed getting proc address InitializeQTML" );
return VLC_EGENERIC;
}
if( p_sys->SoundConverterOpen == NULL ||
p_sys->SoundConverterClose == NULL ||
p_sys->SoundConverterSetInfo == NULL ||
p_sys->SoundConverterGetBufferSizes == NULL ||
p_sys->SoundConverterConvertBuffer == NULL ||
p_sys->SoundConverterEndConversion == NULL ||
p_sys->SoundConverterBeginConversion == NULL )
{
msg_Err( p_dec, "failed getting proc address" );
return VLC_EGENERIC;
}
msg_Dbg( p_dec, "standard init done" );
#endif /* else __APPLE__ */
return VLC_SUCCESS;
}
DMO_AudioDecoder * DMO_AudioDecoder_Open(const char* dllname, GUID* guid, WAVEFORMATEX* wf,int out_channels)
//DMO_AudioDecoder * DMO_AudioDecoder_Create(const CodecInfo * info, const WAVEFORMATEX* wf)
{
DMO_AudioDecoder *this;
int sz;
WAVEFORMATEX* pWF;
#ifdef LDT_paranoia
Setup_LDT_Keeper();
Setup_FS_Segment();
#endif
this = malloc(sizeof(DMO_AudioDecoder));
this->m_iFlushed=1;
sz = 18 + wf->cbSize;
this->m_sVhdr = malloc(sz);
memcpy(this->m_sVhdr, wf, sz);
this->m_sVhdr2 = malloc(18);
memcpy(this->m_sVhdr2, this->m_sVhdr, 18);
pWF = (WAVEFORMATEX*)this->m_sVhdr2;
pWF->wFormatTag = 1;
pWF->wBitsPerSample = 16;
pWF->nChannels = out_channels;
pWF->nBlockAlign = 2*pWF->nChannels; //pWF->nChannels * (pWF->wBitsPerSample + 7) / 8;
pWF->nAvgBytesPerSec = pWF->nBlockAlign * pWF->nSamplesPerSec;
pWF->cbSize = 0;
memset(&this->m_sOurType, 0, sizeof(this->m_sOurType));
this->m_sOurType.majortype=MEDIATYPE_Audio;
this->m_sOurType.subtype=MEDIASUBTYPE_PCM;
this->m_sOurType.subtype.f1=wf->wFormatTag;
this->m_sOurType.formattype=FORMAT_WaveFormatEx;
this->m_sOurType.lSampleSize=wf->nBlockAlign;
this->m_sOurType.bFixedSizeSamples=1;
this->m_sOurType.bTemporalCompression=0;
this->m_sOurType.cbFormat=sz;
this->m_sOurType.pbFormat=this->m_sVhdr;
memset(&this->m_sDestType, 0, sizeof(this->m_sDestType));
this->m_sDestType.majortype=MEDIATYPE_Audio;
this->m_sDestType.subtype=MEDIASUBTYPE_PCM;
this->m_sDestType.formattype=FORMAT_WaveFormatEx;
this->m_sDestType.bFixedSizeSamples=1;
this->m_sDestType.bTemporalCompression=0;
this->m_sDestType.lSampleSize=pWF->nBlockAlign;
this->m_sDestType.cbFormat=18; //pWF->cbSize;
this->m_sDestType.pbFormat=this->m_sVhdr2;
#if 0
print_wave_header((WAVEFORMATEX *)this->m_sVhdr);
print_wave_header((WAVEFORMATEX *)this->m_sVhdr2);
#endif
this->m_pDMO_Filter = DMO_FilterCreate(dllname, guid, &this->m_sOurType, &this->m_sDestType);
if( !this->m_pDMO_Filter ) {
free(this->m_sVhdr);
free(this->m_sVhdr2);
free(this);
return NULL;
}
return this;
}
// init driver
static int init(sh_video_t *sh){
OSErr result = 1;
int extradata_size = sh->bih ? sh->bih->biSize - sizeof(*sh->bih) : 0;
void *extradata = sh->bih + 1;
if (!sh->ImageDesc)
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"sh->ImageDesc not set, try -demuxer mov if this fails.\n");
#ifndef CONFIG_QUICKTIME
#ifdef WIN32_LOADER
Setup_LDT_Keeper();
#endif
//preload quicktime.qts to avoid the problems caused by the hardcoded path inside the dll
qtime_qts = LoadLibraryA("QuickTime.qts");
if(!qtime_qts){
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"unable to load QuickTime.qts\n" );
return 0;
}
handler = LoadLibraryA("qtmlClient.dll");
if(!handler){
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"unable to load qtmlClient.dll\n");
return 0;
}
InitializeQTML = (OSErr (*)(long))GetProcAddress(handler, "InitializeQTML");
EnterMovies = (OSErr (*)(void))GetProcAddress(handler, "EnterMovies");
ExitMovies = (void (*)(void))GetProcAddress(handler, "ExitMovies");
DecompressSequenceBegin = (OSErr (*)(ImageSequence*,ImageDescriptionHandle,CGrafPtr,void *,const Rect *,MatrixRecordPtr,short,RgnHandle,CodecFlags,CodecQ,DecompressorComponent))GetProcAddress(handler, "DecompressSequenceBegin");
DecompressSequenceFrameS = (OSErr (*)(ImageSequence,Ptr,long,CodecFlags,CodecFlags*,ICMCompletionProcRecordPtr))GetProcAddress(handler, "DecompressSequenceFrameS");
GetGWorldPixMap = (PixMapHandle (*)(GWorldPtr))GetProcAddress(handler, "GetGWorldPixMap");
QTNewGWorldFromPtr = (OSErr(*)(GWorldPtr *,OSType,const Rect *,CTabHandle,void*,GWorldFlags,void *,long))GetProcAddress(handler, "QTNewGWorldFromPtr");
NewHandleClear = (OSErr(*)(Size))GetProcAddress(handler, "NewHandleClear");
DisposeHandle = (void (*)(Handle))GetProcAddress(handler, "DisposeHandle");
DisposeGWorld = (void (*)(GWorldPtr))GetProcAddress(handler, "DisposeGWorld");
CDSequenceEnd = (OSErr (*)(ImageSequence))GetProcAddress(handler, "CDSequenceEnd");
if(!InitializeQTML || !EnterMovies || !DecompressSequenceBegin || !DecompressSequenceFrameS){
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"invalid qtmlClient.dll!\n");
return 0;
}
result=InitializeQTML(kInitializeQTMLDisableDirectSound |
kInitializeQTMLUseGDIFlag |
kInitializeQTMLDisableDDClippers);
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"InitializeQTML returned %d\n",result);
#endif /* CONFIG_QUICKTIME */
result=EnterMovies();
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"EnterMovies returned %d\n",result);
//make a yuy2 gworld
OutBufferRect.top=0;
OutBufferRect.left=0;
OutBufferRect.right=sh->disp_w;
OutBufferRect.bottom=sh->disp_h;
//Fill the imagedescription for our SVQ3 frame
//we can probably get this from Demuxer
if (!sh->ImageDesc && extradata_size >= sizeof(ImageDescription) &&
((ImageDescription *)extradata)->idSize <= extradata_size)
sh->ImageDesc = extradata;
if (sh->ImageDesc) {
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"ImageDescription size: %d\n",((ImageDescription*)(sh->ImageDesc))->idSize);
framedescHandle=(ImageDescriptionHandle)NewHandleClear(((ImageDescription*)(sh->ImageDesc))->idSize);
memcpy(*framedescHandle,sh->ImageDesc,((ImageDescription*)(sh->ImageDesc))->idSize);
} else {
// assume extradata consists only of the atoms, build the other parts
ImageDescription *idesc;
int size = sizeof(*idesc) + extradata_size;
mp_msg(MSGT_DECVIDEO, MSGL_V, "Generating a ImageDescription\n");
framedescHandle=(ImageDescriptionHandle)NewHandleClear(size);
idesc = *framedescHandle;
memcpy(idesc + 1, extradata, extradata_size);
idesc->idSize = size;
idesc->width = sh->disp_w;
idesc->height = sh->disp_h;
}
dump_ImageDescription(*framedescHandle);
(**framedescHandle).cType = bswap_32(sh->format);
sh->context = (void *)kYUVSPixelFormat;
{
int imgfmt = sh->codec->outfmt[sh->outfmtidx];
int qt_imgfmt;
switch(imgfmt)
{
case IMGFMT_YUY2:
qt_imgfmt = kYUVSPixelFormat;
break;
case IMGFMT_YVU9:
qt_imgfmt = 0x73797639; //kYVU9PixelFormat;
break;
case IMGFMT_YV12:
qt_imgfmt = 0x79343230;
break;
case IMGFMT_UYVY:
qt_imgfmt = k2vuyPixelFormat;
break;
case IMGFMT_YVYU:
qt_imgfmt = kYVYU422PixelFormat;
imgfmt = IMGFMT_YUY2;
break;
case IMGFMT_RGB16:
qt_imgfmt = k16LE555PixelFormat;
break;
case IMGFMT_BGR24:
qt_imgfmt = k24BGRPixelFormat;
break;
case IMGFMT_BGR32:
qt_imgfmt = k32BGRAPixelFormat;
break;
case IMGFMT_RGB32:
qt_imgfmt = k32RGBAPixelFormat;
break;
default:
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Unknown requested csp\n");
return 0;
}
mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"imgfmt: %s qt_imgfmt: %.4s\n", vo_format_name(imgfmt), (char *)&qt_imgfmt);
sh->context = (void *)qt_imgfmt;
if(!mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,imgfmt)) return 0;
}
mpi=mpcodecs_get_image(sh, MP_IMGTYPE_STATIC, MP_IMGFLAG_PRESERVE,
sh->disp_w, sh->disp_h);
if(!mpi) return 0;
result = QTNewGWorldFromPtr(
&OutBufferGWorld,
(OSType)sh->context,
&OutBufferRect, //we should benchmark if yvu9 is faster for svq3, too
0,
0,
0,
mpi->planes[0],
mpi->stride[0]);
if (result) {
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"QTNewGWorldFromPtr result=%d\n",result);
return 0;
}
result = DecompressSequenceBegin(&imageSeq, framedescHandle, (CGrafPtr)OutBufferGWorld,
NULL, NULL, NULL, srcCopy, NULL, 0,
codecNormalQuality, 0);
if(result) {
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"DecompressSequenceBegin result=%d\n",result);
return 0;
}
return 1;
}
/*
=================
Host_InitCommon
=================
*/
void Host_InitCommon( int argc, const char** argv, const char *progname, qboolean bChangeGame )
{
char dev_level[4];
char *baseDir;
// some commands may turn engine into infinite loop,
// e.g. xash.exe +game xash -game xash
// so we clear all cmd_args, but leave dbg states as well
Sys_ParseCommandLine( argc, argv );
host.enabledll = !Sys_CheckParm( "-nodll" );
host.shutdown_issued = false;
host.crashed = false;
#ifdef DLL_LOADER
if( host.enabledll )
Setup_LDT_Keeper( ); // Must call before any thread creating
#endif
#if defined(XASH_SDL) && !(defined(PANDORA) || defined(RPI))
if( SDL_Init( SDL_INIT_VIDEO |
SDL_INIT_TIMER |
SDL_INIT_AUDIO |
SDL_INIT_JOYSTICK |
SDL_INIT_EVENTS ))
{
Sys_Error( "SDL_Init: %s", SDL_GetError() );
}
#endif
if( ( baseDir = getenv( "XASH3D_BASEDIR" ) ) )
{
Q_strncpy( host.rootdir, baseDir, sizeof(host.rootdir) );
}
else
{
#if defined(PANDORA) || defined(RPI)
Q_strncpy( host.rootdir, ".", sizeof( host.rootdir ) );
#else
#if defined(XASH_SDL)
if( !( baseDir = SDL_GetBasePath() ) )
Sys_Error( "couldn't determine current directory: %s", SDL_GetError() );
Q_strncpy( host.rootdir, baseDir, sizeof( host.rootdir ) );
#else
if( !getcwd( host.rootdir, sizeof(host.rootdir) ) )
host.rootdir[0] = 0;
#endif
#endif
}
if( host.rootdir[Q_strlen( host.rootdir ) - 1] == '/' )
host.rootdir[Q_strlen( host.rootdir ) - 1] = 0;
if( !Sys_CheckParm( "-noch" ) )
{
Sys_SetupCrashHandler();
}
host.change_game = bChangeGame;
host.state = HOST_INIT; // initialization started
host.developer = host.old_developer = 0;
host.textmode = false;
host.mempool = Mem_AllocPool( "Zone Engine" );
if( Sys_CheckParm( "-console" )) host.developer = 1;
if( Sys_CheckParm( "-dev" ))
{
if( Sys_GetParmFromCmdLine( "-dev", dev_level ))
{
if( Q_isdigit( dev_level ))
host.developer = abs( Q_atoi( dev_level ));
else host.developer++; // -dev == 1, -dev -console == 2
}
else host.developer++; // -dev == 1, -dev -console == 2
}
#ifdef XASH_DEDICATED
host.type = HOST_DEDICATED; // predict state
#else
if( Sys_CheckParm("-dedicated") || progname[0] == '#' )
host.type = HOST_DEDICATED;
else host.type = HOST_NORMAL;
#endif
host.con_showalways = true;
host.mouse_visible = false;
#ifdef XASH_SDL
if( SDL_Init( SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS ))
{
SDL_Init( SDL_INIT_TIMER );
host.type = HOST_DEDICATED;
}
#endif
if ( SetCurrentDirectory( host.rootdir ) != 0)
MsgDev( D_INFO, "%s is working directory now\n", host.rootdir );
else
Sys_Error( "Changing working directory to %s failed.\n", host.rootdir );
// set default gamedir
if( progname[0] == '#' ) progname++;
Q_strncpy( SI.ModuleName, progname, sizeof( SI.ModuleName ));
if( host.type == HOST_DEDICATED )
{
Sys_MergeCommandLine( );
if( host.developer < 3 ) host.developer = 3; // otherwise we see empty console
}
else
{
// don't show console as default
if( host.developer < D_WARN ) host.con_showalways = false;
}
host.old_developer = host.developer;
if( !Sys_CheckParm( "-nowcon" ) )
Con_CreateConsole();
// first text message into console or log
MsgDev( D_NOTE, "Sys_LoadLibrary: Loading Engine Library - ok\n" );
// startup cmds and cvars subsystem
Cmd_Init();
Cvar_Init();
// share developer level across all dlls
Q_snprintf( dev_level, sizeof( dev_level ), "%i", host.developer );
Cvar_Get( "developer", dev_level, CVAR_INIT, "current developer level" );
Cmd_AddCommand( "exec", Host_Exec_f, "execute a script file" );
Cmd_AddCommand( "memlist", Host_MemStats_f, "prints memory pool information" );
Cmd_AddCommand( "userconfigd", Host_Userconfigd_f, "execute all scripts from userconfig.d" );
cmd_scripting = Cvar_Get( "cmd_scripting", "0", CVAR_ARCHIVE, "enable simple condition checking and variable operations" );
FS_Init();
Image_Init();
Sound_Init();
FS_LoadGameInfo( NULL );
Q_strncpy( host.gamefolder, GI->gamefolder, sizeof( host.gamefolder ));
#if !(defined(PANDORA) || defined(RPI))
if( GI->secure )
{
// clear all developer levels when game is protected
Cvar_FullSet( "developer", "0", CVAR_INIT );
host.developer = host.old_developer = 0;
host.con_showalways = false;
}
#endif
HPAK_Init();
IN_Init();
Key_Init();
}
