static void CommitDecommitTest(void)
{
IMemAllocator* pMemAllocator;
HRESULT hr;
hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAllocator);
ok(hr==S_OK, "Unable to create memory allocator %x\n", hr);
if (hr == S_OK)
{
ALLOCATOR_PROPERTIES RequestedProps;
ALLOCATOR_PROPERTIES ActualProps;
IMediaSample *sample = NULL, *sample2 = NULL;
RequestedProps.cBuffers = 2;
RequestedProps.cbBuffer = 65536;
RequestedProps.cbAlign = 1;
RequestedProps.cbPrefix = 0;
hr = IMemAllocator_SetProperties(pMemAllocator, &RequestedProps, &ActualProps);
ok(hr==S_OK, "SetProperties returned: %x\n", hr);
hr = IMemAllocator_Commit(pMemAllocator);
ok(hr==S_OK, "Commit returned: %x\n", hr);
hr = IMemAllocator_Commit(pMemAllocator);
ok(hr==S_OK, "Commit returned: %x\n", hr);
hr = IMemAllocator_GetBuffer(pMemAllocator, &sample, NULL, NULL, 0);
ok(hr==S_OK, "Could not get a buffer: %x\n", hr);
hr = IMemAllocator_Decommit(pMemAllocator);
ok(hr==S_OK, "Decommit returned: %x\n", hr);
hr = IMemAllocator_Decommit(pMemAllocator);
ok(hr==S_OK, "Cecommit returned: %x\n", hr);
/* Decommit and recommit while holding a sample */
if (sample)
{
hr = IMemAllocator_Commit(pMemAllocator);
ok(hr==S_OK, "Commit returned: %x\n", hr);
hr = IMemAllocator_GetBuffer(pMemAllocator, &sample2, NULL, NULL, 0);
ok(hr==S_OK, "Could not get a buffer: %x\n", hr);
IUnknown_Release(sample);
if (sample2)
IUnknown_Release(sample2);
hr = IMemAllocator_Decommit(pMemAllocator);
ok(hr==S_OK, "Cecommit returned: %x\n", hr);
}
IMemAllocator_Release(pMemAllocator);
}
}
HRESULT qcap_driver_run(Capture *capBox, FILTER_STATE *state)
{
HANDLE thread;
HRESULT hr;
TRACE("%p -> (%p)\n", capBox, state);
if (*state == State_Running) return S_OK;
EnterCriticalSection(&capBox->CritSect);
capBox->stopped = 0;
if (*state == State_Stopped)
{
*state = State_Running;
if (!capBox->iscommitted++)
{
ALLOCATOR_PROPERTIES ap, actual;
BaseOutputPin *out;
ap.cBuffers = 3;
if (!capBox->swresize)
ap.cbBuffer = capBox->width * capBox->height;
else
ap.cbBuffer = capBox->outputwidth * capBox->outputheight;
ap.cbBuffer = (ap.cbBuffer * capBox->bitDepth) / 8;
ap.cbAlign = 1;
ap.cbPrefix = 0;
out = (BaseOutputPin *)capBox->pOut;
hr = IMemAllocator_SetProperties(out->pAllocator, &ap, &actual);
if (SUCCEEDED(hr))
hr = IMemAllocator_Commit(out->pAllocator);
TRACE("Committing allocator: %x\n", hr);
}
thread = CreateThread(NULL, 0, ReadThread, capBox, 0, NULL);
if (thread)
{
capBox->thread = thread;
SetThreadPriority(thread, THREAD_PRIORITY_LOWEST);
LeaveCriticalSection(&capBox->CritSect);
return S_OK;
}
ERR("Creating thread failed.. %u\n", GetLastError());
LeaveCriticalSection(&capBox->CritSect);
return E_FAIL;
}
ResumeThread(capBox->thread);
*state = State_Running;
LeaveCriticalSection(&capBox->CritSect);
return S_OK;
}
static HRESULT WINAPI AVICompressor_Run(IBaseFilter *iface, REFERENCE_TIME tStart)
{
AVICompressor *This = impl_from_IBaseFilter(iface);
HRESULT hres;
TRACE("(%p)->(%s)\n", This, wine_dbgstr_longlong(tStart));
if(This->filter.state == State_Running)
return S_OK;
hres = IMemAllocator_Commit(This->out->pAllocator);
if(FAILED(hres)) {
FIXME("Commit failed: %08x\n", hres);
return hres;
}
This->frame_cnt = 0;
This->filter.state = State_Running;
return S_OK;
}
static HRESULT WINAPI QTInPin_ReceiveConnection(IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
{
HRESULT hr = S_OK;
ALLOCATOR_PROPERTIES props;
QTInPin *This = impl_from_IPin(iface);
TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
EnterCriticalSection(This->pin.pCritSec);
This->pReader = NULL;
if (This->pin.pConnectedTo)
hr = VFW_E_ALREADY_CONNECTED;
else if (IPin_QueryAccept(iface, pmt) != S_OK)
hr = VFW_E_TYPE_NOT_ACCEPTED;
else
{
PIN_DIRECTION pindirReceive;
IPin_QueryDirection(pReceivePin, &pindirReceive);
if (pindirReceive != PINDIR_OUTPUT)
hr = VFW_E_INVALID_DIRECTION;
}
if (FAILED(hr))
{
LeaveCriticalSection(This->pin.pCritSec);
return hr;
}
hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader);
if (FAILED(hr))
{
LeaveCriticalSection(This->pin.pCritSec);
TRACE("Input source is not an AsyncReader\n");
return hr;
}
LeaveCriticalSection(This->pin.pCritSec);
EnterCriticalSection(&impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->filter.csFilter);
hr = QT_Process_Movie(impl_from_IBaseFilter(This->pin.pinInfo.pFilter));
if (FAILED(hr))
{
LeaveCriticalSection(&impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->filter.csFilter);
TRACE("Unable to process movie\n");
return hr;
}
This->pAlloc = NULL;
props.cBuffers = 8;
props.cbAlign = 1;
props.cbBuffer = impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->outputSize + props.cbAlign;
props.cbPrefix = 0;
hr = IAsyncReader_RequestAllocator(This->pReader, NULL, &props, &This->pAlloc);
if (SUCCEEDED(hr))
{
CopyMediaType(&This->pin.mtCurrent, pmt);
This->pin.pConnectedTo = pReceivePin;
IPin_AddRef(pReceivePin);
hr = IMemAllocator_Commit(This->pAlloc);
}
else
{
QT_RemoveOutputPins(impl_from_IBaseFilter(This->pin.pinInfo.pFilter));
if (This->pReader)
IAsyncReader_Release(This->pReader);
This->pReader = NULL;
if (This->pAlloc)
IMemAllocator_Release(This->pAlloc);
This->pAlloc = NULL;
}
TRACE("Size: %i\n", props.cbBuffer);
LeaveCriticalSection(&impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->filter.csFilter);
return hr;
}
