/* * Copyright 1999 Marcus Meissner * Copyright 2002-2003 Michael Günnewig * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #define COBJMACROS #define COM_NO_WINDOWS_H #include "windef.h" #include "winbase.h" #include "winnls.h" #include "wingdi.h" #include "winuser.h" #include "winreg.h" #include "winerror.h" #include "ole2.h" #include "shellapi.h" #include "shlobj.h" #include "vfw.h" #include "msacm.h" #include "avifile_private.h" #include "wine/debug.h" #include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(avifile); /*********************************************************************** * for AVIBuildFilterW -- uses fixed size table */ #define MAX_FILTERS 30 /* 30 => 7kB */ typedef struct _AVIFilter { WCHAR szClsid[40]; WCHAR szExtensions[MAX_FILTERS * 7]; } AVIFilter; /*********************************************************************** * for AVISaveOptions */ static struct { UINT uFlags; INT nStreams; PAVISTREAM *ppavis; LPAVICOMPRESSOPTIONS *ppOptions; INT nCurrent; } SaveOpts; /*********************************************************************** * copied from dlls/ole32/compobj.c */ static HRESULT AVIFILE_CLSIDFromString(LPCSTR idstr, LPCLSID id) { BYTE const *s; BYTE *p; INT i; BYTE table[256]; if (!idstr) { memset(id, 0, sizeof(CLSID)); return S_OK; } /* validate the CLSID string */ if (lstrlenA(idstr) != 38) return CO_E_CLASSSTRING; s = (BYTE const*)idstr; if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') || (s[24]!='-') || (s[37]!='}')) return CO_E_CLASSSTRING; for (i = 1; i < 37; i++) { if ((i == 9) || (i == 14) || (i == 19) || (i == 24)) continue; if (!(((s[i] >= '0') && (s[i] <= '9')) || ((s[i] >= 'a') && (s[i] <= 'f')) || ((s[i] >= 'A') && (s[i] <= 'F'))) ) return CO_E_CLASSSTRING; } TRACE("%s -> %p\n", s, id); /* quick lookup table */ memset(table, 0, 256); for (i = 0; i < 10; i++) table['0' + i] = i; for (i = 0; i < 6; i++) { table['A' + i] = i+10; table['a' + i] = i+10; } /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */ p = (BYTE *) id; s++; /* skip leading brace */ for (i = 0; i < 4; i++) { p[3 - i] = table[*s]<<4 | table[*(s+1)]; s += 2; } p += 4; s++; /* skip - */ for (i = 0; i < 2; i++) { p[1-i] = table[*s]<<4 | table[*(s+1)]; s += 2; } p += 2; s++; /* skip - */ for (i = 0; i < 2; i++) { p[1-i] = table[*s]<<4 | table[*(s+1)]; s += 2; } p += 2; s++; /* skip - */ /* these are just sequential bytes */ for (i = 0; i < 2; i++) { *p++ = table[*s]<<4 | table[*(s+1)]; s += 2; } s++; /* skip - */ for (i = 0; i < 6; i++) { *p++ = table[*s]<<4 | table[*(s+1)]; s += 2; } return S_OK; } static BOOL AVIFILE_GetFileHandlerByExtension(LPCWSTR szFile, LPCLSID lpclsid) { CHAR szRegKey[25]; CHAR szValue[100]; LPWSTR szExt = strrchrW(szFile, '.'); LONG len = sizeof(szValue) / sizeof(szValue[0]); if (szExt == NULL) return FALSE; szExt++; wsprintfA(szRegKey, "AVIFile\\Extensions\\%.3ls", szExt); if (RegQueryValueA(HKEY_CLASSES_ROOT, szRegKey, szValue, &len) != ERROR_SUCCESS) return FALSE; return (AVIFILE_CLSIDFromString(szValue, lpclsid) == S_OK); } /*********************************************************************** * AVIFileInit (AVIFIL32.@) * AVIFileInit (AVIFILE.100) */ void WINAPI AVIFileInit(void) { OleInitialize(NULL); } /*********************************************************************** * AVIFileExit (AVIFIL32.@) * AVIFileExit (AVIFILE.101) */ void WINAPI AVIFileExit(void) { /* need to free ole32.dll if we are the last exit call */ /* OleUnitialize() */ FIXME("(): stub!\n"); } /*********************************************************************** * AVIFileOpen (AVIFIL32.@) * AVIFileOpenA (AVIFIL32.@) * AVIFileOpen (AVIFILE.102) */ HRESULT WINAPI AVIFileOpenA(PAVIFILE *ppfile, LPCSTR szFile, UINT uMode, LPCLSID lpHandler) { LPWSTR wszFile = NULL; HRESULT hr; int len; TRACE("(%p,%s,0x%08X,%s)\n", ppfile, debugstr_a(szFile), uMode, debugstr_guid(lpHandler)); /* check parameters */ if (ppfile == NULL || szFile == NULL) return AVIERR_BADPARAM; /* convert ASCII string to Unicode and call unicode function */ len = MultiByteToWideChar(CP_ACP, 0, szFile, -1, NULL, 0); if (len <= 0) return AVIERR_BADPARAM; wszFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); if (wszFile == NULL) return AVIERR_MEMORY; MultiByteToWideChar(CP_ACP, 0, szFile, -1, wszFile, len); hr = AVIFileOpenW(ppfile, wszFile, uMode, lpHandler); HeapFree(GetProcessHeap(), 0, wszFile); return hr; } /*********************************************************************** * AVIFileOpenW (AVIFIL32.@) */ HRESULT WINAPI AVIFileOpenW(PAVIFILE *ppfile, LPCWSTR szFile, UINT uMode, LPCLSID lpHandler) { IPersistFile *ppersist = NULL; CLSID clsidHandler; HRESULT hr; TRACE("(%p,%s,0x%X,%s)\n", ppfile, debugstr_w(szFile), uMode, debugstr_guid(lpHandler)); /* check parameters */ if (ppfile == NULL || szFile == NULL) return AVIERR_BADPARAM; *ppfile = NULL; /* if no handler then try guessing it by extension */ if (lpHandler == NULL) { if (! AVIFILE_GetFileHandlerByExtension(szFile, &clsidHandler)) return AVIERR_UNSUPPORTED; } else memcpy(&clsidHandler, lpHandler, sizeof(clsidHandler)); /* create instance of handler */ hr = CoCreateInstance(&clsidHandler, NULL, CLSCTX_INPROC, &IID_IAVIFile, (LPVOID*)ppfile); if (FAILED(hr) || *ppfile == NULL) return hr; /* ask for IPersistFile interface for loading/creating the file */ hr = IAVIFile_QueryInterface(*ppfile, &IID_IPersistFile, (LPVOID*)&ppersist); if (FAILED(hr) || ppersist == NULL) { IAVIFile_Release(*ppfile); *ppfile = NULL; return hr; } hr = IPersistFile_Load(ppersist, szFile, uMode); IPersistFile_Release(ppersist); if (FAILED(hr)) { IAVIFile_Release(*ppfile); *ppfile = NULL; } return hr; } /*********************************************************************** * AVIFileAddRef (AVIFIL32.@) * AVIFileAddRef (AVIFILE.140) */ ULONG WINAPI AVIFileAddRef(PAVIFILE pfile) { TRACE("(%p)\n", pfile); if (pfile == NULL) { ERR(": bad handle passed!\n"); return 0; } return IAVIFile_AddRef(pfile); } /*********************************************************************** * AVIFileRelease (AVIFIL32.@) * AVIFileRelease (AVIFILE.141) */ ULONG WINAPI AVIFileRelease(PAVIFILE pfile) { TRACE("(%p)\n", pfile); if (pfile == NULL) { ERR(": bad handle passed!\n"); return 0; } return IAVIFile_Release(pfile); } /*********************************************************************** * AVIFileInfo (AVIFIL32.@) * AVIFileInfoA (AVIFIL32.@) * AVIFileInfo (AVIFILE.142) */ HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile, LPAVIFILEINFOA afi, LONG size) { AVIFILEINFOW afiw; HRESULT hres; TRACE("(%p,%p,%ld)\n", pfile, afi, size); if (pfile == NULL) return AVIERR_BADHANDLE; if ((DWORD)size < sizeof(AVIFILEINFOA)) return AVIERR_BADSIZE; hres = IAVIFile_Info(pfile, &afiw, sizeof(afiw)); memcpy(afi, &afiw, sizeof(*afi) - sizeof(afi->szFileType)); WideCharToMultiByte(CP_ACP, 0, afiw.szFileType, -1, afi->szFileType, sizeof(afi->szFileType), NULL, NULL); afi->szFileType[sizeof(afi->szFileType) - 1] = 0; return hres; } /*********************************************************************** * AVIFileInfoW (AVIFIL32.@) */ HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile, LPAVIFILEINFOW afiw, LONG size) { TRACE("(%p,%p,%ld)\n", pfile, afiw, size); if (pfile == NULL) return AVIERR_BADHANDLE; return IAVIFile_Info(pfile, afiw, size); } /*********************************************************************** * AVIFileGetStream (AVIFIL32.@) * AVIFileGetStream (AVIFILE.143) */ HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile, PAVISTREAM *avis, DWORD fccType, LONG lParam) { TRACE("(%p,%p,'%4.4s',%ld)\n", pfile, avis, (char*)&fccType, lParam); if (pfile == NULL) return AVIERR_BADHANDLE; return IAVIFile_GetStream(pfile, avis, fccType, lParam); } /*********************************************************************** * AVIFileCreateStream (AVIFIL32.@) * AVIFileCreateStreamA (AVIFIL32.@) * AVIFileCreateStream (AVIFILE.144) */ HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile, PAVISTREAM *ppavi, LPAVISTREAMINFOA psi) { AVISTREAMINFOW psiw; TRACE("(%p,%p,%p)\n", pfile, ppavi, psi); if (pfile == NULL) return AVIERR_BADHANDLE; /* Only the szName at the end is different */ memcpy(&psiw, psi, sizeof(*psi) - sizeof(psi->szName)); MultiByteToWideChar(CP_ACP, 0, psi->szName, -1, psiw.szName, sizeof(psiw.szName) / sizeof(psiw.szName[0])); return IAVIFile_CreateStream(pfile, ppavi, &psiw); } /*********************************************************************** * AVIFileCreateStreamW (AVIFIL32.@) */ HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile, PAVISTREAM *avis, LPAVISTREAMINFOW asi) { TRACE("(%p,%p,%p)\n", pfile, avis, asi); if (pfile == NULL) return AVIERR_BADHANDLE; return IAVIFile_CreateStream(pfile, avis, asi); } /*********************************************************************** * AVIFileWriteData (AVIFIL32.@) * AVIFileWriteData (AVIFILE.146) */ HRESULT WINAPI AVIFileWriteData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LONG size) { TRACE("(%p,'%4.4s',%p,%ld)\n", pfile, (char*)&fcc, lp, size); if (pfile == NULL) return AVIERR_BADHANDLE; return IAVIFile_WriteData(pfile, fcc, lp, size); } /*********************************************************************** * AVIFileReadData (AVIFIL32.@) * AVIFileReadData (AVIFILE.147) */ HRESULT WINAPI AVIFileReadData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LPLONG size) { TRACE("(%p,'%4.4s',%p,%p)\n", pfile, (char*)&fcc, lp, size); if (pfile == NULL) return AVIERR_BADHANDLE; return IAVIFile_ReadData(pfile, fcc, lp, size); } /*********************************************************************** * AVIFileEndRecord (AVIFIL32.@) * AVIFileEndRecord (AVIFILE.148) */ HRESULT WINAPI AVIFileEndRecord(PAVIFILE pfile) { TRACE("(%p)\n", pfile); if (pfile == NULL) return AVIERR_BADHANDLE; return IAVIFile_EndRecord(pfile); } /*********************************************************************** * AVIStreamAddRef (AVIFIL32.@) * AVIStreamAddRef (AVIFILE.160) */ ULONG WINAPI AVIStreamAddRef(PAVISTREAM pstream) { TRACE("(%p)\n", pstream); if (pstream == NULL) { ERR(": bad handle passed!\n"); return 0; } return IAVIStream_AddRef(pstream); } /*********************************************************************** * AVIStreamRelease (AVIFIL32.@) * AVIStreamRelease (AVIFILE.161) */ ULONG WINAPI AVIStreamRelease(PAVISTREAM pstream) { TRACE("(%p)\n", pstream); if (pstream == NULL) { ERR(": bad handle passed!\n"); return 0; } return IAVIStream_Release(pstream); } /*********************************************************************** * AVIStreamCreate (AVIFIL32.@) * AVIStreamCreate (AVIFILE.104) */ HRESULT WINAPI AVIStreamCreate(PAVISTREAM *ppavi, LONG lParam1, LONG lParam2, LPCLSID pclsidHandler) { HRESULT hr; TRACE("(%p,0x%08lX,0x%08lX,%s)\n", ppavi, lParam1, lParam2, debugstr_guid(pclsidHandler)); if (ppavi == NULL) return AVIERR_BADPARAM; *ppavi = NULL; if (pclsidHandler == NULL) return AVIERR_UNSUPPORTED; hr = CoCreateInstance(pclsidHandler, NULL, CLSCTX_INPROC, &IID_IAVIStream, (LPVOID*)ppavi); if (FAILED(hr) || *ppavi == NULL) return hr; hr = IAVIStream_Create(*ppavi, lParam1, lParam2); if (FAILED(hr)) { IAVIStream_Release(*ppavi); *ppavi = NULL; } return hr; } /*********************************************************************** * AVIStreamInfo (AVIFIL32.@) * AVIStreamInfoA (AVIFIL32.@) * AVIStreamInfo (AVIFILE.162) */ HRESULT WINAPI AVIStreamInfoA(PAVISTREAM pstream, LPAVISTREAMINFOA asi, LONG size) { AVISTREAMINFOW asiw; HRESULT hres; TRACE("(%p,%p,%ld)\n", pstream, asi, size); if (pstream == NULL) return AVIERR_BADHANDLE; if ((DWORD)size < sizeof(AVISTREAMINFOA)) return AVIERR_BADSIZE; hres = IAVIStream_Info(pstream, &asiw, sizeof(asiw)); memcpy(asi, &asiw, sizeof(asiw) - sizeof(asiw.szName)); WideCharToMultiByte(CP_ACP, 0, asiw.szName, -1, asi->szName, sizeof(asi->szName), NULL, NULL); asi->szName[sizeof(asi->szName) - 1] = 0; return hres; } /*********************************************************************** * AVIStreamInfoW (AVIFIL32.@) */ HRESULT WINAPI AVIStreamInfoW(PAVISTREAM pstream, LPAVISTREAMINFOW asi, LONG size) { TRACE("(%p,%p,%ld)\n", pstream, asi, size); if (pstream == NULL) return AVIERR_BADHANDLE; return IAVIStream_Info(pstream, asi, size); } /*********************************************************************** * AVIStreamFindSample (AVIFIL32.@) * AVIStreamFindSample (AVIFILE.163) */ HRESULT WINAPI AVIStreamFindSample(PAVISTREAM pstream, LONG pos, DWORD flags) { TRACE("(%p,%ld,0x%lX)\n", pstream, pos, flags); if (pstream == NULL) return -1; return IAVIStream_FindSample(pstream, pos, flags); } /*********************************************************************** * AVIStreamReadFormat (AVIFIL32.@) * AVIStreamReadFormat (AVIFILE.164) */ HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM pstream, LONG pos, LPVOID format, LPLONG formatsize) { TRACE("(%p,%ld,%p,%p)\n", pstream, pos, format, formatsize); if (pstream == NULL) return AVIERR_BADHANDLE; return IAVIStream_ReadFormat(pstream, pos, format, formatsize); } /*********************************************************************** * AVIStreamSetFormat (AVIFIL32.@) * AVIStreamSetFormat (AVIFILE.169) */ HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM pstream, LONG pos, LPVOID format, LONG formatsize) { TRACE("(%p,%ld,%p,%ld)\n", pstream, pos, format, formatsize); if (pstream == NULL) return AVIERR_BADHANDLE; return IAVIStream_SetFormat(pstream, pos, format, formatsize); } /*********************************************************************** * AVIStreamRead (AVIFIL32.@) * AVIStreamRead (AVIFILE.167) */ HRESULT WINAPI AVIStreamRead(PAVISTREAM pstream, LONG start, LONG samples, LPVOID buffer, LONG buffersize, LPLONG bytesread, LPLONG samplesread) { TRACE("(%p,%ld,%ld,%p,%ld,%p,%p)\n", pstream, start, samples, buffer, buffersize, bytesread, samplesread); if (pstream == NULL) return AVIERR_BADHANDLE; return IAVIStream_Read(pstream, start, samples, buffer, buffersize, bytesread, samplesread); } /*********************************************************************** * AVIStreamWrite (AVIFIL32.@) * AVIStreamWrite (AVIFILE.168) */ HRESULT WINAPI AVIStreamWrite(PAVISTREAM pstream, LONG start, LONG samples, LPVOID buffer, LONG buffersize, DWORD flags, LPLONG sampwritten, LPLONG byteswritten) { TRACE("(%p,%ld,%ld,%p,%ld,0x%lX,%p,%p)\n", pstream, start, samples, buffer, buffersize, flags, sampwritten, byteswritten); if (pstream == NULL) return AVIERR_BADHANDLE; return IAVIStream_Write(pstream, start, samples, buffer, buffersize, flags, sampwritten, byteswritten); } /*********************************************************************** * AVIStreamReadData (AVIFIL32.@) * AVIStreamReadData (AVIFILE.165) */ HRESULT WINAPI AVIStreamReadData(PAVISTREAM pstream, DWORD fcc, LPVOID lp, LPLONG lpread) { TRACE("(%p,'%4.4s',%p,%p)\n", pstream, (char*)&fcc, lp, lpread); if (pstream == NULL) return AVIERR_BADHANDLE; return IAVIStream_ReadData(pstream, fcc, lp, lpread); } /*********************************************************************** * AVIStreamWriteData (AVIFIL32.@) * AVIStreamWriteData (AVIFILE.166) */ HRESULT WINAPI AVIStreamWriteData(PAVISTREAM pstream, DWORD fcc, LPVOID lp, LONG size) { TRACE("(%p,'%4.4s',%p,%ld)\n", pstream, (char*)&fcc, lp, size); if (pstream == NULL) return AVIERR_BADHANDLE; return IAVIStream_WriteData(pstream, fcc, lp, size); } /*********************************************************************** * AVIStreamGetFrameOpen (AVIFIL32.@) * AVIStreamGetFrameOpen (AVIFILE.112) */ PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pstream, LPBITMAPINFOHEADER lpbiWanted) { PGETFRAME pg = NULL; TRACE("(%p,%p)\n", pstream, lpbiWanted); if (FAILED(IAVIStream_QueryInterface(pstream, &IID_IGetFrame, (LPVOID*)&pg)) || pg == NULL) { pg = AVIFILE_CreateGetFrame(pstream); if (pg == NULL) return NULL; } if (FAILED(IGetFrame_SetFormat(pg, lpbiWanted, NULL, 0, 0, -1, -1))) { IGetFrame_Release(pg); return NULL; } return pg; } /*********************************************************************** * AVIStreamGetFrame (AVIFIL32.@) * AVIStreamGetFrame (AVIFILE.110) */ LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pg, LONG pos) { TRACE("(%p,%ld)\n", pg, pos); if (pg == NULL) return NULL; return IGetFrame_GetFrame(pg, pos); } /*********************************************************************** * AVIStreamGetFrameClose (AVIFIL32.@) * AVIStreamGetFrameClose (AVIFILE.111) */ HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg) { TRACE("(%p)\n", pg); if (pg != NULL) return IGetFrame_Release(pg); return 0; } /*********************************************************************** * AVIMakeCompressedStream (AVIFIL32.@) */ HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed, PAVISTREAM psSource, LPAVICOMPRESSOPTIONS aco, LPCLSID pclsidHandler) { AVISTREAMINFOW asiw; CHAR szRegKey[25]; CHAR szValue[100]; CLSID clsidHandler; HRESULT hr; LONG size = sizeof(szValue); TRACE("(%p,%p,%p,%s)\n", ppsCompressed, psSource, aco, debugstr_guid(pclsidHandler)); if (ppsCompressed == NULL) return AVIERR_BADPARAM; if (psSource == NULL) return AVIERR_BADHANDLE; *ppsCompressed = NULL; /* if no handler given get default ones based on streamtype */ if (pclsidHandler == NULL) { hr = IAVIStream_Info(psSource, &asiw, sizeof(asiw)); if (FAILED(hr)) return hr; wsprintfA(szRegKey, "AVIFile\\Compressors\\%4.4s", (char*)&asiw.fccType); if (RegQueryValueA(HKEY_CLASSES_ROOT, szRegKey, szValue, &size) != ERROR_SUCCESS) return AVIERR_UNSUPPORTED; if (AVIFILE_CLSIDFromString(szValue, &clsidHandler) != S_OK) return AVIERR_UNSUPPORTED; } else memcpy(&clsidHandler, pclsidHandler, sizeof(clsidHandler)); hr = CoCreateInstance(&clsidHandler, NULL, CLSCTX_INPROC, &IID_IAVIStream, (LPVOID*)ppsCompressed); if (FAILED(hr) || *ppsCompressed == NULL) return hr; hr = IAVIStream_Create(*ppsCompressed, (LPARAM)psSource, (LPARAM)aco); if (FAILED(hr)) { IAVIStream_Release(*ppsCompressed); *ppsCompressed = NULL; } return hr; } /*********************************************************************** * AVIMakeFileFromStreams (AVIFIL32.@) */ HRESULT WINAPI AVIMakeFileFromStreams(PAVIFILE *ppfile, int nStreams, PAVISTREAM *ppStreams) { TRACE("(%p,%d,%p)\n", ppfile, nStreams, ppStreams); if (nStreams < 0 || ppfile == NULL || ppStreams == NULL) return AVIERR_BADPARAM; *ppfile = AVIFILE_CreateAVITempFile(nStreams, ppStreams); if (*ppfile == NULL) return AVIERR_MEMORY; return AVIERR_OK; } /*********************************************************************** * AVIStreamOpenFromFile (AVIFIL32.@) * AVIStreamOpenFromFileA (AVIFIL32.@) * AVIStreamOpenFromFile (AVIFILE.103) */ HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM *ppavi, LPCSTR szFile, DWORD fccType, LONG lParam, UINT mode, LPCLSID pclsidHandler) { PAVIFILE pfile = NULL; HRESULT hr; TRACE("(%p,%s,'%4.4s',%ld,0x%X,%s)\n", ppavi, debugstr_a(szFile), (char*)&fccType, lParam, mode, debugstr_guid(pclsidHandler)); if (ppavi == NULL || szFile == NULL) return AVIERR_BADPARAM; *ppavi = NULL; hr = AVIFileOpenA(&pfile, szFile, mode, pclsidHandler); if (FAILED(hr) || pfile == NULL) return hr; hr = IAVIFile_GetStream(pfile, ppavi, fccType, lParam); IAVIFile_Release(pfile); return hr; } /*********************************************************************** * AVIStreamOpenFromFileW (AVIFIL32.@) */ HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM *ppavi, LPCWSTR szFile, DWORD fccType, LONG lParam, UINT mode, LPCLSID pclsidHandler) { PAVIFILE pfile = NULL; HRESULT hr; TRACE("(%p,%s,'%4.4s',%ld,0x%X,%s)\n", ppavi, debugstr_w(szFile), (char*)&fccType, lParam, mode, debugstr_guid(pclsidHandler)); if (ppavi == NULL || szFile == NULL) return AVIERR_BADPARAM; *ppavi = NULL; hr = AVIFileOpenW(&pfile, szFile, mode, pclsidHandler); if (FAILED(hr) || pfile == NULL) return hr; hr = IAVIFile_GetStream(pfile, ppavi, fccType, lParam); IAVIFile_Release(pfile); return hr; } /*********************************************************************** * AVIStreamBeginStreaming (AVIFIL32.@) */ LONG WINAPI AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate) { IAVIStreaming* pstream = NULL; HRESULT hr; TRACE("(%p,%ld,%ld,%ld)\n", pavi, lStart, lEnd, lRate); if (pavi == NULL) return AVIERR_BADHANDLE; hr = IAVIStream_QueryInterface(pavi, &IID_IAVIStreaming, (LPVOID*)&pstream); if (SUCCEEDED(hr) && pstream != NULL) { hr = IAVIStreaming_Begin(pstream, lStart, lEnd, lRate); IAVIStreaming_Release(pstream); } else hr = AVIERR_OK; return hr; } /*********************************************************************** * AVIStreamEndStreaming (AVIFIL32.@) */ LONG WINAPI AVIStreamEndStreaming(PAVISTREAM pavi) { IAVIStreaming* pstream = NULL; HRESULT hr; TRACE("(%p)\n", pavi); hr = IAVIStream_QueryInterface(pavi, &IID_IAVIStreaming, (LPVOID*)&pstream); if (SUCCEEDED(hr) && pstream != NULL) { IAVIStreaming_End(pstream); IAVIStreaming_Release(pstream); } return AVIERR_OK; } /*********************************************************************** * AVIStreamStart (AVIFILE.130) * AVIStreamStart (AVIFIL32.@) */ LONG WINAPI AVIStreamStart(PAVISTREAM pstream) { AVISTREAMINFOW asiw; TRACE("(%p)\n", pstream); if (pstream == NULL) return 0; if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw)))) return 0; return asiw.dwStart; } /*********************************************************************** * AVIStreamLength (AVIFILE.131) * AVIStreamLength (AVIFIL32.@) */ LONG WINAPI AVIStreamLength(PAVISTREAM pstream) { AVISTREAMINFOW asiw; TRACE("(%p)\n", pstream); if (pstream == NULL) return 0; if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw)))) return 0; return asiw.dwLength; } /*********************************************************************** * AVIStreamSampleToTime (AVIFILE.133) * AVIStreamSampleToTime (AVIFIL32.@) */ LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pstream, LONG lSample) { AVISTREAMINFOW asiw; LONG time; TRACE("(%p,%ld)\n", pstream, lSample); if (pstream == NULL) return -1; if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw)))) return -1; if (asiw.dwRate == 0) return -1; /* limit to stream bounds */ if (lSample < asiw.dwStart) lSample = asiw.dwStart; if (lSample > asiw.dwStart + asiw.dwLength) lSample = asiw.dwStart + asiw.dwLength; if (asiw.dwRate / asiw.dwScale < 1000) time = (LONG)(((float)lSample * asiw.dwScale * 1000) / asiw.dwRate); else time = (LONG)(((float)lSample * asiw.dwScale * 1000 + (asiw.dwRate - 1)) / asiw.dwRate); TRACE(" -> %ld\n",time); return time; } /*********************************************************************** * AVIStreamTimeToSample (AVIFILE.132) * AVIStreamTimeToSample (AVIFIL32.@) */ LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pstream, LONG lTime) { AVISTREAMINFOW asiw; ULONG sample; TRACE("(%p,%ld)\n", pstream, lTime); if (pstream == NULL || lTime < 0) return -1; if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw)))) return -1; if (asiw.dwScale == 0) return -1; if (asiw.dwRate / asiw.dwScale < 1000) sample = (LONG)((((float)asiw.dwRate * lTime) / (asiw.dwScale * 1000))); else sample = (LONG)(((float)asiw.dwRate * lTime + (asiw.dwScale * 1000 - 1)) / (asiw.dwScale * 1000)); /* limit to stream bounds */ if (sample < asiw.dwStart) sample = asiw.dwStart; if (sample > asiw.dwStart + asiw.dwLength) sample = asiw.dwStart + asiw.dwLength; TRACE(" -> %ld\n", sample); return sample; } /*********************************************************************** * AVIBuildFilter (AVIFIL32.@) * AVIBuildFilterA (AVIFIL32.@) * AVIBuildFilter (AVIFILE.123) */ HRESULT WINAPI AVIBuildFilterA(LPSTR szFilter, LONG cbFilter, BOOL fSaving) { LPWSTR wszFilter; HRESULT hr; TRACE("(%p,%ld,%d)\n", szFilter, cbFilter, fSaving); /* check parameters */ if (szFilter == NULL) return AVIERR_BADPARAM; if (cbFilter < 2) return AVIERR_BADSIZE; szFilter[0] = 0; szFilter[1] = 0; wszFilter = HeapAlloc(GetProcessHeap(), 0, cbFilter * sizeof(WCHAR)); if (wszFilter == NULL) return AVIERR_MEMORY; hr = AVIBuildFilterW(wszFilter, cbFilter, fSaving); if (SUCCEEDED(hr)) { WideCharToMultiByte(CP_ACP, 0, wszFilter, cbFilter, szFilter, cbFilter, NULL, NULL); } HeapFree(GetProcessHeap(), 0, wszFilter); return hr; } /*********************************************************************** * AVIBuildFilterW (AVIFIL32.@) */ HRESULT WINAPI AVIBuildFilterW(LPWSTR szFilter, LONG cbFilter, BOOL fSaving) { static const WCHAR szClsid[] = {'C','L','S','I','D',0}; static const WCHAR szExtensionFmt[] = {';','*','.','%','s',0}; static const WCHAR szAVIFileExtensions[] = {'A','V','I','F','i','l','e','\\','E','x','t','e','n','s','i','o','n','s',0}; AVIFilter *lp; WCHAR szAllFiles[40]; WCHAR szFileExt[10]; WCHAR szValue[128]; HKEY hKey; DWORD n, i; LONG size; DWORD count = 0; TRACE("(%p,%ld,%d)\n", szFilter, cbFilter, fSaving); /* check parameters */ if (szFilter == NULL) return AVIERR_BADPARAM; if (cbFilter < 2) return AVIERR_BADSIZE; lp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_FILTERS * sizeof(AVIFilter)); if (lp == NULL) return AVIERR_MEMORY; /* * 1. iterate over HKEY_CLASSES_ROOT\\AVIFile\\Extensions and collect * extensions and CLSID's * 2. iterate over collected CLSID's and copy its description and its * extensions to szFilter if it fits * * First filter is named "All multimedia files" and its filter is a * collection of all possible extensions except "*.*". */ if (RegOpenKeyW(HKEY_CLASSES_ROOT, szAVIFileExtensions, &hKey) != S_OK) { HeapFree(GetProcessHeap(), 0, lp); return AVIERR_ERROR; } for (n = 0;RegEnumKeyW(hKey, n, szFileExt, sizeof(szFileExt)) == S_OK;n++) { /* get CLSID to extension */ size = sizeof(szValue)/sizeof(szValue[0]); if (RegQueryValueW(hKey, szFileExt, szValue, &size) != S_OK) break; /* search if the CLSID is already known */ for (i = 1; i <= count; i++) { if (lstrcmpW(lp[i].szClsid, szValue) == 0) break; /* a new one */ } if (count - i == -1U) { /* it's a new CLSID */ /* FIXME: How do we get info's about read/write capabilities? */ if (count >= MAX_FILTERS) { /* try to inform user of our full fixed size table */ ERR(": More than %d filters found! Adjust MAX_FILTERS in dlls/avifil32/api.c\n", MAX_FILTERS); break; } lstrcpyW(lp[i].szClsid, szValue); count++; } /* append extension to the filter */ wsprintfW(szValue, szExtensionFmt, szFileExt); if (lp[i].szExtensions[0] == 0) lstrcatW(lp[i].szExtensions, szValue + 1); else lstrcatW(lp[i].szExtensions, szValue); /* also append to the "all multimedia"-filter */ if (lp[0].szExtensions[0] == 0) lstrcatW(lp[0].szExtensions, szValue + 1); else lstrcatW(lp[0].szExtensions, szValue); } RegCloseKey(hKey); /* 2. get descriptions for the CLSIDs and fill out szFilter */ if (RegOpenKeyW(HKEY_CLASSES_ROOT, szClsid, &hKey) != S_OK) { HeapFree(GetProcessHeap(), 0, lp); return AVIERR_ERROR; } for (n = 0; n <= count; n++) { /* first the description */ if (n != 0) { size = sizeof(szValue)/sizeof(szValue[0]); if (RegQueryValueW(hKey, lp[n].szClsid, szValue, &size) == S_OK) { size = lstrlenW(szValue); lstrcpynW(szFilter, szValue, cbFilter); } } else size = LoadStringW(AVIFILE_hModule,IDS_ALLMULTIMEDIA,szFilter,cbFilter); /* check for enough space */ size++; if (cbFilter < size + lstrlenW(lp[n].szExtensions) + 2) { szFilter[0] = 0; szFilter[1] = 0; HeapFree(GetProcessHeap(), 0, lp); RegCloseKey(hKey); return AVIERR_BUFFERTOOSMALL; } cbFilter -= size; szFilter += size; /* and then the filter */ lstrcpynW(szFilter, lp[n].szExtensions, cbFilter); size = lstrlenW(lp[n].szExtensions) + 1; cbFilter -= size; szFilter += size; } RegCloseKey(hKey); HeapFree(GetProcessHeap(), 0, lp); /* add "All files" "*.*" filter if enough space left */ size = LoadStringW(AVIFILE_hModule, IDS_ALLFILES, szAllFiles, sizeof(szAllFiles)) + 1; if (cbFilter > size) { int i; /* replace '@' with \000 to separate description of filter */ for (i = 0; i < size && szAllFiles[i] != 0; i++) { if (szAllFiles[i] == '@') { szAllFiles[i] = 0; break; } } memcpy(szFilter, szAllFiles, size * sizeof(szAllFiles[0])); szFilter += size; szFilter[0] = 0; return AVIERR_OK; } else { szFilter[0] = 0; return AVIERR_BUFFERTOOSMALL; } } static BOOL AVISaveOptionsFmtChoose(HWND hWnd) { LPAVICOMPRESSOPTIONS pOptions = SaveOpts.ppOptions[SaveOpts.nCurrent]; AVISTREAMINFOW sInfo; TRACE("(%p)\n", hWnd); if (pOptions == NULL || SaveOpts.ppavis[SaveOpts.nCurrent] == NULL) { ERR(": bad state!\n"); return FALSE; } if (FAILED(AVIStreamInfoW(SaveOpts.ppavis[SaveOpts.nCurrent], &sInfo, sizeof(sInfo)))) { ERR(": AVIStreamInfoW failed!\n"); return FALSE; } if (sInfo.fccType == streamtypeVIDEO) { COMPVARS cv; BOOL ret; memset(&cv, 0, sizeof(cv)); if ((pOptions->dwFlags & AVICOMPRESSF_VALID) == 0) { memset(pOptions, 0, sizeof(AVICOMPRESSOPTIONS)); pOptions->fccType = streamtypeVIDEO; pOptions->fccHandler = comptypeDIB; pOptions->dwQuality = (DWORD)ICQUALITY_DEFAULT; } cv.cbSize = sizeof(cv); cv.dwFlags = ICMF_COMPVARS_VALID; /*cv.fccType = pOptions->fccType; */ cv.fccHandler = pOptions->fccHandler; cv.lQ = pOptions->dwQuality; cv.lpState = pOptions->lpParms; cv.cbState = pOptions->cbParms; if (pOptions->dwFlags & AVICOMPRESSF_KEYFRAMES) cv.lKey = pOptions->dwKeyFrameEvery; else cv.lKey = 0; if (pOptions->dwFlags & AVICOMPRESSF_DATARATE) cv.lDataRate = pOptions->dwBytesPerSecond / 1024; /* need kBytes */ else cv.lDataRate = 0; ret = ICCompressorChoose(hWnd, SaveOpts.uFlags, NULL, SaveOpts.ppavis[SaveOpts.nCurrent], &cv, NULL); if (ret) { pOptions->fccHandler = cv.fccHandler; pOptions->lpParms = cv.lpState; pOptions->cbParms = cv.cbState; pOptions->dwQuality = cv.lQ; if (cv.lKey != 0) { pOptions->dwKeyFrameEvery = cv.lKey; pOptions->dwFlags |= AVICOMPRESSF_KEYFRAMES; } else pOptions->dwFlags &= ~AVICOMPRESSF_KEYFRAMES; if (cv.lDataRate != 0) { pOptions->dwBytesPerSecond = cv.lDataRate * 1024; /* need bytes */ pOptions->dwFlags |= AVICOMPRESSF_DATARATE; } else pOptions->dwFlags &= ~AVICOMPRESSF_DATARATE; pOptions->dwFlags |= AVICOMPRESSF_VALID; } ICCompressorFree(&cv); return ret; } else if (sInfo.fccType == streamtypeAUDIO) { ACMFORMATCHOOSEW afmtc; MMRESULT ret; LONG size; /* FIXME: check ACM version -- Which version is needed? */ memset(&afmtc, 0, sizeof(afmtc)); afmtc.cbStruct = sizeof(afmtc); afmtc.fdwStyle = 0; afmtc.hwndOwner = hWnd; acmMetrics(NULL, ACM_METRIC_MAX_SIZE_FORMAT, &size); if ((pOptions->cbFormat == 0 || pOptions->lpFormat == NULL) && size != 0) { pOptions->lpFormat = HeapAlloc(GetProcessHeap(), 0, size); pOptions->cbFormat = size; } else if (pOptions->cbFormat < (DWORD)size) { pOptions->lpFormat = HeapReAlloc(GetProcessHeap(), 0, pOptions->lpFormat, size); pOptions->cbFormat = size; } if (pOptions->lpFormat == NULL) return FALSE; afmtc.pwfx = pOptions->lpFormat; afmtc.cbwfx = pOptions->cbFormat; size = 0; AVIStreamFormatSize(SaveOpts.ppavis[SaveOpts.nCurrent], sInfo.dwStart, &size); if (size < (LONG)sizeof(PCMWAVEFORMAT)) size = sizeof(PCMWAVEFORMAT); afmtc.pwfxEnum = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); if (afmtc.pwfxEnum != NULL) { AVIStreamReadFormat(SaveOpts.ppavis[SaveOpts.nCurrent], sInfo.dwStart, afmtc.pwfxEnum, &size); afmtc.fdwEnum = ACM_FORMATENUMF_CONVERT; } ret = acmFormatChooseW(&afmtc); if (ret == S_OK) pOptions->dwFlags |= AVICOMPRESSF_VALID; if (afmtc.pwfxEnum != NULL) HeapFree(GetProcessHeap(), 0, afmtc.pwfxEnum); return (ret == S_OK ? TRUE : FALSE); } else { ERR(": unknown streamtype 0x%08lX\n", sInfo.fccType); return FALSE; } } static void AVISaveOptionsUpdate(HWND hWnd) { static const WCHAR szVideoFmt[]={'%','l','d','x','%','l','d','x','%','d',0}; static const WCHAR szAudioFmt[]={'%','s',' ','%','s',0}; WCHAR szFormat[128]; AVISTREAMINFOW sInfo; LPVOID lpFormat; LONG size; TRACE("(%p)\n", hWnd); SaveOpts.nCurrent = SendDlgItemMessageW(hWnd,IDC_STREAM,CB_GETCURSEL,0,0); if (SaveOpts.nCurrent < 0) return; if (FAILED(AVIStreamInfoW(SaveOpts.ppavis[SaveOpts.nCurrent], &sInfo, sizeof(sInfo)))) return; AVIStreamFormatSize(SaveOpts.ppavis[SaveOpts.nCurrent],sInfo.dwStart,&size); if (size > 0) { szFormat[0] = 0; /* read format to build format description string */ lpFormat = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); if (lpFormat != NULL) { if (SUCCEEDED(AVIStreamReadFormat(SaveOpts.ppavis[SaveOpts.nCurrent],sInfo.dwStart,lpFormat, &size))) { if (sInfo.fccType == streamtypeVIDEO) { LPBITMAPINFOHEADER lpbi = lpFormat; ICINFO icinfo; wsprintfW(szFormat, szVideoFmt, lpbi->biWidth, lpbi->biHeight, lpbi->biBitCount); if (lpbi->biCompression != BI_RGB) { HIC hic; hic = ICLocate(ICTYPE_VIDEO, sInfo.fccHandler, lpFormat, NULL, ICMODE_DECOMPRESS); if (hic != NULL) { if (ICGetInfo(hic, &icinfo, sizeof(icinfo)) == S_OK) lstrcatW(szFormat, icinfo.szDescription); ICClose(hic); } } else { LoadStringW(AVIFILE_hModule, IDS_UNCOMPRESSED, icinfo.szDescription, sizeof(icinfo.szDescription)); lstrcatW(szFormat, icinfo.szDescription); } } else if (sInfo.fccType == streamtypeAUDIO) { ACMFORMATTAGDETAILSW aftd; ACMFORMATDETAILSW afd; memset(&aftd, 0, sizeof(aftd)); memset(&afd, 0, sizeof(afd)); aftd.cbStruct = sizeof(aftd); aftd.dwFormatTag = afd.dwFormatTag = ((PWAVEFORMATEX)lpFormat)->wFormatTag; aftd.cbFormatSize = afd.cbwfx = size; afd.cbStruct = sizeof(afd); afd.pwfx = lpFormat; if (acmFormatTagDetailsW(NULL, &aftd, ACM_FORMATTAGDETAILSF_FORMATTAG) == S_OK) { if (acmFormatDetailsW(NULL,&afd,ACM_FORMATDETAILSF_FORMAT) == S_OK) wsprintfW(szFormat, szAudioFmt, afd.szFormat, aftd.szFormatTag); } } } HeapFree(GetProcessHeap(), 0, lpFormat); } /* set text for format description */ SetDlgItemTextW(hWnd, IDC_FORMATTEXT, szFormat); /* Disable option button for unsupported streamtypes */ if (sInfo.fccType == streamtypeVIDEO || sInfo.fccType == streamtypeAUDIO) EnableWindow(GetDlgItem(hWnd, IDC_OPTIONS), TRUE); else EnableWindow(GetDlgItem(hWnd, IDC_OPTIONS), FALSE); } } static INT_PTR CALLBACK AVISaveOptionsDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { DWORD dwInterleave; BOOL bIsInterleaved; INT n; /*TRACE("(%p,%u,0x%04X,0x%08lX)\n", hWnd, uMsg, wParam, lParam);*/ switch (uMsg) { case WM_INITDIALOG: SaveOpts.nCurrent = 0; if (SaveOpts.nStreams == 1) { EndDialog(hWnd, AVISaveOptionsFmtChoose(hWnd)); return TRUE; } /* add streams */ for (n = 0; n < SaveOpts.nStreams; n++) { AVISTREAMINFOW sInfo; AVIStreamInfoW(SaveOpts.ppavis[n], &sInfo, sizeof(sInfo)); SendDlgItemMessageW(hWnd, IDC_STREAM, CB_ADDSTRING, 0L, (LPARAM)sInfo.szName); } /* select first stream */ SendDlgItemMessageW(hWnd, IDC_STREAM, CB_SETCURSEL, 0, 0); SendMessageW(hWnd, WM_COMMAND, MAKELONG(IDC_STREAM, CBN_SELCHANGE), (LPARAM)hWnd); /* initialize interleave */ if (SaveOpts.ppOptions[0] != NULL && (SaveOpts.ppOptions[0]->dwFlags & AVICOMPRESSF_VALID)) { bIsInterleaved = (SaveOpts.ppOptions[0]->dwFlags & AVICOMPRESSF_INTERLEAVE); dwInterleave = SaveOpts.ppOptions[0]->dwInterleaveEvery; } else { bIsInterleaved = TRUE; dwInterleave = 0; } CheckDlgButton(hWnd, IDC_INTERLEAVE, bIsInterleaved); SetDlgItemInt(hWnd, IDC_INTERLEAVEEVERY, dwInterleave, FALSE); EnableWindow(GetDlgItem(hWnd, IDC_INTERLEAVEEVERY), bIsInterleaved); break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDOK: /* get data from controls and save them */ dwInterleave = GetDlgItemInt(hWnd, IDC_INTERLEAVEEVERY, NULL, 0); bIsInterleaved = IsDlgButtonChecked(hWnd, IDC_INTERLEAVE); for (n = 0; n < SaveOpts.nStreams; n++) { if (SaveOpts.ppOptions[n] != NULL) { if (bIsInterleaved) { SaveOpts.ppOptions[n]->dwFlags |= AVICOMPRESSF_INTERLEAVE; SaveOpts.ppOptions[n]->dwInterleaveEvery = dwInterleave; } else SaveOpts.ppOptions[n]->dwFlags &= ~AVICOMPRESSF_INTERLEAVE; } } /* fall through */ case IDCANCEL: EndDialog(hWnd, LOWORD(wParam) == IDOK); break; case IDC_INTERLEAVE: EnableWindow(GetDlgItem(hWnd, IDC_INTERLEAVEEVERY), IsDlgButtonChecked(hWnd, IDC_INTERLEAVE)); break; case IDC_STREAM: if (HIWORD(wParam) == CBN_SELCHANGE) { /* update control elements */ AVISaveOptionsUpdate(hWnd); } break; case IDC_OPTIONS: AVISaveOptionsFmtChoose(hWnd); break; }; return TRUE; }; return FALSE; } /*********************************************************************** * AVISaveOptions (AVIFIL32.@) */ BOOL WINAPI AVISaveOptions(HWND hWnd, UINT uFlags, INT nStreams, PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *ppOptions) { LPAVICOMPRESSOPTIONS pSavedOptions = NULL; INT ret, n; TRACE("(%p,0x%X,%d,%p,%p)\n", hWnd, uFlags, nStreams, ppavi, ppOptions); /* check parameters */ if (nStreams <= 0 || ppavi == NULL || ppOptions == NULL) return AVIERR_BADPARAM; /* save options in case the user presses cancel */ if (ppOptions != NULL && nStreams > 1) { pSavedOptions = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nStreams * sizeof(AVICOMPRESSOPTIONS)); if (pSavedOptions == NULL) return FALSE; for (n = 0; n < nStreams; n++) { if (ppOptions[n] != NULL) memcpy(pSavedOptions + n, ppOptions[n], sizeof(AVICOMPRESSOPTIONS)); } } SaveOpts.uFlags = uFlags; SaveOpts.nStreams = nStreams; SaveOpts.ppavis = ppavi; SaveOpts.ppOptions = ppOptions; ret = DialogBoxW(AVIFILE_hModule, MAKEINTRESOURCEW(IDD_SAVEOPTIONS), hWnd, AVISaveOptionsDlgProc); if (ret == -1) ret = FALSE; /* restore options when user pressed cancel */ if (pSavedOptions != NULL) { if (ret == FALSE) { for (n = 0; n < nStreams; n++) { if (ppOptions[n] != NULL) memcpy(ppOptions[n], pSavedOptions + n, sizeof(AVICOMPRESSOPTIONS)); } } HeapFree(GetProcessHeap(), 0, pSavedOptions); } return (BOOL)ret; } /*********************************************************************** * AVISaveOptionsFree (AVIFIL32.@) * AVISaveOptionsFree (AVIFILE.124) */ HRESULT WINAPI AVISaveOptionsFree(INT nStreams,LPAVICOMPRESSOPTIONS*ppOptions) { TRACE("(%d,%p)\n", nStreams, ppOptions); if (nStreams < 0 || ppOptions == NULL) return AVIERR_BADPARAM; for (; nStreams > 0; nStreams--) { if (ppOptions[nStreams] != NULL) { ppOptions[nStreams]->dwFlags &= ~AVICOMPRESSF_VALID; if (ppOptions[nStreams]->lpParms != NULL) { HeapFree(GetProcessHeap(), 0, ppOptions[nStreams]->lpParms); ppOptions[nStreams]->lpParms = NULL; ppOptions[nStreams]->cbParms = 0; } if (ppOptions[nStreams]->lpFormat != NULL) { HeapFree(GetProcessHeap(), 0, ppOptions[nStreams]->lpFormat); ppOptions[nStreams]->lpFormat = NULL; ppOptions[nStreams]->cbFormat = 0; } } } return AVIERR_OK; } /*********************************************************************** * AVISaveVA (AVIFIL32.@) */ HRESULT WINAPI AVISaveVA(LPCSTR szFile, CLSID *pclsidHandler, AVISAVECALLBACK lpfnCallback, int nStream, PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions) { LPWSTR wszFile = NULL; HRESULT hr; int len; TRACE("%s,%p,%p,%d,%p,%p)\n", debugstr_a(szFile), pclsidHandler, lpfnCallback, nStream, ppavi, plpOptions); if (szFile == NULL || ppavi == NULL || plpOptions == NULL) return AVIERR_BADPARAM; /* convert ASCII string to Unicode and call Unicode function */ len = MultiByteToWideChar(CP_ACP, 0, szFile, -1, NULL, 0); if (len <= 0) return AVIERR_BADPARAM; wszFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); if (wszFile == NULL) return AVIERR_MEMORY; MultiByteToWideChar(CP_ACP, 0, szFile, -1, wszFile, len); hr = AVISaveVW(wszFile, pclsidHandler, lpfnCallback, nStream, ppavi, plpOptions); HeapFree(GetProcessHeap(), 0, wszFile); return hr; } /*********************************************************************** * AVIFILE_AVISaveDefaultCallback (internal) */ static BOOL WINAPI AVIFILE_AVISaveDefaultCallback(INT progress) { TRACE("(%d)\n", progress); return FALSE; } /*********************************************************************** * AVISaveVW (AVIFIL32.@) */ HRESULT WINAPI AVISaveVW(LPCWSTR szFile, CLSID *pclsidHandler, AVISAVECALLBACK lpfnCallback, int nStreams, PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions) { LONG lStart[MAX_AVISTREAMS]; PAVISTREAM pOutStreams[MAX_AVISTREAMS]; PAVISTREAM pInStreams[MAX_AVISTREAMS]; AVIFILEINFOW fInfo; AVISTREAMINFOW sInfo; PAVIFILE pfile = NULL; /* the output AVI file */ LONG lFirstVideo = -1; int curStream; /* for interleaving ... */ DWORD dwInterleave = 0; /* interleave rate */ DWORD dwFileInitialFrames; LONG lFileLength; LONG lSampleInc; /* for reading/writing the data ... */ LPVOID lpBuffer = NULL; LONG cbBuffer; /* real size of lpBuffer */ LONG lBufferSize; /* needed bytes for format(s), etc. */ LONG lReadBytes; LONG lReadSamples; HRESULT hres; TRACE("(%s,%p,%p,%d,%p,%p)\n", debugstr_w(szFile), pclsidHandler, lpfnCallback, nStreams, ppavi, plpOptions); if (szFile == NULL || ppavi == NULL || plpOptions == NULL) return AVIERR_BADPARAM; if (nStreams >= MAX_AVISTREAMS) { WARN("Can't write AVI with %d streams only supports %d -- change MAX_AVISTREAMS!\n", nStreams, MAX_AVISTREAMS); return AVIERR_INTERNAL; } if (lpfnCallback == NULL) lpfnCallback = AVIFILE_AVISaveDefaultCallback; /* clear local variable(s) */ for (curStream = 0; curStream < nStreams; curStream++) { pInStreams[curStream] = NULL; pOutStreams[curStream] = NULL; } /* open output AVI file (create it if it doesn't exist) */ hres = AVIFileOpenW(&pfile, szFile, OF_CREATE|OF_SHARE_EXCLUSIVE|OF_WRITE, pclsidHandler); if (FAILED(hres)) return hres; AVIFileInfoW(pfile, &fInfo, sizeof(fInfo)); /* for dwCaps */ /* initialize our data structures part 1 */ for (curStream = 0; curStream < nStreams; curStream++) { PAVISTREAM pCurStream = ppavi[curStream]; hres = AVIStreamInfoW(pCurStream, &sInfo, sizeof(sInfo)); if (FAILED(hres)) goto error; /* search first video stream and check for interleaving */ if (sInfo.fccType == streamtypeVIDEO) { /* remember first video stream -- needed for interleaving */ if (lFirstVideo < 0) lFirstVideo = curStream; } else if (!dwInterleave && plpOptions != NULL) { /* check if any non-video stream wants to be interleaved */ WARN("options.flags=0x%lX options.dwInterleave=%lu\n",plpOptions[curStream]->dwFlags,plpOptions[curStream]->dwInterleaveEvery); if (plpOptions[curStream] != NULL && plpOptions[curStream]->dwFlags & AVICOMPRESSF_INTERLEAVE) dwInterleave = plpOptions[curStream]->dwInterleaveEvery; } /* create de-/compressed stream interface if needed */ pInStreams[curStream] = NULL; if (plpOptions != NULL && plpOptions[curStream] != NULL) { if (plpOptions[curStream]->fccHandler || plpOptions[curStream]->lpFormat != NULL) { DWORD dwKeySave = plpOptions[curStream]->dwKeyFrameEvery; if (fInfo.dwCaps & AVIFILECAPS_ALLKEYFRAMES) plpOptions[curStream]->dwKeyFrameEvery = 1; hres = AVIMakeCompressedStream(&pInStreams[curStream], pCurStream, plpOptions[curStream], NULL); plpOptions[curStream]->dwKeyFrameEvery = dwKeySave; if (FAILED(hres) || pInStreams[curStream] == NULL) { pInStreams[curStream] = NULL; goto error; } /* test stream interface and update stream-info */ hres = AVIStreamInfoW(pInStreams[curStream], &sInfo, sizeof(sInfo)); if (FAILED(hres)) goto error; } } /* now handle streams which will only be copied */ if (pInStreams[curStream] == NULL) { pCurStream = pInStreams[curStream] = ppavi[curStream]; AVIStreamAddRef(pCurStream); } else pCurStream = pInStreams[curStream]; lStart[curStream] = sInfo.dwStart; } /* for all streams */ /* check that first video stream is the first stream */ if (lFirstVideo > 0) { PAVISTREAM pTmp = pInStreams[lFirstVideo]; LONG lTmp = lStart[lFirstVideo]; pInStreams[lFirstVideo] = pInStreams[0]; pInStreams[0] = pTmp; lStart[lFirstVideo] = lStart[0]; lStart[0] = lTmp; lFirstVideo = 0; } /* allocate buffer for formats, data, etc. of an initial size of 64 kBytes*/ lpBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbBuffer = 0x00010000); if (lpBuffer == NULL) { hres = AVIERR_MEMORY; goto error; } AVIStreamInfoW(pInStreams[0], &sInfo, sizeof(sInfo)); lFileLength = sInfo.dwLength; dwFileInitialFrames = 0; if (lFirstVideo >= 0) { /* check for correct version of the format * -- need at least BITMAPINFOHEADER or newer */ lSampleInc = 1; lBufferSize = cbBuffer; hres = AVIStreamReadFormat(pInStreams[lFirstVideo], AVIStreamStart(pInStreams[lFirstVideo]), lpBuffer, &lBufferSize); if (lBufferSize < (LONG)sizeof(BITMAPINFOHEADER)) hres = AVIERR_INTERNAL; if (FAILED(hres)) goto error; } else /* use one second blocks for interleaving if no video present */ lSampleInc = AVIStreamTimeToSample(pInStreams[0], 1000000); /* create output streams */ for (curStream = 0; curStream < nStreams; curStream++) { AVIStreamInfoW(pInStreams[curStream], &sInfo, sizeof(sInfo)); sInfo.dwInitialFrames = 0; if (dwInterleave != 0 && curStream > 0 && sInfo.fccType != streamtypeVIDEO) { /* 750 ms initial frames for non-video streams */ sInfo.dwInitialFrames = AVIStreamTimeToSample(pInStreams[0], 750); } hres = AVIFileCreateStreamW(pfile, &pOutStreams[curStream], &sInfo); if (pOutStreams[curStream] != NULL && SUCCEEDED(hres)) { /* copy initial format for this stream */ lBufferSize = cbBuffer; hres = AVIStreamReadFormat(pInStreams[curStream], sInfo.dwStart, lpBuffer, &lBufferSize); if (FAILED(hres)) goto error; hres = AVIStreamSetFormat(pOutStreams[curStream], 0, lpBuffer, lBufferSize); if (FAILED(hres)) goto error; /* try to copy stream handler data */ lBufferSize = cbBuffer; hres = AVIStreamReadData(pInStreams[curStream], ckidSTREAMHANDLERDATA, lpBuffer, &lBufferSize); if (SUCCEEDED(hres) && lBufferSize > 0) { hres = AVIStreamWriteData(pOutStreams[curStream],ckidSTREAMHANDLERDATA, lpBuffer, lBufferSize); if (FAILED(hres)) goto error; } if (dwFileInitialFrames < sInfo.dwInitialFrames) dwFileInitialFrames = sInfo.dwInitialFrames; lReadBytes = AVIStreamSampleToSample(pOutStreams[0], pInStreams[curStream], sInfo.dwLength); if (lFileLength < lReadBytes) lFileLength = lReadBytes; } else { /* creation of de-/compression stream interface failed */ WARN("creation of (de-)compression stream failed for stream %d\n",curStream); AVIStreamRelease(pInStreams[curStream]); if (curStream + 1 >= nStreams) { /* move the others one up */ PAVISTREAM *ppas = &pInStreams[curStream]; int n = nStreams - (curStream + 1); do { *ppas = pInStreams[curStream + 1]; } while (--n); } nStreams--; curStream--; } } /* create output streams for all input streams */ /* have we still something to write, or lost everything? */ if (nStreams <= 0) goto error; if (dwInterleave) { LONG lCurFrame = -dwFileInitialFrames; /* interleaved file */ if (dwInterleave == 1) AVIFileEndRecord(pfile); for (; lCurFrame < lFileLength; lCurFrame += lSampleInc) { for (curStream = 0; curStream < nStreams; curStream++) { LONG lLastSample; hres = AVIStreamInfoW(pOutStreams[curStream], &sInfo, sizeof(sInfo)); if (FAILED(hres)) goto error; /* initial frames phase at the end for this stream? */ if (-(LONG)sInfo.dwInitialFrames > lCurFrame) continue; if ((lFileLength - lSampleInc) <= lCurFrame) { lLastSample = AVIStreamLength(pInStreams[curStream]); lFirstVideo = lLastSample + AVIStreamStart(pInStreams[curStream]); } else { if (curStream != 0) { lFirstVideo = AVIStreamSampleToSample(pInStreams[curStream], pInStreams[0], (sInfo.fccType == streamtypeVIDEO ? (LONG)dwInterleave : lSampleInc) + sInfo.dwInitialFrames + lCurFrame); } else lFirstVideo = lSampleInc + (sInfo.dwInitialFrames + lCurFrame); lLastSample = AVIStreamEnd(pInStreams[curStream]); if (lLastSample <= lFirstVideo) lFirstVideo = lLastSample; } /* copy needed samples now */ WARN("copy from stream %d samples %ld to %ld...\n",curStream, lStart[curStream],lFirstVideo); while (lFirstVideo > lStart[curStream]) { DWORD flags = 0; /* copy format in case it can change */ lBufferSize = cbBuffer; hres = AVIStreamReadFormat(pInStreams[curStream], lStart[curStream], lpBuffer, &lBufferSize); if (FAILED(hres)) goto error; AVIStreamSetFormat(pOutStreams[curStream], lStart[curStream], lpBuffer, lBufferSize); /* try to read data until we got it, or error */ do { hres = AVIStreamRead(pInStreams[curStream], lStart[curStream], lFirstVideo - lStart[curStream], lpBuffer, cbBuffer, &lReadBytes, &lReadSamples); } while ((hres == AVIERR_BUFFERTOOSMALL) && (lpBuffer = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpBuffer, cbBuffer *= 2)) != NULL); if (lpBuffer == NULL) hres = AVIERR_MEMORY; if (FAILED(hres)) goto error; if (AVIStreamIsKeyFrame(pInStreams[curStream], (LONG)sInfo.dwStart)) flags = AVIIF_KEYFRAME; hres = AVIStreamWrite(pOutStreams[curStream], -1, lReadSamples, lpBuffer, lReadBytes, flags, NULL, NULL); if (FAILED(hres)) goto error; lStart[curStream] += lReadSamples; } lStart[curStream] = lFirstVideo; } /* stream by stream */ /* need to close this block? */ if (dwInterleave == 1) { hres = AVIFileEndRecord(pfile); if (FAILED(hres)) break; } /* show progress */ if (lpfnCallback(MulDiv(dwFileInitialFrames + lCurFrame, 100, dwFileInitialFrames + lFileLength))) { hres = AVIERR_USERABORT; break; } } /* copy frame by frame */ } else { /* non-interleaved file */ for (curStream = 0; curStream < nStreams; curStream++) { /* show progress */ if (lpfnCallback(MulDiv(curStream, 100, nStreams))) { hres = AVIERR_USERABORT; goto error; } AVIStreamInfoW(pInStreams[curStream], &sInfo, sizeof(sInfo)); if (sInfo.dwSampleSize != 0) { /* sample-based data like audio */ while (sInfo.dwStart < sInfo.dwLength) { LONG lSamples = cbBuffer / sInfo.dwSampleSize; /* copy format in case it can change */ lBufferSize = cbBuffer; hres = AVIStreamReadFormat(pInStreams[curStream], sInfo.dwStart, lpBuffer, &lBufferSize); if (FAILED(hres)) return hres; AVIStreamSetFormat(pOutStreams[curStream], sInfo.dwStart, lpBuffer, lBufferSize); /* limit to stream boundaries */ if (lSamples != (LONG)(sInfo.dwLength - sInfo.dwStart)) lSamples = sInfo.dwLength - sInfo.dwStart; /* now try to read until we get it, or an error occurs */ do { lReadBytes = cbBuffer; lReadSamples = 0; hres = AVIStreamRead(pInStreams[curStream],sInfo.dwStart,lSamples, lpBuffer,cbBuffer,&lReadBytes,&lReadSamples); } while ((hres == AVIERR_BUFFERTOOSMALL) && (lpBuffer = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpBuffer, cbBuffer *= 2)) != NULL); if (lpBuffer == NULL) hres = AVIERR_MEMORY; if (FAILED(hres)) goto error; if (lReadSamples != 0) { sInfo.dwStart += lReadSamples; hres = AVIStreamWrite(pOutStreams[curStream], -1, lReadSamples, lpBuffer, lReadBytes, 0, NULL , NULL); if (FAILED(hres)) goto error; /* show progress */ if (lpfnCallback(MulDiv(sInfo.dwStart,100,nStreams*sInfo.dwLength)+ MulDiv(curStream, 100, nStreams))) { hres = AVIERR_USERABORT; goto error; } } else { if ((sInfo.dwLength - sInfo.dwStart) != 1) { hres = AVIERR_FILEREAD; goto error; } } } } else { /* block-based data like video */ for (; sInfo.dwStart < sInfo.dwLength; sInfo.dwStart++) { DWORD flags = 0; /* copy format in case it can change */ lBufferSize = cbBuffer; hres = AVIStreamReadFormat(pInStreams[curStream], sInfo.dwStart, lpBuffer, &lBufferSize); if (FAILED(hres)) goto error; AVIStreamSetFormat(pOutStreams[curStream], sInfo.dwStart, lpBuffer, lBufferSize); /* try to read block and resize buffer if necessary */ do { lReadSamples = 0; lReadBytes = cbBuffer; hres = AVIStreamRead(pInStreams[curStream], sInfo.dwStart, 1, lpBuffer, cbBuffer,&lReadBytes,&lReadSamples); } while ((hres == AVIERR_BUFFERTOOSMALL) && (lpBuffer = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpBuffer, cbBuffer *= 2)) != NULL); if (lpBuffer == NULL) hres = AVIERR_MEMORY; if (FAILED(hres)) goto error; if (lReadSamples != 1) { hres = AVIERR_FILEREAD; goto error; } if (AVIStreamIsKeyFrame(pInStreams[curStream], (LONG)sInfo.dwStart)) flags = AVIIF_KEYFRAME; hres = AVIStreamWrite(pOutStreams[curStream], -1, lReadSamples, lpBuffer, lReadBytes, flags, NULL, NULL); if (FAILED(hres)) goto error; /* show progress */ if (lpfnCallback(MulDiv(sInfo.dwStart,100,nStreams*sInfo.dwLength)+ MulDiv(curStream, 100, nStreams))) { hres = AVIERR_USERABORT; goto error; } } /* copy all blocks */ } } /* copy data stream by stream */ } error: if (lpBuffer != NULL) HeapFree(GetProcessHeap(), 0, lpBuffer); if (pfile != NULL) { for (curStream = 0; curStream < nStreams; curStream++) { if (pOutStreams[curStream] != NULL) AVIStreamRelease(pOutStreams[curStream]); if (pInStreams[curStream] != NULL) AVIStreamRelease(pInStreams[curStream]); } AVIFileRelease(pfile); } return hres; } /*********************************************************************** * CreateEditableStream (AVIFIL32.@) */ HRESULT WINAPI CreateEditableStream(PAVISTREAM *ppEditable, PAVISTREAM pSource) { IAVIEditStream *pEdit = NULL; HRESULT hr; TRACE("(%p,%p)\n", ppEditable, pSource); if (ppEditable == NULL) return AVIERR_BADPARAM; *ppEditable = NULL; if (pSource != NULL) { hr = IAVIStream_QueryInterface(pSource, &IID_IAVIEditStream, (LPVOID*)&pEdit); if (SUCCEEDED(hr) && pEdit != NULL) { hr = IAVIEditStream_Clone(pEdit, ppEditable); IAVIEditStream_Release(pEdit); return hr; } } /* need own implementation of IAVIEditStream */ pEdit = AVIFILE_CreateEditStream(pSource); if (pEdit == NULL) return AVIERR_MEMORY; hr = IAVIEditStream_QueryInterface(pEdit, &IID_IAVIStream, (LPVOID*)ppEditable); IAVIEditStream_Release(pEdit); return hr; } /*********************************************************************** * EditStreamClone (AVIFIL32.@) */ HRESULT WINAPI EditStreamClone(PAVISTREAM pStream, PAVISTREAM *ppResult) { PAVIEDITSTREAM pEdit = NULL; HRESULT hr; TRACE("(%p,%p)\n", pStream, ppResult); if (pStream == NULL) return AVIERR_BADHANDLE; if (ppResult == NULL) return AVIERR_BADPARAM; *ppResult = NULL; hr = IAVIStream_QueryInterface(pStream, &IID_IAVIEditStream,(LPVOID*)&pEdit); if (SUCCEEDED(hr) && pEdit != NULL) { hr = IAVIEditStream_Clone(pEdit, ppResult); IAVIEditStream_Release(pEdit); } else hr = AVIERR_UNSUPPORTED; return hr; } /*********************************************************************** * EditStreamCopy (AVIFIL32.@) */ HRESULT WINAPI EditStreamCopy(PAVISTREAM pStream, LONG *plStart, LONG *plLength, PAVISTREAM *ppResult) { PAVIEDITSTREAM pEdit = NULL; HRESULT hr; TRACE("(%p,%p,%p,%p)\n", pStream, plStart, plLength, ppResult); if (pStream == NULL) return AVIERR_BADHANDLE; if (plStart == NULL || plLength == NULL || ppResult == NULL) return AVIERR_BADPARAM; *ppResult = NULL; hr = IAVIStream_QueryInterface(pStream, &IID_IAVIEditStream,(LPVOID*)&pEdit); if (SUCCEEDED(hr) && pEdit != NULL) { hr = IAVIEditStream_Copy(pEdit, plStart, plLength, ppResult); IAVIEditStream_Release(pEdit); } else hr = AVIERR_UNSUPPORTED; return hr; } /*********************************************************************** * EditStreamCut (AVIFIL32.@) */ HRESULT WINAPI EditStreamCut(PAVISTREAM pStream, LONG *plStart, LONG *plLength, PAVISTREAM *ppResult) { PAVIEDITSTREAM pEdit = NULL; HRESULT hr; TRACE("(%p,%p,%p,%p)\n", pStream, plStart, plLength, ppResult); if (ppResult != NULL) *ppResult = NULL; if (pStream == NULL) return AVIERR_BADHANDLE; if (plStart == NULL || plLength == NULL) return AVIERR_BADPARAM; hr = IAVIStream_QueryInterface(pStream, &IID_IAVIEditStream,(LPVOID*)&pEdit); if (SUCCEEDED(hr) && pEdit != NULL) { hr = IAVIEditStream_Cut(pEdit, plStart, plLength, ppResult); IAVIEditStream_Release(pEdit); } else hr = AVIERR_UNSUPPORTED; return hr; } /*********************************************************************** * EditStreamPaste (AVIFIL32.@) */ HRESULT WINAPI EditStreamPaste(PAVISTREAM pDest, LONG *plStart, LONG *plLength, PAVISTREAM pSource, LONG lStart, LONG lEnd) { PAVIEDITSTREAM pEdit = NULL; HRESULT hr; TRACE("(%p,%p,%p,%p,%ld,%ld)\n", pDest, plStart, plLength, pSource, lStart, lEnd); if (pDest == NULL || pSource == NULL) return AVIERR_BADHANDLE; if (plStart == NULL || plLength == NULL || lStart < 0) return AVIERR_BADPARAM; hr = IAVIStream_QueryInterface(pDest, &IID_IAVIEditStream,(LPVOID*)&pEdit); if (SUCCEEDED(hr) && pEdit != NULL) { hr = IAVIEditStream_Paste(pEdit, plStart, plLength, pSource, lStart, lEnd); IAVIEditStream_Release(pEdit); } else hr = AVIERR_UNSUPPORTED; return hr; } /*********************************************************************** * EditStreamSetInfoA (AVIFIL32.@) */ HRESULT WINAPI EditStreamSetInfoA(PAVISTREAM pstream, LPAVISTREAMINFOA asi, LONG size) { AVISTREAMINFOW asiw; TRACE("(%p,%p,%ld)\n", pstream, asi, size); if (pstream == NULL) return AVIERR_BADHANDLE; if ((DWORD)size < sizeof(AVISTREAMINFOA)) return AVIERR_BADSIZE; memcpy(&asiw, asi, sizeof(asiw) - sizeof(asiw.szName)); MultiByteToWideChar(CP_ACP, 0, asi->szName, -1, asiw.szName, sizeof(asiw.szName)); return EditStreamSetInfoW(pstream, &asiw, sizeof(asiw)); } /*********************************************************************** * EditStreamSetInfoW (AVIFIL32.@) */ HRESULT WINAPI EditStreamSetInfoW(PAVISTREAM pstream, LPAVISTREAMINFOW asi, LONG size) { PAVIEDITSTREAM pEdit = NULL; HRESULT hr; TRACE("(%p,%p,%ld)\n", pstream, asi, size); hr = IAVIStream_QueryInterface(pstream, &IID_IAVIEditStream,(LPVOID*)&pEdit); if (SUCCEEDED(hr) && pEdit != NULL) { hr = IAVIEditStream_SetInfo(pEdit, asi, size); IAVIEditStream_Release(pEdit); } else hr = AVIERR_UNSUPPORTED; return hr; } /*********************************************************************** * EditStreamSetNameA (AVIFIL32.@) */ HRESULT WINAPI EditStreamSetNameA(PAVISTREAM pstream, LPCSTR szName) { AVISTREAMINFOA asia; HRESULT hres; TRACE("(%p,%s)\n", pstream, debugstr_a(szName)); if (pstream == NULL) return AVIERR_BADHANDLE; if (szName == NULL) return AVIERR_BADPARAM; hres = AVIStreamInfoA(pstream, &asia, sizeof(asia)); if (FAILED(hres)) return hres; memset(asia.szName, 0, sizeof(asia.szName)); lstrcpynA(asia.szName, szName, sizeof(asia.szName)/sizeof(asia.szName[0])); return EditStreamSetInfoA(pstream, &asia, sizeof(asia)); } /*********************************************************************** * EditStreamSetNameW (AVIFIL32.@) */ HRESULT WINAPI EditStreamSetNameW(PAVISTREAM pstream, LPCWSTR szName) { AVISTREAMINFOW asiw; HRESULT hres; TRACE("(%p,%s)\n", pstream, debugstr_w(szName)); if (pstream == NULL) return AVIERR_BADHANDLE; if (szName == NULL) return AVIERR_BADPARAM; hres = IAVIStream_Info(pstream, &asiw, sizeof(asiw)); if (FAILED(hres)) return hres; memset(asiw.szName, 0, sizeof(asiw.szName)); lstrcpynW(asiw.szName, szName, sizeof(asiw.szName)/sizeof(asiw.szName[0])); return EditStreamSetInfoW(pstream, &asiw, sizeof(asiw)); } /*********************************************************************** * AVIClearClipboard (AVIFIL32.@) */ HRESULT WINAPI AVIClearClipboard(void) { TRACE("()\n"); return AVIERR_UNSUPPORTED; /* OleSetClipboard(NULL); */ } /*********************************************************************** * AVIGetFromClipboard (AVIFIL32.@) */ HRESULT WINAPI AVIGetFromClipboard(PAVIFILE *ppfile) { FIXME("(%p), stub!\n", ppfile); *ppfile = NULL; return AVIERR_UNSUPPORTED; } /*********************************************************************** * AVIMakeStreamFromClipboard (AVIFIL32.@) */ HRESULT WINAPI AVIMakeStreamFromClipboard(UINT cfFormat, HANDLE hGlobal, PAVISTREAM * ppstream) { FIXME("(0x%08x,%p,%p), stub!\n", cfFormat, hGlobal, ppstream); if (ppstream == NULL) return AVIERR_BADHANDLE; return AVIERR_UNSUPPORTED; } /*********************************************************************** * AVIPutFileOnClipboard (AVIFIL32.@) */ HRESULT WINAPI AVIPutFileOnClipboard(PAVIFILE pfile) { FIXME("(%p), stub!\n", pfile); if (pfile == NULL) return AVIERR_BADHANDLE; return AVIERR_UNSUPPORTED; } HRESULT CDECL AVISaveA(LPCSTR szFile, CLSID * pclsidHandler, AVISAVECALLBACK lpfnCallback, int nStreams, PAVISTREAM pavi, LPAVICOMPRESSOPTIONS lpOptions, ...) { FIXME("(%s,%p,%p,0x%08x,%p,%p), stub!\n", debugstr_a(szFile), pclsidHandler, lpfnCallback, nStreams, pavi, lpOptions); return AVIERR_UNSUPPORTED; } HRESULT CDECL AVISaveW(LPCWSTR szFile, CLSID * pclsidHandler, AVISAVECALLBACK lpfnCallback, int nStreams, PAVISTREAM pavi, LPAVICOMPRESSOPTIONS lpOptions, ...) { FIXME("(%s,%p,%p,0x%08x,%p,%p), stub!\n", debugstr_w(szFile), pclsidHandler, lpfnCallback, nStreams, pavi, lpOptions); return AVIERR_UNSUPPORTED; }