| /* | |
| * Unit test suite for AVI Functions | |
| * | |
| * Copyright 2008 Detlef Riekenberg | |
| * | |
| * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| * | |
| */ | |
| #define COBJMACROS | |
| #define CONST_VTABLE | |
| #include "wine/test.h" | |
| #include "initguid.h" | |
| #include "wingdi.h" | |
| #include "vfw.h" | |
| /* ########################### */ | |
| DEFINE_AVIGUID(CLSID_WAVFile, 0x00020003, 0, 0); | |
| static const CHAR winetest0[] = "winetest0"; | |
| static const CHAR winetest1[] = "winetest1"; | |
| static const CHAR testfilename[] = "wine_avifil32_test.avi"; | |
| /* ########################### */ | |
| static const DWORD deffh[] = /* file_header */ | |
| { | |
| FOURCC_RIFF, 0x34c6 /* length */, formtypeAVI, | |
| FOURCC_LIST, 0x1ac /* length */, | |
| listtypeAVIHEADER, ckidAVIMAINHDR, sizeof(MainAVIHeader), | |
| }; | |
| static const MainAVIHeader defmah = | |
| { | |
| 0x00008256, /* dwMicroSecPerFrame */ | |
| 0x000080e8, /* dwMaxBytesPerSec */ | |
| 0x00000000, /* dwPaddingGranularity */ | |
| 0x00000910, /* dwFlags */ | |
| 1, /* dwTotalFrames */ | |
| 0, /* dwInitialFrames */ | |
| 2, /* dwStreams */ | |
| 0x00100000, /* dwSuggestedBufferSize*/ | |
| 8, /* dwWidth */ | |
| 6, /* dwHeight */ | |
| { 0, 0, 0, 0 } /* dwReserved[4] */ | |
| }; | |
| static const AVIStreamHeader defash0 = | |
| { | |
| streamtypeVIDEO, /* fccType */ | |
| 0x30323449, /* fccHandler */ | |
| 0x00000000, /* dwFlags */ | |
| 0, /* wPriority */ | |
| 0, /* wLanguage */ | |
| 0, /* dwInitialFrames */ | |
| 0x000003e9, /* dwScale */ | |
| 0x00007530, /* dwRate */ | |
| 0, /* dwStart */ | |
| 1, /* dwLength */ | |
| 0x00100000, /* dwSuggestedBufferSize*/ | |
| 0xffffffff, /* dwQuality */ | |
| 0, /* dwSampleSize */ | |
| { 0, 0, 0, 0 } /* short left right top bottom */ | |
| }; | |
| static const AVIStreamHeader defash1 = | |
| { | |
| /* AVIStreamHeader */ | |
| streamtypeAUDIO, /* fccType */ | |
| 1, /* fccHandler */ | |
| 0, /* dwFlags */ | |
| 0, /* wPriority */ | |
| 0, /* wLanguage */ | |
| 0, /* dwInitialFrames */ | |
| 1, /* dwScale */ | |
| 0x00002b11, /* dwRate */ | |
| 0, /* dwStart */ | |
| 0x00000665, /* dwLength */ | |
| 0x00003000, /* dwSuggestedBufferSize*/ | |
| 0xffffffff, /* dwQuality */ | |
| 2, /* dwSampleSize */ | |
| { 0, 0, 0, 0 } /* short left right top bottom */ | |
| }; | |
| static const PCMWAVEFORMAT defpcmwf = | |
| { | |
| { | |
| 1, /* wFormatTag */ | |
| 2, /* nChannels */ | |
| 11025, /* nSamplesPerSec */ | |
| 22050, /* nAvgBytesPerSec */ | |
| 2, /* nBlockAlign */ | |
| }, | |
| 8, /* wBitsPerSample */ | |
| }; | |
| typedef struct common_avi_headers { | |
| DWORD fh[sizeof(deffh)]; | |
| MainAVIHeader mah; | |
| AVIStreamHeader ash0; | |
| AVIStreamHeader ash1; | |
| PCMWAVEFORMAT pcmwf; | |
| } COMMON_AVI_HEADERS; | |
| /* Extra data needed to get the VFW API to load the file */ | |
| /* DWORD deffh */ | |
| /* MainAVIHeader mah */ | |
| static const DWORD streamlist[] = | |
| { | |
| FOURCC_LIST, 0xd4 /* length */, | |
| listtypeSTREAMHEADER, ckidSTREAMHEADER, 0x38 /* length */, | |
| }; | |
| /* AVIStreamHeader ash0 */ | |
| static const DWORD videostreamformat[] = | |
| { | |
| ckidSTREAMFORMAT, 0x28 /* length */, | |
| 0x00000028, 0x00000008, 0x00000006, 0x00180001, | |
| 0x30323449, 0x00000090, 0x00000000, 0x00000000, | |
| 0x00000000, 0x00000000, | |
| }; | |
| static const DWORD padding1[] = | |
| { | |
| ckidAVIPADDING, 0xc /* length */, | |
| 0x00000004, 0x00000000, 0x63643030 | |
| }; | |
| static const DWORD videopropheader[] = | |
| { | |
| 0x70727076, 0x44 /* length */, | |
| 0x00000000, 0x00000000, | |
| 0x0000001e, 0x00000008, 0x00000006, 0x00100009, | |
| 0x00000008, 0x00000006, 0x00000001, 0x00000006, | |
| 0x00000008, 0x00000006, 0x00000008, 0x00000000, | |
| 0x00000000, 0x00000000, 0x00000000, | |
| FOURCC_LIST, 0x70 /* length */, | |
| listtypeSTREAMHEADER, ckidSTREAMHEADER, 0x38 /* length */, | |
| }; | |
| /* AVIStreamHeader ash1 */ | |
| static const DWORD audiostreamformat_pre[] = | |
| { | |
| ckidSTREAMFORMAT, sizeof(PCMWAVEFORMAT) /* length */, | |
| }; | |
| /* PCMWAVEFORMAT pcmwf */ | |
| static DWORD data[] = | |
| { | |
| ckidAVIPADDING, 0xc /* length */, | |
| 0x00000004, 0x00000000, 0x62773130, | |
| ckidAVIPADDING, 0xc /* length */, | |
| 0x6c6d646f, 0x686c6d64, 0x000000f8, | |
| FOURCC_LIST, 0x18 /* length */, | |
| 0x4f464e49, | |
| 0x54465349, 0xc /* length */, | |
| 0x6676614c, 0x332e3235, 0x00302e37, | |
| ckidAVIPADDING, 0x4 /* length */, | |
| 0, | |
| FOURCC_LIST, 0xd1b /* length */, listtypeAVIMOVIE, | |
| 0, 0 | |
| }; | |
| /* ########################### */ | |
| static void test_AVISaveOptions(void) | |
| { | |
| AVICOMPRESSOPTIONS options[2]; | |
| LPAVICOMPRESSOPTIONS poptions[2]; | |
| PAVISTREAM streams[2] = {NULL, NULL}; | |
| HRESULT hres; | |
| DWORD res; | |
| LONG lres; | |
| poptions[0] = &options[0]; | |
| poptions[1] = &options[1]; | |
| ZeroMemory(options, sizeof(options)); | |
| SetLastError(0xdeadbeef); | |
| hres = CreateEditableStream(&streams[0], NULL); | |
| ok(hres == AVIERR_OK, "0: got 0x%x and %p (expected AVIERR_OK)\n", hres, streams[0]); | |
| SetLastError(0xdeadbeef); | |
| hres = CreateEditableStream(&streams[1], NULL); | |
| ok(hres == AVIERR_OK, "1: got 0x%x and %p (expected AVIERR_OK)\n", hres, streams[1]); | |
| SetLastError(0xdeadbeef); | |
| hres = EditStreamSetNameA(streams[0], winetest0); | |
| ok(hres == AVIERR_OK, "0: got 0x%x (expected AVIERR_OK)\n", hres); | |
| SetLastError(0xdeadbeef); | |
| hres = EditStreamSetNameA(streams[1], winetest1); | |
| ok(hres == AVIERR_OK, "1: got 0x%x (expected AVIERR_OK)\n", hres); | |
| if (winetest_interactive) { | |
| SetLastError(0xdeadbeef); | |
| res = AVISaveOptions(0, ICMF_CHOOSE_DATARATE |ICMF_CHOOSE_KEYFRAME | ICMF_CHOOSE_ALLCOMPRESSORS, | |
| 2, streams, poptions); | |
| trace("got %u with 0x%x/%u\n", res, GetLastError(), GetLastError()); | |
| } | |
| SetLastError(0xdeadbeef); | |
| lres = AVISaveOptionsFree(2, poptions); | |
| ok(lres == AVIERR_OK, "got 0x%x with 0x%x/%u\n", lres, GetLastError(), GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| res = AVIStreamRelease(streams[0]); | |
| ok(res == 0, "0: got refcount %u (expected 0)\n", res); | |
| SetLastError(0xdeadbeef); | |
| res = AVIStreamRelease(streams[1]); | |
| ok(res == 0, "1: got refcount %u (expected 0)\n", res); | |
| } | |
| /* ########################### */ | |
| static void test_EditStreamSetInfo(void) | |
| { | |
| PAVISTREAM stream = NULL; | |
| HRESULT hres; | |
| AVISTREAMINFOA info, info2; | |
| hres = CreateEditableStream(&stream, NULL); | |
| ok(hres == AVIERR_OK, "got 0x%08X, expected AVIERR_OK\n", hres); | |
| /* Size parameter is somehow checked (notice the crash with size=-1 below) */ | |
| hres = EditStreamSetInfoA(stream, NULL, 0); | |
| ok( hres == AVIERR_BADSIZE, "got 0x%08X, expected AVIERR_BADSIZE\n", hres); | |
| hres = EditStreamSetInfoA(stream, NULL, sizeof(AVISTREAMINFOA)-1 ); | |
| ok( hres == AVIERR_BADSIZE, "got 0x%08X, expected AVIERR_BADSIZE\n", hres); | |
| if(0) | |
| { | |
| /* Crashing - first parameter not checked */ | |
| EditStreamSetInfoA(NULL, &info, sizeof(info) ); | |
| /* Crashing - second parameter not checked */ | |
| EditStreamSetInfoA(stream, NULL, sizeof(AVISTREAMINFOA) ); | |
| EditStreamSetInfoA(stream, NULL, -1); | |
| } | |
| hres = AVIStreamInfoA(stream, &info, sizeof(info) ); | |
| ok( hres == 0, "got 0x%08X, expected 0\n", hres); | |
| /* Does the function check what's it's updating ? */ | |
| #define IS_INFO_UPDATED(m) do { \ | |
| hres = EditStreamSetInfoA(stream, &info, sizeof(info) ); \ | |
| ok( hres == 0, "got 0x%08X, expected 0\n", hres); \ | |
| hres = AVIStreamInfoA(stream, &info2, sizeof(info2) ); \ | |
| ok( hres == 0, "got 0x%08X, expected 0\n", hres); \ | |
| ok( info2.m == info.m, "EditStreamSetInfo did not update "#m" parameter\n" ); \ | |
| } while(0) | |
| info.dwStart++; | |
| IS_INFO_UPDATED(dwStart); | |
| info.dwStart = 0; | |
| IS_INFO_UPDATED(dwStart); | |
| info.wPriority++; | |
| IS_INFO_UPDATED(wPriority); | |
| info.wPriority = 0; | |
| IS_INFO_UPDATED(wPriority); | |
| info.wLanguage++; | |
| IS_INFO_UPDATED(wLanguage); | |
| info.wLanguage = 0; | |
| IS_INFO_UPDATED(wLanguage); | |
| info.dwScale++; | |
| IS_INFO_UPDATED(dwScale); | |
| info.dwScale = 0; | |
| IS_INFO_UPDATED(dwScale); | |
| info.dwRate++; | |
| IS_INFO_UPDATED(dwRate); | |
| info.dwRate = 0; | |
| IS_INFO_UPDATED(dwRate); | |
| info.dwQuality++; | |
| IS_INFO_UPDATED(dwQuality); | |
| info.dwQuality = 0; | |
| IS_INFO_UPDATED(dwQuality); | |
| info.dwQuality = -2; | |
| IS_INFO_UPDATED(dwQuality); | |
| info.dwQuality = ICQUALITY_HIGH+1; | |
| IS_INFO_UPDATED(dwQuality); | |
| info.rcFrame.left = 0; | |
| IS_INFO_UPDATED(rcFrame.left); | |
| info.rcFrame.top = 0; | |
| IS_INFO_UPDATED(rcFrame.top); | |
| info.rcFrame.right = 0; | |
| IS_INFO_UPDATED(rcFrame.right); | |
| info.rcFrame.bottom = 0; | |
| IS_INFO_UPDATED(rcFrame.bottom); | |
| info.rcFrame.left = -1; | |
| IS_INFO_UPDATED(rcFrame.left); | |
| info.rcFrame.top = -1; | |
| IS_INFO_UPDATED(rcFrame.top); | |
| info.rcFrame.right = -1; | |
| IS_INFO_UPDATED(rcFrame.right); | |
| info.rcFrame.bottom = -1; | |
| IS_INFO_UPDATED(rcFrame.bottom); | |
| AVIStreamRelease(stream); | |
| #undef IS_INFO_UPDATED | |
| } | |
| static void init_test_struct(COMMON_AVI_HEADERS *cah) | |
| { | |
| memcpy(cah->fh, deffh, sizeof(deffh)); | |
| cah->mah = defmah; | |
| cah->ash0 = defash0; | |
| cah->ash1 = defash1; | |
| cah->pcmwf = defpcmwf; | |
| } | |
| static void create_avi_file(const COMMON_AVI_HEADERS *cah, char *filename) | |
| { | |
| HANDLE hFile; | |
| DWORD written; | |
| hFile = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); | |
| ok(hFile != INVALID_HANDLE_VALUE, "Couldn't create file\n"); | |
| WriteFile(hFile, &cah->fh, sizeof(deffh), &written, NULL); | |
| WriteFile(hFile, &cah->mah, sizeof(MainAVIHeader), &written, NULL); | |
| WriteFile(hFile, streamlist, sizeof(streamlist), &written, NULL); | |
| WriteFile(hFile, &cah->ash0, 0x38, &written, NULL); | |
| WriteFile(hFile, videostreamformat, sizeof(videostreamformat), &written, NULL); | |
| WriteFile(hFile, padding1, sizeof(padding1), &written, NULL); | |
| WriteFile(hFile, videopropheader, sizeof(videopropheader), &written, NULL); | |
| WriteFile(hFile, &cah->ash1, 0x38, &written, NULL); | |
| WriteFile(hFile, audiostreamformat_pre, sizeof(audiostreamformat_pre), &written, NULL); | |
| WriteFile(hFile, &cah->pcmwf, sizeof(PCMWAVEFORMAT), &written, NULL); | |
| WriteFile(hFile, data, sizeof(data), &written, NULL); | |
| CloseHandle(hFile); | |
| } | |
| static void test_default_data(void) | |
| { | |
| COMMON_AVI_HEADERS cah; | |
| char filename[MAX_PATH]; | |
| PAVIFILE pFile; | |
| int res; | |
| LONG lSize; | |
| PAVISTREAM pStream0; | |
| PAVISTREAM pStream1; | |
| AVISTREAMINFOA asi0, asi1; | |
| WAVEFORMATEX wfx; | |
| GetTempPathA(MAX_PATH, filename); | |
| strcpy(filename+strlen(filename), testfilename); | |
| init_test_struct(&cah); | |
| create_avi_file(&cah, filename); | |
| res = AVIFileOpenA(&pFile, filename, OF_SHARE_DENY_WRITE, 0L); | |
| ok(res == 0, "Unable to open file: error=%u\n", res); | |
| pStream0 = (void *)0xdeadbeef; | |
| res = AVIFileGetStream(pFile, &pStream0, ~0U, 0); | |
| ok(res == AVIERR_NODATA, "expected AVIERR_NODATA, got %u\n", res); | |
| ok(pStream0 == NULL, "AVIFileGetStream should set stream to NULL\n"); | |
| res = AVIFileGetStream(pFile, &pStream0, 0, 0); | |
| ok(res == 0, "Unable to open video stream: error=%u\n", res); | |
| res = AVIFileGetStream(pFile, &pStream1, 0, 1); | |
| ok(res == 0, "Unable to open audio stream: error=%u\n", res); | |
| res = AVIStreamInfoA(pStream0, &asi0, sizeof(asi0)); | |
| ok(res == 0, "Unable to read stream info: error=%u\n", res); | |
| res = AVIStreamInfoA(pStream1, &asi1, sizeof(asi1)); | |
| ok(res == 0, "Unable to read stream info: error=%u\n", res); | |
| res = AVIStreamReadFormat(pStream0, AVIStreamStart(pStream1), NULL, &lSize); | |
| ok(res == 0, "Unable to read format size: error=%u\n", res); | |
| res = AVIStreamReadFormat(pStream1, AVIStreamStart(pStream1), &wfx, &lSize); | |
| ok(res == 0, "Unable to read format: error=%u\n", res); | |
| ok(asi0.fccType == streamtypeVIDEO, "got 0x%x (expected streamtypeVIDEO)\n", asi0.fccType); | |
| ok(asi0.fccHandler == 0x30323449, "got 0x%x (expected 0x30323449)\n", asi0.fccHandler); | |
| ok(asi0.dwFlags == 0, "got %u (expected 0)\n", asi0.dwFlags); | |
| ok(asi0.wPriority == 0, "got %u (expected 0)\n", asi0.wPriority); | |
| ok(asi0.wLanguage == 0, "got %u (expected 0)\n", asi0.wLanguage); | |
| ok(asi0.dwScale == 1001, "got %u (expected 1001)\n", asi0.dwScale); | |
| ok(asi0.dwRate == 30000, "got %u (expected 30000)\n", asi0.dwRate); | |
| ok(asi0.dwStart == 0, "got %u (expected 0)\n", asi0.dwStart); | |
| ok(asi0.dwLength == 1, "got %u (expected 1)\n", asi0.dwLength); | |
| ok(asi0.dwInitialFrames == 0, "got %u (expected 0)\n", asi0.dwInitialFrames); | |
| ok(asi0.dwSuggestedBufferSize == 0, "got %u (expected 0)\n", asi0.dwSuggestedBufferSize); | |
| ok(asi0.dwQuality == 0xffffffff, "got 0x%x (expected 0xffffffff)\n", asi0.dwQuality); | |
| ok(asi0.dwSampleSize == 0, "got %u (expected 0)\n", asi0.dwSampleSize); | |
| ok(asi0.rcFrame.left == 0, "got %u (expected 0)\n", asi0.rcFrame.left); | |
| ok(asi0.rcFrame.top == 0, "got %u (expected 0)\n", asi0.rcFrame.top); | |
| ok(asi0.rcFrame.right == 8, "got %u (expected 8)\n", asi0.rcFrame.right); /* these are based on the values in the mah and not */ | |
| ok(asi0.rcFrame.bottom == 6, "got %u (expected 6)\n", asi0.rcFrame.bottom);/* on the ones in the ash which are 0 here */ | |
| ok(asi0.dwEditCount == 0, "got %u (expected 0)\n", asi0.dwEditCount); | |
| ok(asi0.dwFormatChangeCount == 0, "got %u (expected 0)\n", asi0.dwFormatChangeCount); | |
| ok(asi1.fccType == streamtypeAUDIO, "got 0x%x (expected streamtypeVIDEO)\n", asi1.fccType); | |
| ok(asi1.fccHandler == 0x1, "got 0x%x (expected 0x1)\n", asi1.fccHandler); | |
| ok(asi1.dwFlags == 0, "got %u (expected 0)\n", asi1.dwFlags); | |
| ok(asi1.wPriority == 0, "got %u (expected 0)\n", asi1.wPriority); | |
| ok(asi1.wLanguage == 0, "got %u (expected 0)\n", asi1.wLanguage); | |
| ok(asi1.dwScale == 1, "got %u (expected 1)\n", asi1.dwScale); | |
| ok(asi1.dwRate == 11025, "got %u (expected 11025)\n", asi1.dwRate); | |
| ok(asi1.dwStart == 0, "got %u (expected 0)\n", asi1.dwStart); | |
| ok(asi1.dwLength == 1637, "got %u (expected 1637)\n", asi1.dwLength); | |
| ok(asi1.dwInitialFrames == 0, "got %u (expected 0)\n", asi1.dwInitialFrames); | |
| ok(asi1.dwSuggestedBufferSize == 0, "got %u (expected 0)\n", asi1.dwSuggestedBufferSize); | |
| ok(asi1.dwQuality == 0xffffffff, "got 0x%x (expected 0xffffffff)\n", asi1.dwQuality); | |
| ok(asi1.dwSampleSize == 2, "got %u (expected 2)\n", asi1.dwSampleSize); | |
| ok(asi1.rcFrame.left == 0, "got %u (expected 0)\n", asi1.rcFrame.left); | |
| ok(asi1.rcFrame.top == 0, "got %u (expected 0)\n", asi1.rcFrame.top); | |
| ok(asi1.rcFrame.right == 0, "got %u (expected 0)\n", asi1.rcFrame.right); | |
| ok(asi1.rcFrame.bottom == 0, "got %u (expected 0)\n", asi1.rcFrame.bottom); | |
| ok(asi1.dwEditCount == 0, "got %u (expected 0)\n", asi1.dwEditCount); | |
| ok(asi1.dwFormatChangeCount == 0, "got %u (expected 0)\n", asi1.dwFormatChangeCount); | |
| ok(wfx.wFormatTag == 1, "got %u (expected 1)\n",wfx.wFormatTag); | |
| ok(wfx.nChannels == 2, "got %u (expected 2)\n",wfx.nChannels); | |
| ok(wfx.wFormatTag == 1, "got %u (expected 1)\n",wfx.wFormatTag); | |
| ok(wfx.nSamplesPerSec == 11025, "got %u (expected 11025)\n",wfx.nSamplesPerSec); | |
| ok(wfx.nAvgBytesPerSec == 22050, "got %u (expected 22050)\n",wfx.nAvgBytesPerSec); | |
| ok(wfx.nBlockAlign == 2, "got %u (expected 2)\n",wfx.nBlockAlign); | |
| AVIStreamRelease(pStream0); | |
| AVIStreamRelease(pStream1); | |
| AVIFileRelease(pFile); | |
| ok(DeleteFileA(filename) !=0, "Deleting file %s failed\n", filename); | |
| } | |
| static void test_amh_corruption(void) | |
| { | |
| COMMON_AVI_HEADERS cah; | |
| char filename[MAX_PATH]; | |
| PAVIFILE pFile; | |
| int res; | |
| GetTempPathA(MAX_PATH, filename); | |
| strcpy(filename+strlen(filename), testfilename); | |
| /* Make sure only AVI files with the proper headers will be loaded */ | |
| init_test_struct(&cah); | |
| cah.fh[3] = mmioFOURCC('A', 'V', 'i', ' '); | |
| create_avi_file(&cah, filename); | |
| res = AVIFileOpenA(&pFile, filename, OF_SHARE_DENY_WRITE, 0L); | |
| ok(res != 0, "Able to open file: error=%u\n", res); | |
| ok(DeleteFileA(filename) !=0, "Deleting file %s failed\n", filename); | |
| } | |
| static void test_ash1_corruption(void) | |
| { | |
| COMMON_AVI_HEADERS cah; | |
| char filename[MAX_PATH]; | |
| PAVIFILE pFile; | |
| int res; | |
| PAVISTREAM pStream1; | |
| AVISTREAMINFOA asi1; | |
| GetTempPathA(MAX_PATH, filename); | |
| strcpy(filename+strlen(filename), testfilename); | |
| /* Corrupt the sample size in the audio stream header */ | |
| init_test_struct(&cah); | |
| cah.ash1.dwSampleSize = 0xdeadbeef; | |
| create_avi_file(&cah, filename); | |
| res = AVIFileOpenA(&pFile, filename, OF_SHARE_DENY_WRITE, 0L); | |
| ok(res == 0, "Unable to open file: error=%u\n", res); | |
| res = AVIFileGetStream(pFile, &pStream1, 0, 1); | |
| ok(res == 0, "Unable to open audio stream: error=%u\n", res); | |
| res = AVIStreamInfoA(pStream1, &asi1, sizeof(asi1)); | |
| ok(res == 0, "Unable to read stream info: error=%u\n", res); | |
| /* The result will still be 2, because the value is dynamically replaced with the nBlockAlign | |
| value from the stream format header. The next test will prove this */ | |
| ok(asi1.dwSampleSize == 2, "got %u (expected 2)\n", asi1.dwSampleSize); | |
| AVIStreamRelease(pStream1); | |
| AVIFileRelease(pFile); | |
| ok(DeleteFileA(filename) !=0, "Deleting file %s failed\n", filename); | |
| } | |
| static void test_ash1_corruption2(void) | |
| { | |
| COMMON_AVI_HEADERS cah; | |
| char filename[MAX_PATH]; | |
| PAVIFILE pFile; | |
| int res; | |
| PAVISTREAM pStream1; | |
| AVISTREAMINFOA asi1; | |
| GetTempPathA(MAX_PATH, filename); | |
| strcpy(filename+strlen(filename), testfilename); | |
| /* Corrupt the block alignment in the audio format header */ | |
| init_test_struct(&cah); | |
| cah.pcmwf.wf.nBlockAlign = 0xdead; | |
| create_avi_file(&cah, filename); | |
| res = AVIFileOpenA(&pFile, filename, OF_SHARE_DENY_WRITE, 0L); | |
| ok(res == 0, "Unable to open file: error=%u\n", res); | |
| res = AVIFileGetStream(pFile, &pStream1, 0, 1); | |
| ok(res == 0, "Unable to open audio stream: error=%u\n", res); | |
| ok(AVIStreamInfoA(pStream1, &asi1, sizeof(asi1)) == 0, "Unable to read stream info\n"); | |
| /* The result will also be the corrupt value, as explained above. */ | |
| ok(asi1.dwSampleSize == 0xdead, "got 0x%x (expected 0xdead)\n", asi1.dwSampleSize); | |
| AVIStreamRelease(pStream1); | |
| AVIFileRelease(pFile); | |
| ok(DeleteFileA(filename) !=0, "Deleting file %s failed\n", filename); | |
| } | |
| /* Outer IUnknown for COM aggregation tests */ | |
| struct unk_impl { | |
| IUnknown IUnknown_iface; | |
| LONG ref; | |
| IUnknown *inner_unk; | |
| }; | |
| static inline struct unk_impl *impl_from_IUnknown(IUnknown *iface) | |
| { | |
| return CONTAINING_RECORD(iface, struct unk_impl, IUnknown_iface); | |
| } | |
| static HRESULT WINAPI unk_QueryInterface(IUnknown *iface, REFIID riid, void **ppv) | |
| { | |
| struct unk_impl *This = impl_from_IUnknown(iface); | |
| LONG ref = This->ref; | |
| HRESULT hr; | |
| if (IsEqualGUID(riid, &IID_IUnknown)) | |
| { | |
| *ppv = iface; | |
| IUnknown_AddRef(iface); | |
| return S_OK; | |
| } | |
| hr = IUnknown_QueryInterface(This->inner_unk, riid, ppv); | |
| if (hr == S_OK) | |
| { | |
| trace("Working around COM aggregation ref counting bug\n"); | |
| ok(ref == This->ref, "Outer ref count expected %d got %d\n", ref, This->ref); | |
| IUnknown_AddRef((IUnknown*)*ppv); | |
| ref = IUnknown_Release(This->inner_unk); | |
| ok(ref == 1, "Inner ref count expected 1 got %d\n", ref); | |
| } | |
| return hr; | |
| } | |
| static ULONG WINAPI unk_AddRef(IUnknown *iface) | |
| { | |
| struct unk_impl *This = impl_from_IUnknown(iface); | |
| return InterlockedIncrement(&This->ref); | |
| } | |
| static ULONG WINAPI unk_Release(IUnknown *iface) | |
| { | |
| struct unk_impl *This = impl_from_IUnknown(iface); | |
| return InterlockedDecrement(&This->ref); | |
| } | |
| static const IUnknownVtbl unk_vtbl = | |
| { | |
| unk_QueryInterface, | |
| unk_AddRef, | |
| unk_Release | |
| }; | |
| static void test_COM(void) | |
| { | |
| struct unk_impl unk_obj = {{&unk_vtbl}, 19, NULL}; | |
| IAVIFile *avif = NULL; | |
| IPersistFile *pf; | |
| IUnknown *unk; | |
| LONG refcount; | |
| HRESULT hr; | |
| /* COM aggregation */ | |
| hr = CoCreateInstance(&CLSID_AVIFile, &unk_obj.IUnknown_iface, CLSCTX_INPROC_SERVER, | |
| &IID_IUnknown, (void**)&unk_obj.inner_unk); | |
| ok(hr == S_OK, "COM aggregation failed: %08x, expected S_OK\n", hr); | |
| hr = IUnknown_QueryInterface(&unk_obj.IUnknown_iface, &IID_IAVIFile, (void**)&avif); | |
| ok(hr == S_OK, "QueryInterface for IID_IAVIFile failed: %08x\n", hr); | |
| refcount = IAVIFile_AddRef(avif); | |
| ok(refcount == unk_obj.ref, "AVIFile just pretends to support COM aggregation\n"); | |
| refcount = IAVIFile_Release(avif); | |
| ok(refcount == unk_obj.ref, "AVIFile just pretends to support COM aggregation\n"); | |
| hr = IAVIFile_QueryInterface(avif, &IID_IPersistFile, (void**)&pf); | |
| ok(hr == S_OK, "QueryInterface for IID_IPersistFile failed: %08x\n", hr); | |
| refcount = IPersistFile_Release(pf); | |
| ok(refcount == unk_obj.ref, "AVIFile just pretends to support COM aggregation\n"); | |
| refcount = IAVIFile_Release(avif); | |
| ok(refcount == 19, "Outer ref count should be back at 19 but is %d\n", refcount); | |
| refcount = IUnknown_Release(unk_obj.inner_unk); | |
| ok(refcount == 0, "Inner ref count should be 0 but is %u\n", refcount); | |
| /* Invalid RIID */ | |
| hr = CoCreateInstance(&CLSID_AVIFile, NULL, CLSCTX_INPROC_SERVER, &IID_IAVIStream, | |
| (void**)&avif); | |
| ok(hr == E_NOINTERFACE, "AVIFile create failed: %08x, expected E_NOINTERFACE\n", hr); | |
| /* Same refcount */ | |
| hr = CoCreateInstance(&CLSID_AVIFile, NULL, CLSCTX_INPROC_SERVER, &IID_IAVIFile, (void**)&avif); | |
| ok(hr == S_OK, "AVIFile create failed: %08x, expected S_OK\n", hr); | |
| refcount = IAVIFile_AddRef(avif); | |
| ok(refcount == 2, "refcount == %u, expected 2\n", refcount); | |
| hr = IAVIFile_QueryInterface(avif, &IID_IUnknown, (void**)&unk); | |
| ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr); | |
| refcount = IUnknown_AddRef(unk); | |
| ok(refcount == 4, "refcount == %u, expected 4\n", refcount); | |
| hr = IAVIFile_QueryInterface(avif, &IID_IPersistFile, (void**)&pf); | |
| ok(hr == S_OK, "QueryInterface for IID_IPersistFile failed: %08x\n", hr); | |
| refcount = IPersistFile_AddRef(pf); | |
| ok(refcount == 6, "refcount == %u, expected 6\n", refcount); | |
| while (IAVIFile_Release(avif)); | |
| } | |
| static void test_COM_wavfile(void) | |
| { | |
| struct unk_impl unk_obj = {{&unk_vtbl}, 19, NULL}; | |
| IAVIFile *avif = NULL; | |
| IPersistFile *pf; | |
| IAVIStream *avis; | |
| IUnknown *unk; | |
| ULONG refcount; | |
| HRESULT hr; | |
| /* COM aggregation */ | |
| hr = CoCreateInstance(&CLSID_WAVFile, &unk_obj.IUnknown_iface, CLSCTX_INPROC_SERVER, | |
| &IID_IUnknown, (void**)&unk_obj.inner_unk); | |
| ok(hr == S_OK, "COM aggregation failed: %08x, expected S_OK\n", hr); | |
| hr = IUnknown_QueryInterface(&unk_obj.IUnknown_iface, &IID_IAVIFile, (void**)&avif); | |
| ok(hr == S_OK, "QueryInterface for IID_IAVIFile failed: %08x\n", hr); | |
| refcount = IAVIFile_AddRef(avif); | |
| ok(refcount == unk_obj.ref, "WAVFile just pretends to support COM aggregation\n"); | |
| refcount = IAVIFile_Release(avif); | |
| ok(refcount == unk_obj.ref, "WAVFile just pretends to support COM aggregation\n"); | |
| hr = IAVIFile_QueryInterface(avif, &IID_IPersistFile, (void**)&pf); | |
| ok(hr == S_OK, "QueryInterface for IID_IPersistFile failed: %08x\n", hr); | |
| refcount = IPersistFile_Release(pf); | |
| ok(refcount == unk_obj.ref, "WAVFile just pretends to support COM aggregation\n"); | |
| refcount = IAVIFile_Release(avif); | |
| ok(refcount == 19, "Outer ref count should be back at 19 but is %d\n", refcount); | |
| refcount = IUnknown_Release(unk_obj.inner_unk); | |
| ok(refcount == 0, "Inner ref count should be 0 but is %u\n", refcount); | |
| /* Invalid RIID */ | |
| hr = CoCreateInstance(&CLSID_WAVFile, NULL, CLSCTX_INPROC_SERVER, &IID_IAVIStreaming, | |
| (void**)&avif); | |
| ok(hr == E_NOINTERFACE, "WAVFile create failed: %08x, expected E_NOINTERFACE\n", hr); | |
| /* Same refcount for all WAVFile interfaces */ | |
| hr = CoCreateInstance(&CLSID_WAVFile, NULL, CLSCTX_INPROC_SERVER, &IID_IAVIFile, (void**)&avif); | |
| ok(hr == S_OK, "WAVFile create failed: %08x, expected S_OK\n", hr); | |
| refcount = IAVIFile_AddRef(avif); | |
| ok(refcount == 2, "refcount == %u, expected 2\n", refcount); | |
| hr = IAVIFile_QueryInterface(avif, &IID_IPersistFile, (void**)&pf); | |
| ok(hr == S_OK, "QueryInterface for IID_IPersistFile failed: %08x\n", hr); | |
| refcount = IPersistFile_AddRef(pf); | |
| ok(refcount == 4, "refcount == %u, expected 4\n", refcount); | |
| refcount = IPersistFile_Release(pf); | |
| hr = IAVIFile_QueryInterface(avif, &IID_IAVIStream, (void**)&avis); | |
| ok(hr == S_OK, "QueryInterface for IID_IAVIStream failed: %08x\n", hr); | |
| refcount = IAVIStream_AddRef(avis); | |
| ok(refcount == 5, "refcount == %u, expected 5\n", refcount); | |
| refcount = IAVIStream_Release(avis); | |
| hr = IAVIFile_QueryInterface(avif, &IID_IUnknown, (void**)&unk); | |
| ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr); | |
| refcount = IUnknown_AddRef(unk); | |
| ok(refcount == 6, "refcount == %u, expected 6\n", refcount); | |
| refcount = IUnknown_Release(unk); | |
| while (IAVIFile_Release(avif)); | |
| } | |
| static void test_COM_editstream(void) | |
| { | |
| IAVIEditStream *edit; | |
| IAVIStream *stream; | |
| IUnknown *unk; | |
| ULONG refcount; | |
| HRESULT hr; | |
| /* Same refcount for all AVIEditStream interfaces */ | |
| hr = CreateEditableStream(&stream, NULL); | |
| ok(hr == S_OK, "AVIEditStream create failed: %08x, expected S_OK\n", hr); | |
| refcount = IAVIStream_AddRef(stream); | |
| ok(refcount == 2, "refcount == %u, expected 2\n", refcount); | |
| hr = IAVIStream_QueryInterface(stream, &IID_IAVIEditStream, (void**)&edit); | |
| ok(hr == S_OK, "QueryInterface for IID_IAVIEditStream failed: %08x\n", hr); | |
| refcount = IAVIEditStream_AddRef(edit); | |
| ok(refcount == 4, "refcount == %u, expected 4\n", refcount); | |
| refcount = IAVIEditStream_Release(edit); | |
| hr = IAVIEditStream_QueryInterface(edit, &IID_IUnknown, (void**)&unk); | |
| ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr); | |
| refcount = IUnknown_AddRef(unk); | |
| ok(refcount == 5, "refcount == %u, expected 5\n", refcount); | |
| IUnknown_Release(unk); | |
| while (IAVIEditStream_Release(edit)); | |
| } | |
| START_TEST(api) | |
| { | |
| AVIFileInit(); | |
| test_EditStreamSetInfo(); | |
| test_AVISaveOptions(); | |
| test_default_data(); | |
| test_amh_corruption(); | |
| test_ash1_corruption(); | |
| test_ash1_corruption2(); | |
| test_COM(); | |
| test_COM_wavfile(); | |
| test_COM_editstream(); | |
| AVIFileExit(); | |
| } |