dlls/quartz/memallocator.c

   1 /*
   2  * Memory Allocator and Media Sample Implementation
   3  *
   4  * Copyright 2003 Robert Shearman
   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 #include <assert.h>
  22 #include <limits.h>
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "vfwmsgs.h"
  28
  29 #include "quartz_private.h"
  30 #include "wine/list.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  34
  35 void dump_AM_SAMPLE2_PROPERTIES(const AM_SAMPLE2_PROPERTIES * pProps)
  36 {
  37     if (!pProps)
  38     {
  39         TRACE("AM_SAMPLE2_PROPERTIES: (null)\n");
  40         return;
  41     }
  42     TRACE("\tcbData: %d\n", pProps->cbData);
  43     TRACE("\tdwTypeSpecificFlags: 0x%8x\n", pProps->dwTypeSpecificFlags);
  44     TRACE("\tdwSampleFlags: 0x%8x\n", pProps->dwSampleFlags);
  45     TRACE("\tlActual: %d\n", pProps->lActual);
  46     TRACE("\ttStart: %x%08x%s\n", (LONG)(pProps->tStart >> 32), (LONG)pProps->tStart, pProps->dwSampleFlags & AM_SAMPLE_TIMEVALID ? "" : " (not valid)");
  47     TRACE("\ttStop: %x%08x%s\n", (LONG)(pProps->tStop >> 32), (LONG)pProps->tStop, pProps->dwSampleFlags & AM_SAMPLE_STOPVALID ? "" : " (not valid)");
  48     TRACE("\tdwStreamId: 0x%x\n", pProps->dwStreamId);
  49     TRACE("\tpMediaType: %p\n", pProps->pMediaType);
  50     TRACE("\tpbBuffer: %p\n", pProps->pbBuffer);
  51     TRACE("\tcbBuffer: %d\n", pProps->cbBuffer);
  52 }
  53
  54 typedef struct BaseMemAllocator
  55 {
  56     const IMemAllocatorVtbl * lpVtbl;
  57
  58     LONG ref;
  59     ALLOCATOR_PROPERTIES * pProps;
  60     CRITICAL_SECTION csState;
  61     HRESULT (* fnAlloc) (IMemAllocator *);
  62     HRESULT (* fnFree)(IMemAllocator *);
  63     HANDLE hSemWaiting;
  64     BOOL bDecommitQueued;
  65     BOOL bCommitted;
  66     LONG lWaiting;
  67     struct list free_list;
  68     struct list used_list;
  69 } BaseMemAllocator;
  70
  71 typedef struct StdMediaSample2
  72 {
  73     const IMediaSample2Vtbl * lpvtbl;
  74
  75     LONG ref;
  76     AM_SAMPLE2_PROPERTIES props;
  77     IMemAllocator * pParent;
  78     struct list listentry;
  79     LONGLONG tMediaStart;
  80     LONGLONG tMediaEnd;
  81 } StdMediaSample2;
  82
  83 static const IMemAllocatorVtbl BaseMemAllocator_VTable;
  84 static const IMediaSample2Vtbl StdMediaSample2_VTable;
  85
  86 #define AM_SAMPLE2_PROP_SIZE_WRITABLE (unsigned int)(&((AM_SAMPLE2_PROPERTIES *)0)->pbBuffer)
  87
  88 #define INVALID_MEDIA_TIME (((ULONGLONG)0x7fffffff << 32) | 0xffffffff)
  89
  90 static HRESULT BaseMemAllocator_Init(HRESULT (* fnAlloc)(IMemAllocator *), HRESULT (* fnFree)(IMemAllocator *), BaseMemAllocator * pMemAlloc)
  91 {
  92     assert(fnAlloc && fnFree);
  93
  94     pMemAlloc->lpVtbl = &BaseMemAllocator_VTable;
  95
  96     pMemAlloc->ref = 1;
  97     pMemAlloc->pProps = NULL;
  98     list_init(&pMemAlloc->free_list);
  99     list_init(&pMemAlloc->used_list);
 100     pMemAlloc->fnAlloc = fnAlloc;
 101     pMemAlloc->fnFree = fnFree;
 102     pMemAlloc->bDecommitQueued = FALSE;
 103     pMemAlloc->bCommitted = FALSE;
 104     pMemAlloc->hSemWaiting = NULL;
 105     pMemAlloc->lWaiting = 0;
 106
 107     InitializeCriticalSection(&pMemAlloc->csState);
 108     pMemAlloc->csState.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BaseMemAllocator.csState");
 109
 110     return S_OK;
 111 }
 112
 113 static HRESULT WINAPI BaseMemAllocator_QueryInterface(IMemAllocator * iface, REFIID riid, LPVOID * ppv)
 114 {
 115     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 116     TRACE("(%p)->(%s, %p)\n", This, qzdebugstr_guid(riid), ppv);
 117
 118     *ppv = NULL;
 119
 120     if (IsEqualIID(riid, &IID_IUnknown))
 121         *ppv = (LPVOID)This;
 122     else if (IsEqualIID(riid, &IID_IMemAllocator))
 123         *ppv = (LPVOID)This;
 124
 125     if (*ppv)
 126     {
 127         IUnknown_AddRef((IUnknown *)(*ppv));
 128         return S_OK;
 129     }
 130
 131     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 132
 133     return E_NOINTERFACE;
 134 }
 135
 136 static ULONG WINAPI BaseMemAllocator_AddRef(IMemAllocator * iface)
 137 {
 138     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 139     ULONG ref = InterlockedIncrement(&This->ref);
 140
 141     TRACE("(%p)->() AddRef from %d\n", iface, ref - 1);
 142
 143     return ref;
 144 }
 145
 146 static ULONG WINAPI BaseMemAllocator_Release(IMemAllocator * iface)
 147 {
 148     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 149     ULONG ref = InterlockedDecrement(&This->ref);
 150
 151     TRACE("(%p)->() Release from %d\n", iface, ref + 1);
 152
 153     if (!ref)
 154     {
 155         CloseHandle(This->hSemWaiting);
 156         if (This->bCommitted)
 157             This->fnFree(iface);
 158         CoTaskMemFree(This->pProps);
 159         This->csState.DebugInfo->Spare[0] = 0;
 160         DeleteCriticalSection(&This->csState);
 161         CoTaskMemFree(This);
 162         return 0;
 163     }
 164     return ref;
 165 }
 166
 167 static HRESULT WINAPI BaseMemAllocator_SetProperties(IMemAllocator * iface, ALLOCATOR_PROPERTIES *pRequest, ALLOCATOR_PROPERTIES *pActual)
 168 {
 169     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 170     HRESULT hr;
 171
 172     TRACE("(%p)->(%p, %p)\n", This, pRequest, pActual);
 173
 174     EnterCriticalSection(&This->csState);
 175     {
 176         if (!list_empty(&This->used_list))
 177             hr = VFW_E_BUFFERS_OUTSTANDING;
 178         else if (This->bCommitted)
 179             hr = VFW_E_ALREADY_COMMITTED;
 180         else if (pRequest->cbAlign == 0)
 181             hr = VFW_E_BADALIGN;
 182         else
 183         {
 184             if (!This->pProps)
 185                 This->pProps = CoTaskMemAlloc(sizeof(*This->pProps));
 186
 187             if (!This->pProps)
 188                 hr = E_OUTOFMEMORY;
 189             else
 190             {
 191                 *This->pProps = *pRequest;
 192
 193                 *pActual = *pRequest;
 194
 195                 hr = S_OK;
 196             }
 197         }
 198     }
 199     LeaveCriticalSection(&This->csState);
 200
 201     return hr;
 202 }
 203
 204 static HRESULT WINAPI BaseMemAllocator_GetProperties(IMemAllocator * iface, ALLOCATOR_PROPERTIES *pProps)
 205 {
 206     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 207     HRESULT hr = S_OK;
 208
 209     TRACE("(%p)->(%p)\n", This, pProps);
 210
 211     EnterCriticalSection(&This->csState);
 212     {
 213         /* NOTE: this is different from the native version.
 214          * It would silently succeed if the properties had
 215          * not been set, but would fail further on down the
 216          * line with some obscure error like having an
 217          * invalid alignment. Whether or not our version
 218          * will cause any problems remains to be seen */
 219         if (!This->pProps)
 220             hr = VFW_E_SIZENOTSET;
 221         else
 222             memcpy(pProps, This->pProps, sizeof(*pProps));
 223     }
 224     LeaveCriticalSection(&This->csState);
 225
 226     return hr;
 227 }
 228
 229 static HRESULT WINAPI BaseMemAllocator_Commit(IMemAllocator * iface)
 230 {
 231     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 232     HRESULT hr;
 233
 234     TRACE("(%p)->()\n", This);
 235
 236     EnterCriticalSection(&This->csState);
 237     {
 238         if (!This->pProps)
 239             hr = VFW_E_SIZENOTSET;
 240         else if (This->bDecommitQueued && This->bCommitted)
 241         {
 242             This->bDecommitQueued = FALSE;
 243             hr = S_OK;
 244         }
 245         else if (This->bCommitted)
 246             hr = S_OK;
 247         else
 248         {
 249             if (!(This->hSemWaiting = CreateSemaphoreW(NULL, This->pProps->cBuffers, This->pProps->cBuffers, NULL)))
 250             {
 251                 ERR("Couldn't create semaphore (error was %u)\n", GetLastError());
 252                 hr = HRESULT_FROM_WIN32(GetLastError());
 253             }
 254             else
 255             {
 256                 hr = This->fnAlloc(iface);
 257                 if (SUCCEEDED(hr))
 258                     This->bCommitted = TRUE;
 259                 else
 260                     ERR("fnAlloc failed with error 0x%x\n", hr);
 261             }
 262         }
 263     }
 264     LeaveCriticalSection(&This->csState);
 265
 266     return hr;
 267 }
 268
 269 static HRESULT WINAPI BaseMemAllocator_Decommit(IMemAllocator * iface)
 270 {
 271     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 272     HRESULT hr;
 273
 274     TRACE("(%p)->()\n", This);
 275
 276     EnterCriticalSection(&This->csState);
 277     {
 278         if (!This->bCommitted)
 279             hr = S_OK;
 280         else
 281         {
 282             if (!list_empty(&This->used_list))
 283             {
 284                 This->bDecommitQueued = TRUE;
 285                 /* notify ALL waiting threads that they cannot be allocated a buffer any more */
 286                 ReleaseSemaphore(This->hSemWaiting, This->lWaiting, NULL);
 287
 288                 hr = S_OK;
 289             }
 290             else
 291             {
 292                 assert(This->lWaiting == 0);
 293
 294                 This->bCommitted = FALSE;
 295                 CloseHandle(This->hSemWaiting);
 296                 This->hSemWaiting = NULL;
 297
 298                 hr = This->fnFree(iface);
 299                 if (FAILED(hr))
 300                     ERR("fnFree failed with error 0x%x\n", hr);
 301             }
 302         }
 303     }
 304     LeaveCriticalSection(&This->csState);
 305
 306     return hr;
 307 }
 308
 309 static HRESULT WINAPI BaseMemAllocator_GetBuffer(IMemAllocator * iface, IMediaSample ** pSample, REFERENCE_TIME *pStartTime, REFERENCE_TIME *pEndTime, DWORD dwFlags)
 310 {
 311     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 312     HRESULT hr = S_OK;
 313
 314     /* NOTE: The pStartTime and pEndTime parameters are not applied to the sample.
 315      * The allocator might use these values to determine which buffer it retrieves */
 316
 317     TRACE("(%p)->(%p, %p, %p, %x)\n", This, pSample, pStartTime, pEndTime, dwFlags);
 318
 319     *pSample = NULL;
 320
 321     if (!This->bCommitted)
 322         return VFW_E_NOT_COMMITTED;
 323
 324     This->lWaiting++;
 325     if (WaitForSingleObject(This->hSemWaiting, (dwFlags & AM_GBF_NOWAIT) ? 0 : INFINITE) != WAIT_OBJECT_0)
 326     {
 327         This->lWaiting--;
 328         return VFW_E_TIMEOUT;
 329     }
 330     This->lWaiting--;
 331
 332     EnterCriticalSection(&This->csState);
 333     {
 334         if (!This->bCommitted)
 335             hr = VFW_E_NOT_COMMITTED;
 336         else if (This->bDecommitQueued)
 337             hr = VFW_E_TIMEOUT;
 338         else
 339         {
 340             struct list * free = list_head(&This->free_list);
 341             list_remove(free);
 342             list_add_head(&This->used_list, free);
 343
 344             *pSample = (IMediaSample *)LIST_ENTRY(free, StdMediaSample2, listentry);
 345
 346             assert(((StdMediaSample2 *)*pSample)->ref == 0);
 347
 348             IMediaSample_AddRef(*pSample);
 349         }
 350     }
 351     LeaveCriticalSection(&This->csState);
 352
 353     return hr;
 354 }
 355
 356 static HRESULT WINAPI BaseMemAllocator_ReleaseBuffer(IMemAllocator * iface, IMediaSample * pSample)
 357 {
 358     BaseMemAllocator *This = (BaseMemAllocator *)iface;
 359     StdMediaSample2 * pStdSample = (StdMediaSample2 *)pSample;
 360     HRESULT hr = S_OK;
 361
 362     TRACE("(%p)->(%p)\n", This, pSample);
 363
 364     /* FIXME: make sure that sample is currently on the used list */
 365
 366     /* FIXME: we should probably check the ref count on the sample before freeing
 367      * it to make sure that it is not still in use */
 368     EnterCriticalSection(&This->csState);
 369     {
 370         if (!This->bCommitted)
 371             ERR("Releasing a buffer when the allocator is not committed?!?\n");
 372
 373                 /* remove from used_list */
 374         list_remove(&pStdSample->listentry);
 375
 376         list_add_head(&This->free_list, &pStdSample->listentry);
 377
 378         if (list_empty(&This->used_list) && This->bDecommitQueued && This->bCommitted)
 379         {
 380             HRESULT hrfree;
 381
 382             assert(This->lWaiting == 0);
 383
 384             This->bCommitted = FALSE;
 385             This->bDecommitQueued = FALSE;
 386
 387             CloseHandle(This->hSemWaiting);
 388             This->hSemWaiting = NULL;
 389
 390             if (FAILED(hrfree = This->fnFree(iface)))
 391                 ERR("fnFree failed with error 0x%x\n", hrfree);
 392         }
 393     }
 394     LeaveCriticalSection(&This->csState);
 395
 396     /* notify a waiting thread that there is now a free buffer */
 397     if (This->hSemWaiting && !ReleaseSemaphore(This->hSemWaiting, 1, NULL))
 398     {
 399         ERR("ReleaseSemaphore failed with error %u\n", GetLastError());
 400         hr = HRESULT_FROM_WIN32(GetLastError());
 401     }
 402
 403     return hr;
 404 }
 405
 406 static const IMemAllocatorVtbl BaseMemAllocator_VTable =
 407 {
 408     BaseMemAllocator_QueryInterface,
 409     BaseMemAllocator_AddRef,
 410     BaseMemAllocator_Release,
 411     BaseMemAllocator_SetProperties,
 412     BaseMemAllocator_GetProperties,
 413     BaseMemAllocator_Commit,
 414     BaseMemAllocator_Decommit,
 415     BaseMemAllocator_GetBuffer,
 416     BaseMemAllocator_ReleaseBuffer
 417 };
 418
 419 static HRESULT StdMediaSample2_Construct(BYTE * pbBuffer, LONG cbBuffer, IMemAllocator * pParent, StdMediaSample2 ** ppSample)
 420 {
 421     assert(pbBuffer && pParent && (cbBuffer > 0));
 422
 423     if (!(*ppSample = CoTaskMemAlloc(sizeof(StdMediaSample2))))
 424         return E_OUTOFMEMORY;
 425
 426     (*ppSample)->lpvtbl = &StdMediaSample2_VTable;
 427     (*ppSample)->ref = 0;
 428     ZeroMemory(&(*ppSample)->props, sizeof((*ppSample)->props));
 429
 430     /* NOTE: no need to AddRef as the parent is guaranteed to be around
 431      * at least as long as us and we don't want to create circular
 432      * dependencies on the ref count */
 433     (*ppSample)->pParent = pParent;
 434     (*ppSample)->props.cbData = sizeof(AM_SAMPLE2_PROPERTIES);
 435     (*ppSample)->props.cbBuffer = (*ppSample)->props.lActual = cbBuffer;
 436     (*ppSample)->props.pbBuffer = pbBuffer;
 437     (*ppSample)->tMediaStart = INVALID_MEDIA_TIME;
 438     (*ppSample)->tMediaEnd = 0;
 439
 440     return S_OK;
 441 }
 442
 443 static void StdMediaSample2_Delete(StdMediaSample2 * This)
 444 {
 445     /* NOTE: does not remove itself from the list it belongs to */
 446     CoTaskMemFree(This);
 447 }
 448
 449 static HRESULT WINAPI StdMediaSample2_QueryInterface(IMediaSample2 * iface, REFIID riid, LPVOID * ppv)
 450 {
 451     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 452     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 453
 454     *ppv = NULL;
 455
 456     if (IsEqualIID(riid, &IID_IUnknown))
 457         *ppv = (LPVOID)This;
 458     else if (IsEqualIID(riid, &IID_IMediaSample))
 459         *ppv = (LPVOID)This;
 460     else if (IsEqualIID(riid, &IID_IMediaSample2))
 461         *ppv = (LPVOID)This;
 462
 463     if (*ppv)
 464     {
 465         IUnknown_AddRef((IUnknown *)(*ppv));
 466         return S_OK;
 467     }
 468
 469     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 470
 471     return E_NOINTERFACE;
 472 }
 473
 474 static ULONG WINAPI StdMediaSample2_AddRef(IMediaSample2 * iface)
 475 {
 476     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 477     ULONG ref = InterlockedIncrement(&This->ref);
 478
 479     TRACE("(%p)->() AddRef from %d\n", iface, ref - 1);
 480
 481     return ref;
 482 }
 483
 484 static ULONG WINAPI StdMediaSample2_Release(IMediaSample2 * iface)
 485 {
 486     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 487     ULONG ref = InterlockedDecrement(&This->ref);
 488
 489     TRACE("(%p)->() Release from %d\n", iface, ref + 1);
 490
 491     if (!ref)
 492     {
 493         if (This->pParent)
 494             IMemAllocator_ReleaseBuffer(This->pParent, (IMediaSample *)iface);
 495         else
 496             StdMediaSample2_Delete(This);
 497         return 0;
 498     }
 499     return ref;
 500 }
 501
 502 static HRESULT WINAPI StdMediaSample2_GetPointer(IMediaSample2 * iface, BYTE ** ppBuffer)
 503 {
 504     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 505
 506     TRACE("(%p)\n", ppBuffer);
 507
 508     *ppBuffer = This->props.pbBuffer;
 509
 510     return S_OK;
 511 }
 512
 513 static long WINAPI StdMediaSample2_GetSize(IMediaSample2 * iface)
 514 {
 515     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 516
 517     TRACE("StdMediaSample2_GetSize()\n");
 518
 519     return This->props.cbBuffer;
 520 }
 521
 522 static HRESULT WINAPI StdMediaSample2_GetTime(IMediaSample2 * iface, REFERENCE_TIME * pStart, REFERENCE_TIME * pEnd)
 523 {
 524     HRESULT hr;
 525     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 526
 527     TRACE("(%p, %p)\n", pStart, pEnd);
 528
 529     if (!(This->props.dwSampleFlags & AM_SAMPLE_TIMEVALID))
 530         hr = VFW_E_SAMPLE_TIME_NOT_SET;
 531     else if (!(This->props.dwSampleFlags & AM_SAMPLE_STOPVALID))
 532     {
 533         *pStart = This->props.tStart;
 534         *pEnd = This->props.tStart + 1;
 535
 536         hr = VFW_S_NO_STOP_TIME;
 537     }
 538     else
 539     {
 540         *pStart = This->props.tStart;
 541         *pEnd = This->props.tStop;
 542
 543         hr = S_OK;
 544     }
 545
 546     return S_OK;
 547 }
 548
 549 static HRESULT WINAPI StdMediaSample2_SetTime(IMediaSample2 * iface, REFERENCE_TIME * pStart, REFERENCE_TIME * pEnd)
 550 {
 551     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 552
 553     TRACE("(%p, %p)\n", pStart, pEnd);
 554
 555     if (pStart)
 556     {
 557         This->props.tStart = *pStart;
 558         This->props.dwSampleFlags |= AM_SAMPLE_TIMEVALID;
 559     }
 560     else
 561         This->props.dwSampleFlags &= ~AM_SAMPLE_TIMEVALID;
 562
 563     if (pEnd)
 564     {
 565         This->props.tStop = *pEnd;
 566         This->props.dwSampleFlags |= AM_SAMPLE_STOPVALID;
 567     }
 568     else
 569         This->props.dwSampleFlags &= ~AM_SAMPLE_STOPVALID;
 570
 571     return S_OK;
 572 }
 573
 574 static HRESULT WINAPI StdMediaSample2_IsSyncPoint(IMediaSample2 * iface)
 575 {
 576     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 577
 578     TRACE("()\n");
 579
 580     return (This->props.dwSampleFlags & AM_SAMPLE_SPLICEPOINT) ? S_OK : S_FALSE;
 581 }
 582
 583 static HRESULT WINAPI StdMediaSample2_SetSyncPoint(IMediaSample2 * iface, BOOL bIsSyncPoint)
 584 {
 585     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 586
 587     TRACE("(%s)\n", bIsSyncPoint ? "TRUE" : "FALSE");
 588
 589     if (bIsSyncPoint)
 590         This->props.dwSampleFlags |= AM_SAMPLE_SPLICEPOINT;
 591     else
 592         This->props.dwSampleFlags &= ~AM_SAMPLE_SPLICEPOINT;
 593
 594     return S_OK;
 595 }
 596
 597 static HRESULT WINAPI StdMediaSample2_IsPreroll(IMediaSample2 * iface)
 598 {
 599     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 600
 601     TRACE("()\n");
 602
 603     return (This->props.dwSampleFlags & AM_SAMPLE_PREROLL) ? S_OK : S_FALSE;
 604 }
 605
 606 static HRESULT WINAPI StdMediaSample2_SetPreroll(IMediaSample2 * iface, BOOL bIsPreroll)
 607 {
 608     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 609
 610     TRACE("(%s)\n", bIsPreroll ? "TRUE" : "FALSE");
 611
 612     if (bIsPreroll)
 613         This->props.dwSampleFlags |= AM_SAMPLE_PREROLL;
 614     else
 615         This->props.dwSampleFlags &= ~AM_SAMPLE_PREROLL;
 616
 617     return S_OK;
 618 }
 619
 620 static LONG WINAPI StdMediaSample2_GetActualDataLength(IMediaSample2 * iface)
 621 {
 622     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 623
 624     TRACE("()\n");
 625
 626     return This->props.lActual;
 627 }
 628
 629 static HRESULT WINAPI StdMediaSample2_SetActualDataLength(IMediaSample2 * iface, LONG len)
 630 {
 631     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 632
 633     TRACE("(%d)\n", len);
 634
 635     if ((len > This->props.cbBuffer) || (len < 0))
 636         return VFW_E_BUFFER_OVERFLOW;
 637     else
 638     {
 639         This->props.lActual = len;
 640         return S_OK;
 641     }
 642 }
 643
 644 static HRESULT WINAPI StdMediaSample2_GetMediaType(IMediaSample2 * iface, AM_MEDIA_TYPE ** ppMediaType)
 645 {
 646     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 647
 648     TRACE("(%p)\n", ppMediaType);
 649
 650     if (!This->props.pMediaType) {
 651         /* Make sure we return a NULL pointer (required by native Quartz dll) */
 652         if (ppMediaType)
 653             *ppMediaType = NULL;
 654         return S_FALSE;
 655     }
 656
 657     if (!(*ppMediaType = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE))))
 658         return E_OUTOFMEMORY;
 659
 660     return CopyMediaType(*ppMediaType, This->props.pMediaType);
 661 }
 662
 663 static HRESULT WINAPI StdMediaSample2_SetMediaType(IMediaSample2 * iface, AM_MEDIA_TYPE * pMediaType)
 664 {
 665     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 666
 667     TRACE("(%p)\n", pMediaType);
 668
 669     if (This->props.pMediaType)
 670         FreeMediaType(This->props.pMediaType);
 671     else if (!(This->props.pMediaType = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE))))
 672         return E_OUTOFMEMORY;
 673
 674     return CopyMediaType(This->props.pMediaType, pMediaType);
 675 }
 676
 677 static HRESULT WINAPI StdMediaSample2_IsDiscontinuity(IMediaSample2 * iface)
 678 {
 679     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 680
 681     TRACE("()\n");
 682
 683     return (This->props.dwSampleFlags & AM_SAMPLE_DATADISCONTINUITY) ? S_OK : S_FALSE;
 684 }
 685
 686 static HRESULT WINAPI StdMediaSample2_SetDiscontinuity(IMediaSample2 * iface, BOOL bIsDiscontinuity)
 687 {
 688     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 689
 690     TRACE("(%s)\n", bIsDiscontinuity ? "TRUE" : "FALSE");
 691
 692     if (bIsDiscontinuity)
 693         This->props.dwSampleFlags |= AM_SAMPLE_DATADISCONTINUITY;
 694     else
 695         This->props.dwSampleFlags &= ~AM_SAMPLE_DATADISCONTINUITY;
 696
 697     return S_OK;
 698 }
 699
 700 static HRESULT WINAPI StdMediaSample2_GetMediaTime(IMediaSample2 * iface, LONGLONG * pStart, LONGLONG * pEnd)
 701 {
 702     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 703
 704     TRACE("(%p, %p)\n", pStart, pEnd);
 705
 706     if (This->tMediaStart == INVALID_MEDIA_TIME)
 707         return VFW_E_MEDIA_TIME_NOT_SET;
 708
 709     *pStart = This->tMediaStart;
 710     *pEnd = This->tMediaEnd;
 711
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI StdMediaSample2_SetMediaTime(IMediaSample2 * iface, LONGLONG * pStart, LONGLONG * pEnd)
 716 {
 717     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 718
 719     TRACE("(%p, %p)\n", pStart, pEnd);
 720
 721     if (pStart)
 722         This->tMediaStart = *pStart;
 723     else
 724         This->tMediaStart = INVALID_MEDIA_TIME;
 725
 726     if (pEnd)
 727         This->tMediaEnd = *pEnd;
 728     else
 729         This->tMediaEnd = 0;
 730
 731     return S_OK;
 732 }
 733
 734 static HRESULT WINAPI StdMediaSample2_GetProperties(IMediaSample2 * iface, DWORD cbProperties, BYTE * pbProperties)
 735 {
 736     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 737
 738     TRACE("(%d, %p)\n", cbProperties, pbProperties);
 739
 740     memcpy(pbProperties, &This->props, min(cbProperties, sizeof(This->props)));
 741
 742     return S_OK;
 743 }
 744
 745 static HRESULT WINAPI StdMediaSample2_SetProperties(IMediaSample2 * iface, DWORD cbProperties, const BYTE * pbProperties)
 746 {
 747     StdMediaSample2 *This = (StdMediaSample2 *)iface;
 748
 749     TRACE("(%d, %p)\n", cbProperties, pbProperties);
 750
 751     /* NOTE: pbBuffer and cbBuffer are read-only */
 752     memcpy(&This->props, pbProperties, min(cbProperties, AM_SAMPLE2_PROP_SIZE_WRITABLE));
 753
 754     return S_OK;
 755 }
 756
 757 static const IMediaSample2Vtbl StdMediaSample2_VTable =
 758 {
 759     StdMediaSample2_QueryInterface,
 760     StdMediaSample2_AddRef,
 761     StdMediaSample2_Release,
 762     StdMediaSample2_GetPointer,
 763     StdMediaSample2_GetSize,
 764     StdMediaSample2_GetTime,
 765     StdMediaSample2_SetTime,
 766     StdMediaSample2_IsSyncPoint,
 767     StdMediaSample2_SetSyncPoint,
 768     StdMediaSample2_IsPreroll,
 769     StdMediaSample2_SetPreroll,
 770     StdMediaSample2_GetActualDataLength,
 771     StdMediaSample2_SetActualDataLength,
 772     StdMediaSample2_GetMediaType,
 773     StdMediaSample2_SetMediaType,
 774     StdMediaSample2_IsDiscontinuity,
 775     StdMediaSample2_SetDiscontinuity,
 776     StdMediaSample2_GetMediaTime,
 777     StdMediaSample2_SetMediaTime,
 778     StdMediaSample2_GetProperties,
 779     StdMediaSample2_SetProperties
 780 };
 781
 782 typedef struct StdMemAllocator
 783 {
 784     BaseMemAllocator base;
 785     LPVOID pMemory;
 786 } StdMemAllocator;
 787
 788 static HRESULT StdMemAllocator_Alloc(IMemAllocator * iface)
 789 {
 790     StdMemAllocator *This = (StdMemAllocator *)iface;
 791     StdMediaSample2 * pSample = NULL;
 792     SYSTEM_INFO si;
 793     long i;
 794
 795     assert(list_empty(&This->base.free_list));
 796
 797     /* check alignment */
 798     GetSystemInfo(&si);
 799
 800     /* we do not allow a courser alignment than the OS page size */
 801     if ((si.dwPageSize % This->base.pProps->cbAlign) != 0)
 802         return VFW_E_BADALIGN;
 803
 804     /* FIXME: each sample has to have its buffer start on the right alignment.
 805      * We don't do this at the moment */
 806
 807     /* allocate memory */
 808     This->pMemory = VirtualAlloc(NULL, (This->base.pProps->cbBuffer + This->base.pProps->cbPrefix) * This->base.pProps->cBuffers, MEM_COMMIT, PAGE_READWRITE);
 809
 810     for (i = This->base.pProps->cBuffers - 1; i >= 0; i--)
 811     {
 812         /* pbBuffer does not start at the base address, it starts at base + cbPrefix */
 813         BYTE * pbBuffer = (BYTE *)This->pMemory + i * (This->base.pProps->cbBuffer + This->base.pProps->cbPrefix) + This->base.pProps->cbPrefix;
 814
 815         StdMediaSample2_Construct(pbBuffer, This->base.pProps->cbBuffer, iface, &pSample);
 816
 817         list_add_head(&This->base.free_list, &pSample->listentry);
 818     }
 819
 820     return S_OK;
 821 }
 822
 823 static HRESULT StdMemAllocator_Free(IMemAllocator * iface)
 824 {
 825     StdMemAllocator *This = (StdMemAllocator *)iface;
 826     struct list * cursor;
 827
 828     if (!list_empty(&This->base.used_list))
 829     {
 830         WARN("Freeing allocator with outstanding samples!\n");
 831         while ((cursor = list_head(&This->base.used_list)) != NULL)
 832         {
 833             StdMediaSample2 *pSample;
 834             list_remove(cursor);
 835             pSample = LIST_ENTRY(cursor, StdMediaSample2, listentry);
 836             pSample->pParent = NULL;
 837         }
 838     }
 839
 840     while ((cursor = list_head(&This->base.free_list)) != NULL)
 841     {
 842         list_remove(cursor);
 843         StdMediaSample2_Delete(LIST_ENTRY(cursor, StdMediaSample2, listentry));
 844     }
 845
 846     /* free memory */
 847     if (!VirtualFree(This->pMemory, 0, MEM_RELEASE))
 848     {
 849         ERR("Couldn't free memory. Error: %u\n", GetLastError());
 850         return HRESULT_FROM_WIN32(GetLastError());
 851     }
 852
 853     return S_OK;
 854 }
 855
 856 HRESULT StdMemAllocator_create(LPUNKNOWN lpUnkOuter, LPVOID * ppv)
 857 {
 858     StdMemAllocator * pMemAlloc;
 859     HRESULT hr;
 860
 861     *ppv = NULL;
 862
 863     if (lpUnkOuter)
 864         return CLASS_E_NOAGGREGATION;
 865
 866     if (!(pMemAlloc = CoTaskMemAlloc(sizeof(*pMemAlloc))))
 867         return E_OUTOFMEMORY;
 868
 869     pMemAlloc->pMemory = NULL;
 870
 871     if (SUCCEEDED(hr = BaseMemAllocator_Init(StdMemAllocator_Alloc, StdMemAllocator_Free, &pMemAlloc->base)))
 872         *ppv = (LPVOID)pMemAlloc;
 873     else
 874         CoTaskMemFree(pMemAlloc);
 875
 876     return hr;
 877 }