git.oblomov.eu Git - wine/blob - dlls/avifil32/tests/api.c

   1 /*
   2  * Unit test suite for AVI Functions
   3  *
   4  * Copyright 2008 Detlef Riekenberg
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #define COBJMACROS
  23 #define CONST_VTABLE
  24
  25 #include "wine/test.h"
  26 #include "initguid.h"
  27 #include "wingdi.h"
  28 #include "vfw.h"
  29
  30 /* ########################### */
  31
  32 static const CHAR winetest0[] = "winetest0";
  33 static const CHAR winetest1[] = "winetest1";
  34 static const CHAR testfilename[]  = "wine_avifil32_test.avi";
  35
  36 /* ########################### */
  37
  38 static const DWORD deffh[] = /* file_header */
  39 {
  40     FOURCC_RIFF, 0x34c6 /* length */, formtypeAVI,
  41     FOURCC_LIST, 0x1ac /* length */,
  42     listtypeAVIHEADER, ckidAVIMAINHDR, sizeof(MainAVIHeader),
  43 };
  44
  45 static const MainAVIHeader defmah =
  46 {
  47     0x00008256, /* dwMicroSecPerFrame   */
  48     0x000080e8, /* dwMaxBytesPerSec     */
  49     0x00000000, /* dwPaddingGranularity */
  50     0x00000910, /* dwFlags              */
  51     1,          /* dwTotalFrames        */
  52     0,          /* dwInitialFrames      */
  53     2,          /* dwStreams            */
  54     0x00100000, /* dwSuggestedBufferSize*/
  55     8,          /* dwWidth              */
  56     6,          /* dwHeight             */
  57     { 0, 0, 0, 0 } /* dwReserved[4] */
  58 };
  59
  60 static const AVIStreamHeader defash0 =
  61 {
  62     streamtypeVIDEO, /* fccType              */
  63     0x30323449,      /* fccHandler           */
  64     0x00000000,      /* dwFlags              */
  65     0,               /* wPriority            */
  66     0,               /* wLanguage            */
  67     0,               /* dwInitialFrames      */
  68     0x000003e9,      /* dwScale              */
  69     0x00007530,      /* dwRate               */
  70     0,               /* dwStart              */
  71     1,               /* dwLength             */
  72     0x00100000,      /* dwSuggestedBufferSize*/
  73     0xffffffff,      /* dwQuality            */
  74     0,               /* dwSampleSize         */
  75     { 0, 0, 0, 0 }   /* short left right top bottom */
  76 };
  77
  78 static const AVIStreamHeader defash1 =
  79 {
  80     /* AVIStreamHeader */
  81     streamtypeAUDIO, /* fccType              */
  82     1,               /* fccHandler           */
  83     0,               /* dwFlags              */
  84     0,               /* wPriority            */
  85     0,               /* wLanguage            */
  86     0,               /* dwInitialFrames      */
  87     1,               /* dwScale              */
  88     0x00002b11,      /* dwRate               */
  89     0,               /* dwStart              */
  90     0x00000665,      /* dwLength             */
  91     0x00003000,      /* dwSuggestedBufferSize*/
  92     0xffffffff,      /* dwQuality            */
  93     2,               /* dwSampleSize         */
  94     { 0, 0, 0, 0 }   /* short left right top bottom */
  95 };
  96
  97 static const PCMWAVEFORMAT defpcmwf =
  98 {
  99     {
 100         1,      /* wFormatTag      */
 101         2,      /* nChannels       */
 102         11025,  /* nSamplesPerSec  */
 103         22050,  /* nAvgBytesPerSec */
 104         2,      /* nBlockAlign     */
 105     },
 106     8,      /* wBitsPerSample  */
 107 };
 108
 109 typedef struct common_avi_headers {
 110     DWORD           fh[sizeof(deffh)];
 111     MainAVIHeader   mah;
 112     AVIStreamHeader ash0;
 113     AVIStreamHeader ash1;
 114     PCMWAVEFORMAT   pcmwf;
 115 } COMMON_AVI_HEADERS;
 116
 117 /* Extra data needed to get the VFW API to load the file */
 118 /* DWORD deffh */
 119 /* MainAVIHeader mah */
 120 static const DWORD streamlist[] =
 121 {
 122     FOURCC_LIST, 0xd4 /* length */,
 123     listtypeSTREAMHEADER, ckidSTREAMHEADER, 0x38 /* length */,
 124 };
 125 /* AVIStreamHeader ash0 */
 126 static const DWORD videostreamformat[] =
 127 {
 128     ckidSTREAMFORMAT, 0x28 /* length */,
 129     0x00000028, 0x00000008, 0x00000006, 0x00180001,
 130     0x30323449, 0x00000090, 0x00000000, 0x00000000,
 131     0x00000000, 0x00000000,
 132 };
 133 static const DWORD padding1[] =
 134 {
 135     ckidAVIPADDING, 0xc /* length */,
 136     0x00000004, 0x00000000, 0x63643030
 137 };
 138 static const DWORD videopropheader[] =
 139 {
 140     0x70727076, 0x44 /* length */,
 141     0x00000000, 0x00000000,
 142     0x0000001e, 0x00000008, 0x00000006, 0x00100009,
 143     0x00000008, 0x00000006, 0x00000001, 0x00000006,
 144     0x00000008, 0x00000006, 0x00000008, 0x00000000,
 145     0x00000000, 0x00000000, 0x00000000,
 146     FOURCC_LIST, 0x70 /* length */,
 147     listtypeSTREAMHEADER, ckidSTREAMHEADER, 0x38 /* length */,
 148 };
 149 /* AVIStreamHeader ash1 */
 150 static const DWORD audiostreamformat_pre[] =
 151 {
 152     ckidSTREAMFORMAT, sizeof(PCMWAVEFORMAT) /* length */,
 153 };
 154 /* PCMWAVEFORMAT pcmwf */
 155 static DWORD data[] =
 156 {
 157     ckidAVIPADDING, 0xc /* length */,
 158     0x00000004, 0x00000000, 0x62773130,
 159     ckidAVIPADDING, 0xc /* length */,
 160     0x6c6d646f, 0x686c6d64, 0x000000f8,
 161     FOURCC_LIST, 0x18 /* length */,
 162     0x4f464e49,
 163     0x54465349, 0xc /* length */,
 164     0x6676614c, 0x332e3235, 0x00302e37,
 165     ckidAVIPADDING, 0x4 /* length */,
 166     0,
 167     FOURCC_LIST, 0xd1b /* length */, listtypeAVIMOVIE,
 168     0, 0
 169 };
 170
 171 /* ########################### */
 172
 173 static void test_AVISaveOptions(void)
 174 {
 175     AVICOMPRESSOPTIONS options[2];
 176     LPAVICOMPRESSOPTIONS poptions[2];
 177     PAVISTREAM streams[2] = {NULL, NULL};
 178     HRESULT hres;
 179     DWORD   res;
 180     LONG    lres;
 181
 182     poptions[0] = &options[0];
 183     poptions[1] = &options[1];
 184     ZeroMemory(options, sizeof(options));
 185
 186     SetLastError(0xdeadbeef);
 187     hres = CreateEditableStream(&streams[0], NULL);
 188     ok(hres == AVIERR_OK, "0: got 0x%x and %p (expected AVIERR_OK)\n", hres, streams[0]);
 189
 190     SetLastError(0xdeadbeef);
 191     hres = CreateEditableStream(&streams[1], NULL);
 192     ok(hres == AVIERR_OK, "1: got 0x%x and %p (expected AVIERR_OK)\n", hres, streams[1]);
 193
 194     SetLastError(0xdeadbeef);
 195     hres = EditStreamSetNameA(streams[0], winetest0);
 196     ok(hres == AVIERR_OK, "0: got 0x%x (expected AVIERR_OK)\n", hres);
 197
 198     SetLastError(0xdeadbeef);
 199     hres = EditStreamSetNameA(streams[1], winetest1);
 200     ok(hres == AVIERR_OK, "1: got 0x%x (expected AVIERR_OK)\n", hres);
 201
 202     if (winetest_interactive) {
 203         SetLastError(0xdeadbeef);
 204         res = AVISaveOptions(0, ICMF_CHOOSE_DATARATE |ICMF_CHOOSE_KEYFRAME | ICMF_CHOOSE_ALLCOMPRESSORS,
 205                              2, streams, poptions);
 206         trace("got %u with 0x%x/%u\n", res, GetLastError(), GetLastError());
 207     }
 208
 209     SetLastError(0xdeadbeef);
 210     lres = AVISaveOptionsFree(2, poptions);
 211     ok(lres == AVIERR_OK, "got 0x%x with 0x%x/%u\n", lres, GetLastError(), GetLastError());
 212
 213     SetLastError(0xdeadbeef);
 214     res = AVIStreamRelease(streams[0]);
 215     ok(res == 0, "0: got refcount %u (expected 0)\n", res);
 216
 217     SetLastError(0xdeadbeef);
 218     res = AVIStreamRelease(streams[1]);
 219     ok(res == 0, "1: got refcount %u (expected 0)\n", res);
 220
 221 }
 222
 223 /* ########################### */
 224
 225 static void test_EditStreamSetInfo(void)
 226 {
 227     PAVISTREAM stream = NULL;
 228     HRESULT hres;
 229     AVISTREAMINFO info, info2;
 230
 231     hres = CreateEditableStream(&stream, NULL);
 232     ok(hres == AVIERR_OK, "got 0x%08X, expected AVIERR_OK\n", hres);
 233
 234     /* Size parameter is somehow checked (notice the crash with size=-1 below) */
 235     hres = EditStreamSetInfo(stream, NULL, 0);
 236     ok( hres == AVIERR_BADSIZE, "got 0x%08X, expected AVIERR_BADSIZE\n", hres);
 237
 238     hres = EditStreamSetInfo(stream, NULL, sizeof(AVISTREAMINFO)-1 );
 239     ok( hres == AVIERR_BADSIZE, "got 0x%08X, expected AVIERR_BADSIZE\n", hres);
 240
 241     if(0)
 242     {
 243         /* Crashing - first parameter not checked */
 244         EditStreamSetInfo(NULL, &info, sizeof(AVISTREAMINFO) );
 245
 246         /* Crashing - second parameter not checked */
 247         EditStreamSetInfo(stream, NULL, sizeof(AVISTREAMINFO) );
 248
 249         EditStreamSetInfo(stream, NULL, -1);
 250     }
 251
 252     hres = AVIStreamInfo(stream, &info, sizeof(AVISTREAMINFO) );
 253     ok( hres == 0, "got 0x%08X, expected 0\n", hres);
 254
 255              /* Does the function check what's it's updating ? */
 256
 257 #define IS_INFO_UPDATED(m) do { \
 258     hres = EditStreamSetInfo(stream, &info, sizeof(AVISTREAMINFO) ); \
 259     ok( hres == 0, "got 0x%08X, expected 0\n", hres); \
 260     hres = AVIStreamInfo(stream, &info2, sizeof(AVISTREAMINFO) ); \
 261     ok( hres == 0, "got 0x%08X, expected 0\n", hres); \
 262     ok( info2.m == info.m, "EditStreamSetInfo did not update "#m" parameter\n" ); \
 263     } while(0)
 264
 265     info.dwStart++;
 266     IS_INFO_UPDATED(dwStart);
 267     info.dwStart = 0;
 268     IS_INFO_UPDATED(dwStart);
 269
 270     info.wPriority++;
 271     IS_INFO_UPDATED(wPriority);
 272     info.wPriority = 0;
 273     IS_INFO_UPDATED(wPriority);
 274
 275     info.wLanguage++;
 276     IS_INFO_UPDATED(wLanguage);
 277     info.wLanguage = 0;
 278     IS_INFO_UPDATED(wLanguage);
 279
 280     info.dwScale++;
 281     IS_INFO_UPDATED(dwScale);
 282     info.dwScale = 0;
 283     IS_INFO_UPDATED(dwScale);
 284
 285     info.dwRate++;
 286     IS_INFO_UPDATED(dwRate);
 287     info.dwRate = 0;
 288     IS_INFO_UPDATED(dwRate);
 289
 290     info.dwQuality++;
 291     IS_INFO_UPDATED(dwQuality);
 292     info.dwQuality = 0;
 293     IS_INFO_UPDATED(dwQuality);
 294     info.dwQuality = -2;
 295     IS_INFO_UPDATED(dwQuality);
 296     info.dwQuality = ICQUALITY_HIGH+1;
 297     IS_INFO_UPDATED(dwQuality);
 298
 299     info.rcFrame.left = 0;
 300     IS_INFO_UPDATED(rcFrame.left);
 301     info.rcFrame.top = 0;
 302     IS_INFO_UPDATED(rcFrame.top);
 303     info.rcFrame.right = 0;
 304     IS_INFO_UPDATED(rcFrame.right);
 305     info.rcFrame.bottom = 0;
 306     IS_INFO_UPDATED(rcFrame.bottom);
 307
 308     info.rcFrame.left = -1;
 309     IS_INFO_UPDATED(rcFrame.left);
 310     info.rcFrame.top = -1;
 311     IS_INFO_UPDATED(rcFrame.top);
 312     info.rcFrame.right = -1;
 313     IS_INFO_UPDATED(rcFrame.right);
 314     info.rcFrame.bottom = -1;
 315     IS_INFO_UPDATED(rcFrame.bottom);
 316     AVIStreamRelease(stream);
 317 #undef IS_INFO_UPDATED
 318 }
 319
 320
 321 static void init_test_struct(COMMON_AVI_HEADERS *cah)
 322 {
 323     memcpy(cah->fh, deffh, sizeof(deffh));
 324     cah->mah = defmah;
 325     cah->ash0 = defash0;
 326     cah->ash1 = defash1;
 327     cah->pcmwf = defpcmwf;
 328 }
 329
 330 static void create_avi_file(const COMMON_AVI_HEADERS *cah, char *filename)
 331 {
 332     HANDLE hFile;
 333     DWORD written;
 334
 335     hFile = CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 336
 337     ok(hFile != INVALID_HANDLE_VALUE, "Couldn't create file\n");
 338
 339     WriteFile(hFile, &cah->fh, sizeof(deffh), &written, NULL);
 340     WriteFile(hFile, &cah->mah, sizeof(MainAVIHeader), &written, NULL);
 341     WriteFile(hFile, streamlist, sizeof(streamlist), &written, NULL);
 342     WriteFile(hFile, &cah->ash0, 0x38, &written, NULL);
 343     WriteFile(hFile, videostreamformat, sizeof(videostreamformat), &written, NULL);
 344     WriteFile(hFile, padding1, sizeof(padding1), &written, NULL);
 345     WriteFile(hFile, videopropheader, sizeof(videopropheader), &written, NULL);
 346     WriteFile(hFile, &cah->ash1, 0x38, &written, NULL);
 347     WriteFile(hFile, audiostreamformat_pre, sizeof(audiostreamformat_pre), &written, NULL);
 348     WriteFile(hFile, &cah->pcmwf, sizeof(PCMWAVEFORMAT), &written, NULL);
 349     WriteFile(hFile, data, sizeof(data), &written, NULL);
 350
 351     CloseHandle(hFile);
 352 }
 353
 354 static void test_default_data(void)
 355 {
 356     COMMON_AVI_HEADERS cah;
 357     char filename[MAX_PATH];
 358     PAVIFILE pFile;
 359     int res;
 360     LONG lSize;
 361     PAVISTREAM pStream0;
 362     PAVISTREAM pStream1;
 363     AVISTREAMINFO asi0;
 364     AVISTREAMINFO asi1;
 365     WAVEFORMATEX wfx;
 366
 367     GetTempPath(MAX_PATH, filename);
 368     strcpy(filename+strlen(filename), testfilename);
 369
 370     init_test_struct(&cah);
 371     create_avi_file(&cah, filename);
 372
 373     res = AVIFileOpen(&pFile, filename, OF_SHARE_DENY_WRITE, 0L);
 374     ok(res != AVIERR_BADFORMAT, "Unable to open file: error1=%u\n", AVIERR_BADFORMAT);
 375     ok(res != AVIERR_MEMORY, "Unable to open file: error2=%u\n", AVIERR_MEMORY);
 376     ok(res != AVIERR_FILEREAD, "Unable to open file: error3=%u\n", AVIERR_FILEREAD);
 377     ok(res != AVIERR_FILEOPEN, "Unable to open file: error4=%u\n", AVIERR_FILEOPEN);
 378     ok(res != REGDB_E_CLASSNOTREG, "Unable to open file: error5=%u\n", REGDB_E_CLASSNOTREG);
 379     ok(res == 0, "Unable to open file: error=%u\n", res);
 380
 381     res = AVIFileGetStream(pFile, &pStream0, 0, 0);
 382     ok(res == 0, "Unable to open video stream: error=%u\n", res);
 383
 384     res = AVIFileGetStream(pFile, &pStream1, 0, 1);
 385     ok(res == 0, "Unable to open audio stream: error=%u\n", res);
 386
 387     res = AVIStreamInfo(pStream0, &asi0, sizeof(AVISTREAMINFO));
 388     ok(res == 0, "Unable to read stream info: error=%u\n", res);
 389
 390     res = AVIStreamInfo(pStream1, &asi1, sizeof(AVISTREAMINFO));
 391     ok(res == 0, "Unable to read stream info: error=%u\n", res);
 392
 393     res = AVIStreamReadFormat(pStream0, AVIStreamStart(pStream1), NULL, &lSize);
 394     ok(res == 0, "Unable to read format size: error=%u\n", res);
 395
 396     res = AVIStreamReadFormat(pStream1, AVIStreamStart(pStream1), &wfx, &lSize);
 397     ok(res == 0, "Unable to read format: error=%u\n", res);
 398
 399     ok(asi0.fccType == streamtypeVIDEO, "got 0x%x (expected streamtypeVIDEO)\n", asi0.fccType);
 400     ok(asi0.fccHandler == 0x30323449, "got 0x%x (expected 0x30323449)\n", asi0.fccHandler);
 401     ok(asi0.dwFlags == 0, "got %u (expected 0)\n", asi0.dwFlags);
 402     ok(asi0.wPriority == 0, "got %u (expected 0)\n", asi0.wPriority);
 403     ok(asi0.wLanguage == 0, "got %u (expected 0)\n", asi0.wLanguage);
 404     ok(asi0.dwScale == 1001, "got %u (expected 1001)\n", asi0.dwScale);
 405     ok(asi0.dwRate == 30000, "got %u (expected 30000)\n", asi0.dwRate);
 406     ok(asi0.dwStart == 0, "got %u (expected 0)\n", asi0.dwStart);
 407     ok(asi0.dwLength == 1, "got %u (expected 1)\n", asi0.dwLength);
 408     ok(asi0.dwInitialFrames == 0, "got %u (expected 0)\n", asi0.dwInitialFrames);
 409     ok(asi0.dwSuggestedBufferSize == 0, "got %u (expected 0)\n", asi0.dwSuggestedBufferSize);
 410     ok(asi0.dwQuality == 0xffffffff, "got 0x%x (expected 0xffffffff)\n", asi0.dwQuality);
 411     ok(asi0.dwSampleSize == 0, "got %u (expected 0)\n", asi0.dwSampleSize);
 412     ok(asi0.rcFrame.left == 0, "got %u (expected 0)\n", asi0.rcFrame.left);
 413     ok(asi0.rcFrame.top == 0, "got %u (expected 0)\n", asi0.rcFrame.top);
 414     ok(asi0.rcFrame.right == 8, "got %u (expected 8)\n", asi0.rcFrame.right);  /* these are based on the values in the mah and not */
 415     ok(asi0.rcFrame.bottom == 6, "got %u (expected 6)\n", asi0.rcFrame.bottom);/* on the ones in the ash which are 0 here */
 416     ok(asi0.dwEditCount == 0, "got %u (expected 0)\n", asi0.dwEditCount);
 417     ok(asi0.dwFormatChangeCount == 0, "got %u (expected 0)\n", asi0.dwFormatChangeCount);
 418
 419     ok(asi1.fccType == streamtypeAUDIO, "got 0x%x (expected streamtypeVIDEO)\n", asi1.fccType);
 420     ok(asi1.fccHandler == 0x1, "got 0x%x (expected 0x1)\n", asi1.fccHandler);
 421     ok(asi1.dwFlags == 0, "got %u (expected 0)\n", asi1.dwFlags);
 422     ok(asi1.wPriority == 0, "got %u (expected 0)\n", asi1.wPriority);
 423     ok(asi1.wLanguage == 0, "got %u (expected 0)\n", asi1.wLanguage);
 424     ok(asi1.dwScale == 1, "got %u (expected 1)\n", asi1.dwScale);
 425     ok(asi1.dwRate == 11025, "got %u (expected 11025)\n", asi1.dwRate);
 426     ok(asi1.dwStart == 0, "got %u (expected 0)\n", asi1.dwStart);
 427     ok(asi1.dwLength == 1637, "got %u (expected 1637)\n", asi1.dwLength);
 428     ok(asi1.dwInitialFrames == 0, "got %u (expected 0)\n", asi1.dwInitialFrames);
 429     ok(asi1.dwSuggestedBufferSize == 0, "got %u (expected 0)\n", asi1.dwSuggestedBufferSize);
 430     ok(asi1.dwQuality == 0xffffffff, "got 0x%x (expected 0xffffffff)\n", asi1.dwQuality);
 431     ok(asi1.dwSampleSize == 2, "got %u (expected 2)\n", asi1.dwSampleSize);
 432     ok(asi1.rcFrame.left == 0, "got %u (expected 0)\n", asi1.rcFrame.left);
 433     ok(asi1.rcFrame.top == 0, "got %u (expected 0)\n", asi1.rcFrame.top);
 434     ok(asi1.rcFrame.right == 0, "got %u (expected 0)\n", asi1.rcFrame.right);
 435     ok(asi1.rcFrame.bottom == 0, "got %u (expected 0)\n", asi1.rcFrame.bottom);
 436     ok(asi1.dwEditCount == 0, "got %u (expected 0)\n", asi1.dwEditCount);
 437     ok(asi1.dwFormatChangeCount == 0, "got %u (expected 0)\n", asi1.dwFormatChangeCount);
 438
 439     ok(wfx.wFormatTag == 1, "got %u (expected 1)\n",wfx.wFormatTag);
 440     ok(wfx.nChannels == 2, "got %u (expected 2)\n",wfx.nChannels);
 441     ok(wfx.wFormatTag == 1, "got %u (expected 1)\n",wfx.wFormatTag);
 442     ok(wfx.nSamplesPerSec == 11025, "got %u (expected 11025)\n",wfx.nSamplesPerSec);
 443     ok(wfx.nAvgBytesPerSec == 22050, "got %u (expected 22050)\n",wfx.nAvgBytesPerSec);
 444     ok(wfx.nBlockAlign == 2, "got %u (expected 2)\n",wfx.nBlockAlign);
 445
 446     AVIStreamRelease(pStream0);
 447     AVIStreamRelease(pStream1);
 448     AVIFileRelease(pFile);
 449     ok(DeleteFile(filename) !=0, "Deleting file %s failed\n", filename);
 450 }
 451
 452 static void test_amh_corruption(void)
 453 {
 454     COMMON_AVI_HEADERS cah;
 455     char filename[MAX_PATH];
 456     PAVIFILE pFile;
 457     int res;
 458
 459     GetTempPath(MAX_PATH, filename);
 460     strcpy(filename+strlen(filename), testfilename);
 461
 462     /* Make sure only AVI files with the proper headers will be loaded */
 463     init_test_struct(&cah);
 464     cah.fh[3] = mmioFOURCC('A', 'V', 'i', ' ');
 465
 466     create_avi_file(&cah, filename);
 467     res = AVIFileOpen(&pFile, filename, OF_SHARE_DENY_WRITE, 0L);
 468     ok(res != 0, "Able to open file: error=%u\n", res);
 469
 470     ok(DeleteFile(filename) !=0, "Deleting file %s failed\n", filename);
 471 }
 472
 473 static void test_ash1_corruption(void)
 474 {
 475     COMMON_AVI_HEADERS cah;
 476     char filename[MAX_PATH];
 477     PAVIFILE pFile;
 478     int res;
 479     PAVISTREAM pStream1;
 480     AVISTREAMINFO asi1;
 481
 482     GetTempPath(MAX_PATH, filename);
 483     strcpy(filename+strlen(filename), testfilename);
 484
 485     /* Corrupt the sample size in the audio stream header */
 486     init_test_struct(&cah);
 487     cah.ash1.dwSampleSize = 0xdeadbeef;
 488
 489     create_avi_file(&cah, filename);
 490
 491     res = AVIFileOpen(&pFile, filename, OF_SHARE_DENY_WRITE, 0L);
 492     ok(res == 0, "Unable to open file: error=%u\n", res);
 493
 494     res = AVIFileGetStream(pFile, &pStream1, 0, 1);
 495     ok(res == 0, "Unable to open audio stream: error=%u\n", res);
 496
 497     res = AVIStreamInfo(pStream1, &asi1, sizeof(AVISTREAMINFO));
 498     ok(res == 0, "Unable to read stream info: error=%u\n", res);
 499
 500     /* The result will still be 2, because the value is dynamically replaced with the nBlockAlign
 501        value from the stream format header. The next test will prove this */
 502     ok(asi1.dwSampleSize == 2, "got %u (expected 2)\n", asi1.dwSampleSize);
 503
 504     AVIStreamRelease(pStream1);
 505     AVIFileRelease(pFile);
 506     ok(DeleteFile(filename) !=0, "Deleting file %s failed\n", filename);
 507 }
 508
 509 static void test_ash1_corruption2(void)
 510 {
 511     COMMON_AVI_HEADERS cah;
 512     char filename[MAX_PATH];
 513     PAVIFILE pFile;
 514     int res;
 515     PAVISTREAM pStream1;
 516     AVISTREAMINFO asi1;
 517
 518     GetTempPath(MAX_PATH, filename);
 519     strcpy(filename+strlen(filename), testfilename);
 520
 521     /* Corrupt the block alignment in the audio format header */
 522     init_test_struct(&cah);
 523     cah.pcmwf.wf.nBlockAlign = 0xdead;
 524
 525     create_avi_file(&cah, filename);
 526
 527     res = AVIFileOpen(&pFile, filename, OF_SHARE_DENY_WRITE, 0L);
 528     ok(res == 0, "Unable to open file: error=%u\n", res);
 529
 530     res = AVIFileGetStream(pFile, &pStream1, 0, 1);
 531     ok(res == 0, "Unable to open audio stream: error=%u\n", res);
 532
 533     ok(AVIStreamInfo(pStream1, &asi1, sizeof(AVISTREAMINFO)) == 0, "Unable to read stream info\n");
 534
 535     /* The result will also be the corrupt value, as explained above. */
 536     ok(asi1.dwSampleSize == 0xdead, "got 0x%x (expected 0xdead)\n", asi1.dwSampleSize);
 537
 538     AVIStreamRelease(pStream1);
 539     AVIFileRelease(pFile);
 540     ok(DeleteFile(filename) !=0, "Deleting file %s failed\n", filename);
 541 }
 542
 543 /* Outer IUnknown for COM aggregation tests */
 544 struct unk_impl {
 545     IUnknown IUnknown_iface;
 546     LONG ref;
 547     IUnknown *inner_unk;
 548 };
 549
 550 static inline struct unk_impl *impl_from_IUnknown(IUnknown *iface)
 551 {
 552     return CONTAINING_RECORD(iface, struct unk_impl, IUnknown_iface);
 553 }
 554
 555 static HRESULT WINAPI unk_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 556 {
 557     struct unk_impl *This = impl_from_IUnknown(iface);
 558     LONG ref = This->ref;
 559     HRESULT hr;
 560
 561     if (IsEqualGUID(riid, &IID_IUnknown))
 562     {
 563         *ppv = iface;
 564         IUnknown_AddRef(iface);
 565         return S_OK;
 566     }
 567
 568     hr = IUnknown_QueryInterface(This->inner_unk, riid, ppv);
 569     if (hr == S_OK)
 570     {
 571         trace("Working around COM aggregation ref counting bug\n");
 572         ok(ref == This->ref, "Outer ref count expected %d got %d\n", ref, This->ref);
 573         IUnknown_AddRef((IUnknown*)*ppv);
 574         ref = IUnknown_Release(This->inner_unk);
 575         ok(ref == 1, "Inner ref count expected 1 got %d\n", ref);
 576     }
 577
 578     return hr;
 579 }
 580
 581 static ULONG WINAPI unk_AddRef(IUnknown *iface)
 582 {
 583     struct unk_impl *This = impl_from_IUnknown(iface);
 584
 585     return InterlockedIncrement(&This->ref);
 586 }
 587
 588 static ULONG WINAPI unk_Release(IUnknown *iface)
 589 {
 590     struct unk_impl *This = impl_from_IUnknown(iface);
 591
 592     return InterlockedDecrement(&This->ref);
 593 }
 594
 595 static const IUnknownVtbl unk_vtbl =
 596 {
 597     unk_QueryInterface,
 598     unk_AddRef,
 599     unk_Release
 600 };
 601
 602 static void test_COM(void)
 603 {
 604     struct unk_impl unk_obj = {{&unk_vtbl}, 19, NULL};
 605     IAVIFile *avif = NULL;
 606     IPersistFile *pf;
 607     IUnknown *unk;
 608     LONG refcount;
 609     HRESULT hr;
 610
 611     /* COM aggregation */
 612     hr = CoCreateInstance(&CLSID_AVIFile, &unk_obj.IUnknown_iface, CLSCTX_INPROC_SERVER,
 613             &IID_IUnknown, (void**)&unk_obj.inner_unk);
 614     ok(hr == S_OK, "COM aggregation failed: %08x, expected S_OK\n", hr);
 615     hr = IUnknown_QueryInterface(&unk_obj.IUnknown_iface, &IID_IAVIFile, (void**)&avif);
 616     ok(hr == S_OK, "QueryInterface for IID_IAVIFile failed: %08x\n", hr);
 617     refcount = IAVIFile_AddRef(avif);
 618     ok(refcount == unk_obj.ref, "AVIFile just pretends to support COM aggregation\n");
 619     refcount = IAVIFile_Release(avif);
 620     ok(refcount == unk_obj.ref, "AVIFile just pretends to support COM aggregation\n");
 621     hr = IAVIFile_QueryInterface(avif, &IID_IPersistFile, (void**)&pf);
 622     ok(hr == S_OK, "QueryInterface for IID_IPersistFile failed: %08x\n", hr);
 623     refcount = IPersistFile_Release(pf);
 624     ok(refcount == unk_obj.ref, "AVIFile just pretends to support COM aggregation\n");
 625     refcount = IAVIFile_Release(avif);
 626     ok(refcount == 19, "Outer ref count should be back at 19 but is %d\n", refcount);
 627     refcount = IUnknown_Release(unk_obj.inner_unk);
 628     ok(refcount == 0, "Inner ref count should be 0 but is %u\n", refcount);
 629
 630     /* Invalid RIID */
 631     hr = CoCreateInstance(&CLSID_AVIFile, NULL, CLSCTX_INPROC_SERVER, &IID_IAVIStream,
 632             (void**)&avif);
 633     ok(hr == E_NOINTERFACE, "AVIFile create failed: %08x, expected E_NOINTERFACE\n", hr);
 634
 635     /* Same refcount */
 636     hr = CoCreateInstance(&CLSID_AVIFile, NULL, CLSCTX_INPROC_SERVER, &IID_IAVIFile, (void**)&avif);
 637     ok(hr == S_OK, "AVIFile create failed: %08x, expected S_OK\n", hr);
 638     refcount = IAVIFile_AddRef(avif);
 639     ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
 640     hr = IAVIFile_QueryInterface(avif, &IID_IUnknown, (void**)&unk);
 641     ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr);
 642     refcount = IUnknown_AddRef(unk);
 643     ok(refcount == 4, "refcount == %u, expected 4\n", refcount);
 644     hr = IAVIFile_QueryInterface(avif, &IID_IPersistFile, (void**)&pf);
 645     ok(hr == S_OK, "QueryInterface for IID_IPersistFile failed: %08x\n", hr);
 646     refcount = IPersistFile_AddRef(pf);
 647     ok(refcount == 6, "refcount == %u, expected 6\n", refcount);
 648
 649     while (IAVIFile_Release(avif));
 650 }
 651
 652 START_TEST(api)
 653 {
 654
 655     AVIFileInit();
 656     test_EditStreamSetInfo();
 657     test_AVISaveOptions();
 658     test_default_data();
 659     test_amh_corruption();
 660     test_ash1_corruption();
 661     test_ash1_corruption2();
 662     test_COM();
 663     AVIFileExit();
 664
 665 }