HRESULT create (ComSmartPtr <IGraphBuilder>& graphBuilder,
ComSmartPtr <IBaseFilter>& baseFilter, HWND hwnd)
{
ComSmartPtr <IVMRFilterConfig> filterConfig;
HRESULT hr = baseFilter.CoCreateInstance (CLSID_VideoMixingRenderer);
if (SUCCEEDED (hr))
hr = graphBuilder->AddFilter (baseFilter, L"VMR-7");
if (SUCCEEDED (hr))
hr = baseFilter.QueryInterface (filterConfig);
if (SUCCEEDED (hr))
hr = filterConfig->SetRenderingMode (VMRMode_Windowless);
if (SUCCEEDED (hr))
hr = baseFilter.QueryInterface (windowlessControl);
if (SUCCEEDED (hr))
hr = windowlessControl->SetVideoClippingWindow (hwnd);
if (SUCCEEDED (hr))
hr = windowlessControl->SetAspectRatioMode (VMR_ARMODE_LETTER_BOX);
return hr;
}
void scanFileForDetails()
{
ComSmartPtr<IWMHeaderInfo> wmHeaderInfo;
HRESULT hr = wmSyncReader.QueryInterface (wmHeaderInfo);
if (SUCCEEDED (hr))
{
QWORD lengthInNanoseconds = 0;
WORD lengthOfLength = sizeof (lengthInNanoseconds);
WORD streamNum = 0;
WMT_ATTR_DATATYPE wmAttrDataType;
hr = wmHeaderInfo->GetAttributeByName (&streamNum, L"Duration", &wmAttrDataType,
(BYTE*) &lengthInNanoseconds, &lengthOfLength);
ComSmartPtr<IWMProfile> wmProfile;
hr = wmSyncReader.QueryInterface (wmProfile);
if (SUCCEEDED (hr))
{
ComSmartPtr<IWMStreamConfig> wmStreamConfig;
hr = wmProfile->GetStream (0, wmStreamConfig.resetAndGetPointerAddress());
if (SUCCEEDED (hr))
{
ComSmartPtr<IWMMediaProps> wmMediaProperties;
hr = wmStreamConfig.QueryInterface (wmMediaProperties);
if (SUCCEEDED (hr))
{
DWORD sizeMediaType;
hr = wmMediaProperties->GetMediaType (0, &sizeMediaType);
HeapBlock<WM_MEDIA_TYPE> mediaType;
mediaType.malloc (sizeMediaType, 1);
hr = wmMediaProperties->GetMediaType (mediaType, &sizeMediaType);
if (mediaType->majortype == WMMEDIATYPE_Audio)
{
const WAVEFORMATEX* const inputFormat = reinterpret_cast<WAVEFORMATEX*> (mediaType->pbFormat);
sampleRate = inputFormat->nSamplesPerSec;
numChannels = inputFormat->nChannels;
bitsPerSample = inputFormat->wBitsPerSample;
lengthInSamples = (lengthInNanoseconds * (int) sampleRate) / 10000000;
}
}
}
}
}
}
HRESULT create (ComSmartPtr <IGraphBuilder>& graphBuilder,
ComSmartPtr <IBaseFilter>& baseFilter, HWND hwnd)
{
ComSmartPtr <IMFGetService> getService;
HRESULT hr = baseFilter.CoCreateInstance (CLSID_EnhancedVideoRenderer);
if (SUCCEEDED (hr))
hr = graphBuilder->AddFilter (baseFilter, L"EVR");
if (SUCCEEDED (hr))
hr = baseFilter.QueryInterface (getService);
if (SUCCEEDED (hr))
hr = getService->GetService (MR_VIDEO_RENDER_SERVICE, IID_IMFVideoDisplayControl,
(LPVOID*) videoDisplayControl.resetAndGetPointerAddress());
if (SUCCEEDED (hr))
hr = videoDisplayControl->SetVideoWindow (hwnd);
if (SUCCEEDED (hr))
hr = videoDisplayControl->SetAspectRatioMode (MFVideoARMode_PreservePicture);
return hr;
}
EDataFlow getDataFlow (const ComSmartPtr<IMMDevice>& device)
{
EDataFlow flow = eRender;
ComSmartPtr <IMMEndpoint> endPoint;
if (check (device.QueryInterface (endPoint)))
(void) check (endPoint->GetDataFlow (&flow));
return flow;
}
void LgUnicodeCollater::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<LgUnicodeCollater> qunicoll;
qunicoll.Attach(NewObj LgUnicodeCollater()); // ref count initialy 1
CheckHr(qunicoll->QueryInterface(riid, ppv));
}
void VwInvertedRootBox::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<VwInvertedRootBox> qrootb;
qrootb.Attach(NewObj VwInvertedRootBox()); // ref count initialy 1
CheckHr(qrootb->QueryInterface(riid, ppv));
}
/*----------------------------------------------------------------------------------------------
This static method creates a new LgTsDataObject object.
----------------------------------------------------------------------------------------------*/
void LgTsDataObject::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<LgTsDataObject> qtsdo;
qtsdo.Attach(NewObj LgTsDataObject); // ref count initialy 1
CheckHr(qtsdo->QueryInterface(riid, ppv));
}
void RomRenderEngine::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<RomRenderEngine> qrre;
qrre.Attach(NewObj RomRenderEngine()); // ref count initialy 1
CheckHr(qrre->QueryInterface(riid, ppv));
}
void LgInputMethodEditor::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<LgInputMethodEditor> qime;
qime.Attach(NewObj LgInputMethodEditor()); // ref count initialy 1
CheckHr(qime->QueryInterface(riid, ppv));
}
void AfFwTool::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<AfFwTool> qaft;
qaft.Attach(NewObj AfFwTool()); // ref count initialy 1
CheckHr(qaft->QueryInterface(riid, ppv));
}
/*----------------------------------------------------------------------------------------------
Static method to create an instance of FwCppStylesDlg.
----------------------------------------------------------------------------------------------*/
void FwCppStylesDlg::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<FwCppStylesDlg> qzfwst;
qzfwst.Attach(NewObj FwCppStylesDlg()); // ref count initially 1
CheckHr(qzfwst->QueryInterface(riid, ppv));
}
void LgIcuConverterEnumerator::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<LgIcuConverterEnumerator> qlcpe;
qlcpe.Attach(NewObj LgIcuConverterEnumerator()); // ref count initialy 1
CheckHr(qlcpe->QueryInterface(riid, ppv));
}
void SampleInterface::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<SampleInterface> qxsi;
qxsi.Attach(NewObj SampleInterface()); // ref count initialy 1
CheckHr(qxsi->QueryInterface(riid, ppv));
}
//:>********************************************************************************************
//:> DbColSpec - IUnknown methods
//:>********************************************************************************************
void DbColSpec::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
{
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
}
ComSmartPtr<DbColSpec> qzdcs;
qzdcs.Attach(NewObj DbColSpec()); // ref count initially 1
CheckHr(qzdcs->QueryInterface(riid, ppv));
}
void DebugReport::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
{
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
}
ComSmartPtr<DebugReport> qdbr;
// Ref count initially 1
qdbr.Attach(NewObj DebugReport());
CheckHr(qdbr->QueryInterface(riid, ppv));
}
void ActionHandler::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
{
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
}
ComSmartPtr<ActionHandler> qzacth;
// Ref count initially 1
qzacth.Attach(NewObj ActionHandler());
CheckHr(qzacth->QueryInterface(riid, ppv));
}
void handleFrame (double /*time*/, BYTE* buffer, long /*bufferSize*/)
{
if (recordNextFrameTime)
{
const double defaultCameraLatency = 0.1;
firstRecordedTime = Time::getCurrentTime() - RelativeTime (defaultCameraLatency);
recordNextFrameTime = false;
ComSmartPtr<IPin> pin;
if (getPin (filter, PINDIR_OUTPUT, pin))
{
ComSmartPtr<IAMPushSource> pushSource;
HRESULT hr = pin.QueryInterface (pushSource);
if (pushSource != nullptr)
{
REFERENCE_TIME latency = 0;
hr = pushSource->GetLatency (&latency);
firstRecordedTime = firstRecordedTime - RelativeTime ((double) latency);
}
}
}
{
const int lineStride = width * 3;
const ScopedLock sl (imageSwapLock);
{
loadingImage.duplicateIfShared();
const Image::BitmapData destData (loadingImage, 0, 0, width, height, Image::BitmapData::writeOnly);
for (int i = 0; i < height; ++i)
memcpy (destData.getLinePointer ((height - 1) - i),
buffer + lineStride * i,
lineStride);
}
imageNeedsFlipping = true;
}
if (listeners.size() > 0)
callListeners (loadingImage);
sendChangeMessage();
}
void LgIcuResourceBundle::CreateCom(IUnknown *punkCtl, REFIID riid, void ** ppv)
{
AssertPtr(ppv);
Assert(!*ppv);
if (punkCtl)
ThrowHr(WarnHr(CLASS_E_NOAGGREGATION));
ComSmartPtr<LgIcuResourceBundle> qlcpe;
StrUtil::InitIcuDataDir();
UErrorCode uerr = U_ZERO_ERROR;
ResourceBundle rbt(NULL, Locale("en"), uerr);
if (U_FAILURE(uerr))
ThrowHr(E_FAIL);
qlcpe.Attach(NewObj LgIcuResourceBundle(rbt)); // ref count initialy 1
CheckHr(qlcpe->QueryInterface(riid, ppv));
}
DShowCameraDeviceInteral (CameraDevice* const owner_,
const ComSmartPtr <ICaptureGraphBuilder2>& captureGraphBuilder_,
const ComSmartPtr <IBaseFilter>& filter_,
int minWidth, int minHeight,
int maxWidth, int maxHeight)
: owner (owner_),
captureGraphBuilder (captureGraphBuilder_),
filter (filter_),
ok (false),
imageNeedsFlipping (false),
width (0),
height (0),
activeUsers (0),
recordNextFrameTime (false),
previewMaxFPS (60)
{
HRESULT hr = graphBuilder.CoCreateInstance (CLSID_FilterGraph);
if (FAILED (hr))
return;
hr = captureGraphBuilder->SetFiltergraph (graphBuilder);
if (FAILED (hr))
return;
hr = graphBuilder.QueryInterface (mediaControl);
if (FAILED (hr))
return;
{
ComSmartPtr <IAMStreamConfig> streamConfig;
hr = captureGraphBuilder->FindInterface (&PIN_CATEGORY_CAPTURE, 0, filter,
IID_IAMStreamConfig, (void**) streamConfig.resetAndGetPointerAddress());
if (streamConfig != nullptr)
{
getVideoSizes (streamConfig);
if (! selectVideoSize (streamConfig, minWidth, minHeight, maxWidth, maxHeight))
return;
}
}
hr = graphBuilder->AddFilter (filter, _T("Video Capture"));
if (FAILED (hr))
return;
hr = smartTee.CoCreateInstance (CLSID_SmartTee);
if (FAILED (hr))
return;
hr = graphBuilder->AddFilter (smartTee, _T("Smart Tee"));
if (FAILED (hr))
return;
if (! connectFilters (filter, smartTee))
return;
ComSmartPtr <IBaseFilter> sampleGrabberBase;
hr = sampleGrabberBase.CoCreateInstance (CLSID_SampleGrabber);
if (FAILED (hr))
return;
hr = sampleGrabberBase.QueryInterface (IID_ISampleGrabber, sampleGrabber);
if (FAILED (hr))
return;
{
AM_MEDIA_TYPE mt = { 0 };
mt.majortype = MEDIATYPE_Video;
mt.subtype = MEDIASUBTYPE_RGB24;
mt.formattype = FORMAT_VideoInfo;
sampleGrabber->SetMediaType (&mt);
}
callback = new GrabberCallback (*this);
hr = sampleGrabber->SetCallback (callback, 1);
hr = graphBuilder->AddFilter (sampleGrabberBase, _T("Sample Grabber"));
if (FAILED (hr))
return;
ComSmartPtr <IPin> grabberInputPin;
if (! (getPin (smartTee, PINDIR_OUTPUT, smartTeeCaptureOutputPin, "capture")
&& getPin (smartTee, PINDIR_OUTPUT, smartTeePreviewOutputPin, "preview")
&& getPin (sampleGrabberBase, PINDIR_INPUT, grabberInputPin)))
return;
hr = graphBuilder->Connect (smartTeePreviewOutputPin, grabberInputPin);
if (FAILED (hr))
return;
AM_MEDIA_TYPE mt = { 0 };
hr = sampleGrabber->GetConnectedMediaType (&mt);
VIDEOINFOHEADER* pVih = (VIDEOINFOHEADER*) (mt.pbFormat);
width = pVih->bmiHeader.biWidth;
height = pVih->bmiHeader.biHeight;
ComSmartPtr <IBaseFilter> nullFilter;
hr = nullFilter.CoCreateInstance (CLSID_NullRenderer);
hr = graphBuilder->AddFilter (nullFilter, _T("Null Renderer"));
if (connectFilters (sampleGrabberBase, nullFilter)
&& addGraphToRot())
{
activeImage = Image (Image::RGB, width, height, true);
loadingImage = Image (Image::RGB, width, height, true);
ok = true;
}
}