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