void WASAPISource::InitClient()
{
CoTaskMemPtr<WAVEFORMATEX> wfex;
HRESULT res;
DWORD flags = AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
res = device->Activate(__uuidof(IAudioClient), CLSCTX_ALL,
nullptr, (void**)client.Assign());
if (FAILED(res))
throw HRError("Failed to activate client context", res);
res = client->GetMixFormat(&wfex);
if (FAILED(res))
throw HRError("Failed to get mix format", res);
InitFormat(wfex);
if (!isInputDevice)
flags |= AUDCLNT_STREAMFLAGS_LOOPBACK;
res = client->Initialize(
AUDCLNT_SHAREMODE_SHARED, flags,
BUFFER_TIME_100NS, 0, wfex, nullptr);
if (FAILED(res))
throw HRError("Failed to get initialize audio client", res);
}
HRESULT ezUwpApplication::OnActivated(ICoreApplicationView* view, IActivatedEventArgs* args)
{
view->remove_Activated(m_activateRegistrationToken);
ActivationKind activationKind;
EZ_SUCCEED_OR_RETURN(args->get_Kind(&activationKind));
if (activationKind == ActivationKind_Launch)
{
ComPtr<ILaunchActivatedEventArgs> launchArgs;
EZ_SUCCEED_OR_RETURN(args->QueryInterface(launchArgs.GetAddressOf()));
HString argHString;
EZ_SUCCEED_OR_RETURN(launchArgs->get_Arguments(argHString.GetAddressOf()));
ezDynamicArray<const char*> argv;
ezCommandLineUtils::SplitCommandLineString(ezStringUtf8(argHString).GetData(), true, m_commandLineArgs, argv);
m_application->SetCommandLineArguments(argv.GetCount(), argv.GetData());
}
// Activate main window together with the application!
ComPtr<ABI::Windows::UI::Core::ICoreWindow> pCoreWindow;
EZ_SUCCEED_OR_RETURN(view->get_CoreWindow(pCoreWindow.GetAddressOf()));
EZ_SUCCEED_OR_RETURN(pCoreWindow->Activate());
return S_OK;
}
void WASAPISource::InitRender()
{
CoTaskMemPtr<WAVEFORMATEX> wfex;
HRESULT res;
LPBYTE buffer;
UINT32 frames;
ComPtr<IAudioClient> client;
res = device->Activate(__uuidof(IAudioClient), CLSCTX_ALL,
nullptr, (void**)client.Assign());
if (FAILED(res))
throw HRError("Failed to activate client context", res);
res = client->GetMixFormat(&wfex);
if (FAILED(res))
throw HRError("Failed to get mix format", res);
res = client->Initialize(
AUDCLNT_SHAREMODE_SHARED, 0,
BUFFER_TIME_100NS, 0, wfex, nullptr);
if (FAILED(res))
throw HRError("Failed to get initialize audio client", res);
/* Silent loopback fix. Prevents audio stream from stopping and */
/* messing up timestamps and other weird glitches during silence */
/* by playing a silent sample all over again. */
res = client->GetBufferSize(&frames);
if (FAILED(res))
throw HRError("Failed to get buffer size", res);
res = client->GetService(__uuidof(IAudioRenderClient),
(void**)render.Assign());
if (FAILED(res))
throw HRError("Failed to get render client", res);
res = render->GetBuffer(frames, &buffer);
if (FAILED(res))
throw HRError("Failed to get buffer", res);
memset(buffer, 0, frames*wfex->nBlockAlign);
render->ReleaseBuffer(frames, 0);
}
void TextService::setGlobalCompartmentValue(const GUID& key, DWORD value) {
if(threadMgr_) {
ComPtr<ITfCompartment> compartment = globalCompartment(key);
if(compartment) {
VARIANT var;
::VariantInit(&var);
var.vt = VT_I4;
var.lVal = value;
compartment->SetValue(clientId_, &var);
}
}
else {
// if we don't have a thread manager (this is possible when we try to set
// a global compartment value while the text service is not activated)
ComPtr<ITfThreadMgr> threadMgr;
if(::CoCreateInstance(CLSID_TF_ThreadMgr, NULL, CLSCTX_INPROC_SERVER, IID_ITfThreadMgr, (void**)&threadMgr) == S_OK) {
if(threadMgr) {
ComPtr<ITfCompartmentMgr> compartmentMgr;
if(threadMgr->GetGlobalCompartment(&compartmentMgr) == S_OK) {
ComPtr<ITfCompartment> compartment;
if(compartmentMgr->GetCompartment(key, &compartment) == S_OK && compartment) {
TfClientId id;
if(threadMgr->Activate(&id) == S_OK) {
VARIANT var;
::VariantInit(&var);
var.vt = VT_I4;
var.lVal = value;
compartment->SetValue(id, &var);
threadMgr->Deactivate();
}
}
}
}
}
}
}
//
// InitializeAudioDeviceAsync()
//
// Activates the default audio capture on a asynchronous callback thread. This needs
// to be called from the main UI thread.
//
HRESULT AudioCaptureDevice::InitializeAudioDevice(UINT reflexIntervalMilliSec)
{
HRESULT hr = S_OK;
DWORD dwTaskID = 0;
REFERENCE_TIME bufferRefTime = reflexIntervalMilliSec * REFTIMES_PER_MILLISEC;
hr = MFStartup(MF_VERSION);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
// Initialize Critial Section
if (!InitializeCriticalSectionEx(&m_CritSec, 0, 0))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return HRESULT_FROM_WIN32(GetLastError());
}
// Find and Active the first audio recorder
{
ComPtr<IMMDeviceEnumerator> pEnumerator = nullptr;
ComPtr<IMMDevice> pDevice = nullptr;
hr = CoCreateInstance(
CLSID_MMDeviceEnumerator, NULL,
CLSCTX_ALL, IID_IMMDeviceEnumerator,
(void**) &pEnumerator);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
// Get a string representing the Default Audio Capture Device
hr = pEnumerator->GetDefaultAudioEndpoint(
eCapture, eConsole, &pDevice);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
#ifdef ACTIVE_AUDIO_ASYNC
ComPtr<IActivateAudioInterfaceAsyncOperation> pAsyncOp = nullptr;
LPWSTR endPointId = L"\\?\SWD#MMDEVAPI#{0.0.1.00000000}.{963a2c89-65fe-46f1-850d-4eea82af65b2}#{2eef81be-33fa-4800-9670-1cd474972c3f}";
hr = pDevice->GetId(&endPointId);
// This call must be made on the main UI thread. Async operation will call back to
// IActivateAudioInterfaceCompletionHandler::ActivateCompleted, which must be an agile interface implementation
hr = ActivateAudioInterfaceAsync(endPointId, __uuidof(IAudioClient), nullptr, this, &pAsyncOp);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
}
#else // ACTIVE_AUDIO_ASYNC
hr = pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**) &m_AudioClient);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
}
hr = m_AudioClient->GetMixFormat(&m_MixFormat);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
// convert from Float to PCM and from WAVEFORMATEXTENSIBLE to WAVEFORMATEX
if ((m_MixFormat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) ||
((m_MixFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
(reinterpret_cast<WAVEFORMATEXTENSIBLE *>(m_MixFormat)->SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)))
{
m_MixFormat->wFormatTag = WAVE_FORMAT_PCM;
m_MixFormat->wBitsPerSample = 16;
m_MixFormat->nBlockAlign = m_MixFormat->nChannels * 2; // (nChannels * wBitsPerSample) / 8
m_MixFormat->nAvgBytesPerSec = m_MixFormat->nSamplesPerSec * m_MixFormat->nBlockAlign;
m_MixFormat->cbSize = 0;
}
// Initialize the AudioClient in Shared Mode with the user specified buffer
hr = m_AudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
bufferRefTime,
0,
m_MixFormat,
nullptr);
if (m_pAudioSink != nullptr)
hr = m_pAudioSink->OnFormatChange(m_MixFormat);
// Get the maximum size of the AudioClient Buffer
hr = m_AudioClient->GetBufferSize(&m_BufferFrames);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
// Get the capture client
hr = m_AudioClient->GetService(__uuidof(IAudioCaptureClient), &m_AudioCaptureClient);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
// Create events for sample ready or user stop
m_SampleReadyEvent = CreateEventEx(nullptr, nullptr, 0, EVENT_ALL_ACCESS);
if (nullptr == m_SampleReadyEvent)
{
SetState(DeviceState::DeviceStateInError, hr, true);
return HRESULT_FROM_WIN32(GetLastError());
}
// Register MMCSS work queue
hr = MFLockSharedWorkQueue(L"Capture", 0, &dwTaskID, &m_dwQueueID);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
// Set the capture event work queue to use the MMCSS queue
cb_SampleReady.SetQueueID(m_dwQueueID);
// Sets the event handle that the system signals when an audio buffer is ready to be processed by the client
hr = m_AudioClient->SetEventHandle(m_SampleReadyEvent);
if (FAILED(hr))
{
SetState(DeviceState::DeviceStateInError, hr, true);
return hr;
}
#endif // ACTIVE_AUDIO_ASYNC
SetState(DeviceState::DeviceStateInitialized, hr, true);
return hr;
}
// To be called from the XAML thread
QWinRTScreen::QWinRTScreen()
: d_ptr(new QWinRTScreenPrivate)
{
Q_D(QWinRTScreen);
d->orientation = Qt::PrimaryOrientation;
d->touchDevice = Q_NULLPTR;
HRESULT hr;
ComPtr<Xaml::IWindowStatics> windowStatics;
hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_UI_Xaml_Window).Get(),
IID_PPV_ARGS(&windowStatics));
Q_ASSERT_SUCCEEDED(hr);
ComPtr<Xaml::IWindow> window;
hr = windowStatics->get_Current(&window);
Q_ASSERT_SUCCEEDED(hr);
hr = window->Activate();
Q_ASSERT_SUCCEEDED(hr);
hr = window->get_CoreWindow(&d->coreWindow);
Q_ASSERT_SUCCEEDED(hr);
hr = d->coreWindow->Activate();
Q_ASSERT_SUCCEEDED(hr);
Rect rect;
hr = d->coreWindow->get_Bounds(&rect);
Q_ASSERT_SUCCEEDED(hr);
d->logicalSize = QSizeF(rect.Width, rect.Height);
// Orientation handling
ComPtr<IDisplayInformationStatics> displayInformationStatics;
hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Graphics_Display_DisplayInformation).Get(),
IID_PPV_ARGS(&displayInformationStatics));
Q_ASSERT_SUCCEEDED(hr);
hr = displayInformationStatics->GetForCurrentView(&d->displayInformation);
Q_ASSERT_SUCCEEDED(hr);
// Set native orientation
DisplayOrientations displayOrientation;
hr = d->displayInformation->get_NativeOrientation(&displayOrientation);
Q_ASSERT_SUCCEEDED(hr);
d->nativeOrientation = static_cast<Qt::ScreenOrientation>(static_cast<int>(qtOrientationsFromNative(displayOrientation)));
// Set initial pixel density
onDpiChanged(Q_NULLPTR, Q_NULLPTR);
d->orientation = d->nativeOrientation;
ComPtr<IApplicationViewStatics2> applicationViewStatics;
hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_UI_ViewManagement_ApplicationView).Get(),
IID_PPV_ARGS(&applicationViewStatics));
RETURN_VOID_IF_FAILED("Could not get ApplicationViewStatics");
hr = applicationViewStatics->GetForCurrentView(&d->view);
RETURN_VOID_IF_FAILED("Could not access currentView");
// Create a canvas and set it as the window content. Eventually, this should have its own method so multiple "screens" can be added
ComPtr<Xaml::Controls::ICanvas> canvas;
hr = RoActivateInstance(HString::MakeReference(RuntimeClass_Windows_UI_Xaml_Controls_Canvas).Get(), &canvas);
Q_ASSERT_SUCCEEDED(hr);
ComPtr<Xaml::IFrameworkElement> frameworkElement;
hr = canvas.As(&frameworkElement);
Q_ASSERT_SUCCEEDED(hr);
hr = frameworkElement->put_Width(d->logicalSize.width());
Q_ASSERT_SUCCEEDED(hr);
hr = frameworkElement->put_Height(d->logicalSize.height());
Q_ASSERT_SUCCEEDED(hr);
ComPtr<Xaml::IUIElement> uiElement;
hr = canvas.As(&uiElement);
Q_ASSERT_SUCCEEDED(hr);
hr = window->put_Content(uiElement.Get());
Q_ASSERT_SUCCEEDED(hr);
hr = canvas.As(&d->canvas);
Q_ASSERT_SUCCEEDED(hr);
d->cursor.reset(new QWinRTCursor);
#ifdef Q_OS_WINPHONE
ComPtr<IStatusBarStatics> statusBarStatics;
hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_UI_ViewManagement_StatusBar).Get(),
IID_PPV_ARGS(&statusBarStatics));
Q_ASSERT_SUCCEEDED(hr);
hr = statusBarStatics->GetForCurrentView(&d->statusBar);
Q_ASSERT_SUCCEEDED(hr);
#endif // Q_OS_WINPHONE
}
HRESULT HDMediaSource::SelectStreams(IMFPresentationDescriptor* ppd,const PROPVARIANT& varStartPosition,bool seek,bool sendstart)
{
_nPendingEOS = 0;
unsigned count = _streamList.Count();
for (unsigned i = 0;i < count;i++)
{
BOOL fSelected = FALSE;
ComPtr<IMFStreamDescriptor> psd;
HRESULT hr = ppd->GetStreamDescriptorByIndex(i,&fSelected,psd.GetAddressOf());
if (FAILED(hr))
return hr;
DWORD dwStreamId = 0xFFFFFFFF;
hr = psd->GetStreamIdentifier(&dwStreamId);
if (FAILED(hr))
return hr;
if (dwStreamId == 0xFFFFFFFF)
continue;
ComPtr<HDMediaStream> pStream;
hr = FindMediaStreamById((int)dwStreamId,pStream.GetAddressOf());
if (FAILED(hr))
return hr;
if (seek)
pStream->DisablePrivateData();
else
pStream->EnablePrivateData();
BOOL fWasSelected = pStream->IsActive();
pStream->Activate(!!fSelected);
if (fSelected)
{
_nPendingEOS++;
hr = _pEventQueue->QueueEventParamUnk(fWasSelected ? MEUpdatedStream:MENewStream,
GUID_NULL,S_OK,pStream.Get());
if (FAILED(hr))
return hr;
if (sendstart) {
hr = pStream->Start(varStartPosition,seek);
if (FAILED(hr))
return hr;
}
if (_network_mode)
pStream->SetPrerollTime(_network_preroll_time);
}
}
DbgLogPrintf(L"%s::DoStart->SelectStreams %d.",L"HDMediaSource",_nPendingEOS);
return S_OK;
}
