void Close()
{
// Stop Thread
fprintf(stderr,"* SPU2-X: Waiting for DSound thread to finish...");
dsound_running=false;
WaitForSingleObject(thread,INFINITE);
CloseHandle(thread);
fprintf(stderr," Done.\n");
//
// Clean up
//
if( buffer != NULL )
{
buffer->Stop();
for(u32 i=0;i<m_NumBuffers;i++)
{
if( buffer_events[i] != NULL )
CloseHandle(buffer_events[i]);
buffer_events[i] = NULL;
}
safe_release( buffer_notify );
safe_release( buffer );
}
safe_release( dsound );
CoUninitialize();
}
tstring print_log_info(ID3D11Resource* resource)
{
tstringstream ret;
ID3D11Texture2D* t2d;
if (SUCCEEDED(resource->QueryInterface(&t2d)))
{
D3D11_TEXTURE2D_DESC desc;
t2d->GetDesc(&desc);
safe_release(t2d);
ret << L" " << desc.Width << L"x" << desc.Height << L" " << (is_srgb(desc.Format) ? L"sRGB" : L"") << L"(F:" << desc.Format << L" M:" << desc.MipLevels << L")";
}
ID3D11Texture3D* t3d;
if (SUCCEEDED(resource->QueryInterface(&t3d)))
{
D3D11_TEXTURE3D_DESC desc;
t3d->GetDesc(&desc);
safe_release(t3d);
ret << L" " << desc.Width << L"x" << desc.Height << L"x" << desc.Depth << L" (F:" << desc.Format << L" M:" << desc.MipLevels << L")";
}
return ret.str();
}
bool UPNPCheckDlg::WinUPnP_add(const unsigned short port, const string& protocol, const string& description, IUPnPNAT* pUN)
{
#ifdef HAVE_NATUPNP_H
IStaticPortMappingCollection* pSPMC = WinUPnP_getStaticPortMappingCollection(pUN);
if (!pSPMC)
return false;
/// @todo use a BSTR wrapper
BSTR protocol_ = SysAllocString(Text::toT(protocol).c_str());
BSTR description_ = SysAllocString(Text::toT(description).c_str());
BSTR localIP = SysAllocString(Text::toT(Util::getLocalOrBindIp(false)).c_str());
IStaticPortMapping* pSPM = 0;
HRESULT hr = pSPMC->Add(port, protocol_, port, localIP, VARIANT_TRUE, description_, &pSPM);
SysFreeString(protocol_);
SysFreeString(description_);
SysFreeString(localIP);
bool ret = SUCCEEDED(hr);
if (ret)
{
safe_release(pSPM);
}
safe_release(pSPMC);
return ret;
#else
return false;
#endif
}
void obs_enum_audio_monitoring_devices(obs_enum_audio_device_cb cb,
void *data)
{
IMMDeviceEnumerator *enumerator = NULL;
IMMDeviceCollection *collection = NULL;
UINT count;
HRESULT hr;
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL,
&IID_IMMDeviceEnumerator, &enumerator);
if (FAILED(hr)) {
goto fail;
}
hr = enumerator->lpVtbl->EnumAudioEndpoints(enumerator, eRender,
DEVICE_STATE_ACTIVE, &collection);
if (FAILED(hr)) {
goto fail;
}
hr = collection->lpVtbl->GetCount(collection, &count);
if (FAILED(hr)) {
goto fail;
}
for (UINT i = 0; i < count; i++) {
if (!get_device_info(cb, data, collection, i)) {
break;
}
}
fail:
safe_release(enumerator);
safe_release(collection);
}
void ContentLayer::replaceTopNode(Layout *node, Transition *enterTransition, Transition *exitTransition) {
if (!_nodes.empty()) {
auto back = _nodes.back();
back->retain();
_nodes.popBack();
back->onPopTransitionBegan(this, false);
auto tit = _exitTransitions.find(back);
if (tit != _exitTransitions.end()) {
safe_retain(node);
safe_retain(enterTransition);
safe_retain(exitTransition);
back->runAction(action::callback(tit->second, [this, back, node, enterTransition, exitTransition] {
eraseNode(back);
back->onPop(this, false);
back->release();
pushNode(node, enterTransition, exitTransition);
safe_release(node);
safe_release(enterTransition);
safe_release(exitTransition);
}));
} else {
eraseNode(back);
back->onPop(this, false);
back->release();
pushNode(node, enterTransition, exitTransition);
}
}
}
//=============================================================================================================
void CGodRayRenderer9::UnloadContent()
{
safe_release(surfaces[0]);
safe_release(surfaces[1]);
safe_release(Occluders);
safe_release(Color);
memset(rendertargets, 0, sizeof(rendertargets));
CEffectRenderer9::UnloadContent();
}
void delta_sparse_voxel_octree::destroy()
{
// destroy other stuff first
sparse_voxel_octree::destroy();
safe_release(uav_v_delta_);
safe_release(srv_v_delta_);
safe_release(v_delta_);
inject_rsm_mu_start_slot_ = -1;
}
void D3DRenderWidget::d3dResize()
{
assert(m_d3dImmediateContext);
assert(m_d3dDevice);
assert(m_swapChain);
safe_release(m_renderTargetView);
safe_release(m_depthStencilView);
safe_release(m_depthStencilBuffer);
m_swapChain->ResizeBuffers(1, width(), height(), DXGI_FORMAT_R8G8B8A8_UNORM, 0);
ID3D11Texture2D* backBuffer;
m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer));
m_d3dDevice->CreateRenderTargetView(backBuffer, 0, &m_renderTargetView);
safe_release(backBuffer);
D3D11_TEXTURE2D_DESC depthStencilDesc;
depthStencilDesc.Width = width();
depthStencilDesc.Height = height();
depthStencilDesc.MipLevels = 1;
depthStencilDesc.ArraySize = 1;
depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
if (m_enable4xMsaa)
{
depthStencilDesc.SampleDesc.Count = 4;
depthStencilDesc.SampleDesc.Quality = m_4xMsaaQuality - 1;
}
else
{
depthStencilDesc.SampleDesc.Count = 1;
depthStencilDesc.SampleDesc.Quality = 0;
}
depthStencilDesc.Usage = D3D11_USAGE_DEFAULT;
depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthStencilDesc.CPUAccessFlags = 0;
depthStencilDesc.MiscFlags = 0;
m_d3dDevice->CreateTexture2D(&depthStencilDesc, 0, &m_depthStencilBuffer);
m_d3dDevice->CreateDepthStencilView(m_depthStencilBuffer, 0, &m_depthStencilView);
m_d3dImmediateContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
m_screenViewport.TopLeftX = 0;
m_screenViewport.TopLeftY = 0;
m_screenViewport.Width = static_cast<float>(width());
m_screenViewport.Height = static_cast<float>(height());
m_screenViewport.MinDepth = 0.0f;
m_screenViewport.MaxDepth = 1.0f;
m_d3dImmediateContext->RSSetViewports(1, &m_screenViewport);
}
void kinect_gbuffer::shutdown()
{
if (sensor_)
{
sensor_->NuiShutdown();
safe_release(sensor_);
}
if (kill_event_)
{
CloseHandle(kill_event_);
kill_event_ = nullptr;
}
if (color_event_)
{
CloseHandle(color_event_);
color_event_ = nullptr;
}
if (depth_event_)
{
CloseHandle(depth_event_);
depth_event_ = nullptr;
}
DeleteCriticalSection(&cs_color_);
DeleteCriticalSection(&cs_depth_);
}
void texture_cache::destroy()
{
for (auto i = texture_cache_.begin(); i != texture_cache_.end(); ++i)
safe_release(i->second);
texture_cache_.clear();
}
static inline void audio_monitor_free(struct audio_monitor *monitor)
{
if (monitor->source) {
obs_source_remove_audio_capture_callback(
monitor->source, on_audio_playback, monitor);
}
if (monitor->client)
monitor->client->lpVtbl->Stop(monitor->client);
safe_release(monitor->device);
safe_release(monitor->client);
safe_release(monitor->render);
audio_resampler_destroy(monitor->resampler);
circlebuf_free(&monitor->delay_buffer);
da_free(monitor->buf);
}
tstring print_log_info(ID3D11ShaderResourceView* srv)
{
ID3D11Resource* resource;
srv->GetResource(&resource);
tstring ret = print_log_info(resource);
safe_release(resource);
return ret;
}
static bool get_device_info(obs_enum_audio_device_cb cb, void *data,
IMMDeviceCollection *collection, UINT idx)
{
IPropertyStore *store = NULL;
IMMDevice *device = NULL;
PROPVARIANT name_var;
char utf8_name[512];
WCHAR *w_id = NULL;
char utf8_id[512];
bool cont = true;
HRESULT hr;
hr = collection->lpVtbl->Item(collection, idx, &device);
if (FAILED(hr)) {
goto fail;
}
hr = device->lpVtbl->GetId(device, &w_id);
if (FAILED(hr)) {
goto fail;
}
hr = device->lpVtbl->OpenPropertyStore(device, STGM_READ, &store);
if (FAILED(hr)) {
goto fail;
}
PropVariantInit(&name_var);
hr = store->lpVtbl->GetValue(store, &PKEY_Device_FriendlyName,
&name_var);
if (FAILED(hr)) {
goto fail;
}
os_wcs_to_utf8(w_id, 0, utf8_id, 512);
os_wcs_to_utf8(name_var.pwszVal, 0, utf8_name, 512);
cont = cb(data, utf8_name, utf8_id);
fail:
safe_release(store);
safe_release(device);
if (w_id)
CoTaskMemFree(w_id);
return cont;
}
void Texture::destroy()
{
mDev = nullptr;
mCtx = nullptr;
mUsage = EUsage::DynamicShaderResource;
mFormat = DXGI_FORMAT_UNKNOWN;
mDimension = EDimension::Texture_2D;
mWidth = 0;
mHeight = 0;
mDepth = 0;
mArraySize = 0;
mMipLevels = 1;
mMultiSampleCount = 1;
mMultiSampleQuality = 0;
safe_delete(mImageCache);
safe_release(mSRV);
safe_release(mRTV);
safe_release(mDSV);
safe_release(mUAV);
safe_release(mTexture1D);
safe_release(mTexture2D);
safe_release(mTexture3D);
mIsImageCacheDirty = false;
mIsInitalized = false;
}
//=============================================================================================================
void CCausticsRenderer9::UnloadContent()
{
for( size_t i = 0; i < distancemaps.size(); ++i )
{
for( int j = 0; j < 12; ++j )
{
safe_release(distancemaps[i].surfaces[j]);
}
}
safe_release(photonsurface);
safe_release(shadowsurface);
for( int j = 0; j < 6; ++j )
safe_release(causticsurfaces[j]);
CEffectRenderer9::UnloadContent();
}
void DxFw::release()
{
safe_delete(mParticleSystemMgr);
safe_delete(mRenderer);
safe_delete(mResourceMgr);
safe_Release(mDevice);
safe_Release(mDirect3D);
safe_release(mInputSys);
}
void CBundle::PostStop(bool wasUnregistered, bool activatorError)
{
UnregisterServices();
ReleaseUsedServices();
m_context->DropListeners();
m_context->Finalize();
safe_release(m_context);
safe_release(m_activator);
VERBOSE("[%s] Unloading module", m_location.c_str());
m_module.Shutdown();
if(!wasUnregistered)
{
m_state = eBndlState_Resolved;
m_systemBundle->PostBundleEvent(this, eBndlEvntT_Stopped);
}
}
static CFPropertyListRef load_plist_from_path(const char * path)
{
CFURLRef url = NULL;
CFDataRef data = NULL;
CFStringRef err = NULL;
CFPropertyListRef plist = NULL;
url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)path, strlen(path),
false /* isDirectory */);
if (url == NULL) {
VERBOSE("failed to build CFURL for '%s'\n", path);
goto done;
}
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault,
url, &data, NULL, NULL, NULL)) {
VERBOSE("failed to read CFURL data for '%s'\n", path);
goto done;
}
/* Despite the name, this actually reads both binary and XML plists. */
plist = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,
data, kCFPropertyListImmutable, &err);
if (!plist) {
char errbuf[256];
CFStringGetCString(err, errbuf, sizeof(errbuf), kCFStringEncodingUTF8);
VERBOSE("plist parse error for '%s': %s\n",
path, errbuf);
}
done:
safe_release(err);
safe_release(url);
safe_release(data);
return plist;
}
//=============================================================================================================
void CGame10::ShutDown()
{
if( Graphics )
Graphics->ClearState();
safe_release(DepthStencil);
safe_release(DepthStencilView);
safe_release(RenderTargetView);
safe_release(SwapChain);
if( Graphics )
{
ULONG rc = Graphics->Release();
if( rc > 0 )
{
std::stringstream ss;
ss << "d3ddevice refcount == " << rc;
dnassert(, ss.str(), true);
}
else
{
void Player_::OnTopologyStatus(IMFMediaEventPtr pEvent)
{
UINT32 status;
THROW_IF_ERR(pEvent->GetUINT32(MF_EVENT_TOPOLOGY_STATUS, &status));
if (status == MF_TOPOSTATUS_READY)
{
safe_release(m_pVideoDisplay);
// Get the IMFVideoDisplayControl interface from EVR. This call is
// expected to fail if the media file does not have a video stream.
(void)MFGetService(m_pSession.Get(), MR_VIDEO_RENDER_SERVICE,
IID_PPV_ARGS(m_pVideoDisplay.GetAddressOf()));
static_cast<this_type&>(*this).process_event(ev::OpenComplete());
//StartPlayback();
}
}
D3DRenderWidget::~D3DRenderWidget()
{
safe_release(m_renderTargetView);
safe_release(m_depthStencilView);
safe_release(m_swapChain);
safe_release(m_depthStencilBuffer);
if (m_d3dImmediateContext)
m_d3dImmediateContext->ClearState();
safe_release(m_d3dImmediateContext);
safe_release(m_d3dDevice);
}
bool UPNPCheckDlg::WinUPnP_remove(const unsigned short port, const string& protocol, IUPnPNAT* pUN)
{
#ifdef HAVE_NATUPNP_H
IStaticPortMappingCollection* pSPMC = WinUPnP_getStaticPortMappingCollection(pUN);
if (!pSPMC)
return false;
/// @todo use a BSTR wrapper
BSTR protocol_ = SysAllocString(Text::toT(protocol).c_str());
HRESULT hr = pSPMC->Remove(port, protocol_);
safe_release(pSPMC);
SysFreeString(protocol_);
return SUCCEEDED(hr);
#else
return false;
#endif
}
void seq_tab_dialog::discard_device()
{
//safe_release(sampler_state_);
//safe_release(shader_res_view_);
//safe_release(cb_changes_every_frame_);
//safe_release(cb_change_on_resize_);
//safe_release(cb_never_changes_);
//safe_release(i_buffer_);
//safe_release(v_buffer_);
//safe_release(p_shader_);
//safe_release(input_layout_);
//safe_release(v_shader_);
// discard_swap_chain_dependent_resources();
safe_release(render_target_);
/* safe_release(dxgi_swap_chain_);
safe_release(d3d_context_);
safe_release(d3d_device_);
safe_release(dxgi_adapter_);
*/
}
LRESULT CAnimatedButton::onClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
// TODO тут всегда m_hWnd = NULL dcassert(m_hWnd);
if (m_pImage)
{
if (m_bInited)
{
m_pImage->UnregisterCallback(OnFrameChanged, (LPARAM)this);
m_pImage->DeleteBackDC(m_hBackDC);
}
safe_release(m_pImage);
}
if (m_hDC)
{
dcdrun(int l_res =)::ReleaseDC(m_hWnd, m_hDC);
// TODO dcassert(l_res);
m_hDC = nullptr;
}
return 0;
}
/* Initialise a Preferences object from the given pspec. This might be an
* SCPreferences AppID or it might be the path to a plist file.
*/
Preferences::Preferences(const char * pspec)
: m_pspec(pspec), m_plist(NULL), m_scpref(NULL)
{
/* Try to load this as a plist file first. The SCPreferences API does a
* bunch of work if it can't find the file, and we should avoid that unless
* we have a good idea that it's necessary.
*/
this->m_plist = load_plist_from_path(this->m_pspec.c_str());
if (this->m_plist) {
/* Loading a plist should always give you back a dictionary. */
ASSERT(CFDictionaryGetTypeID() == CFGetTypeID(this->m_plist));
VERBOSE("loaded plist %s\n", pspec);
return;
}
cf_typeref<CFStringRef> appname(cfstring_wrap(getprogname()));
cf_typeref<CFStringRef> appid(cfstring_wrap(this->m_pspec.c_str()));
this->m_scpref = SCPreferencesCreate(kCFAllocatorDefault, appname, appid);
if (this->m_scpref == NULL) {
return;
}
/* If there was no existing preferences file, SCError() should return
* kSCStatusNoConfigFile. We are only interested in reading preferences, so
* we want to fail if there's no existing config.
*/
if (SCError() != kSCStatusOK) {
safe_release(this->m_scpref);
}
if (this->m_scpref) {
VERBOSE("loaded SC preferences %s\n", pspec);
}
}
seq_tab_dialog::~seq_tab_dialog()
{
discard_device();
safe_release(d2d_factory_);
safe_release(write_factory_);
};
HRESULT create(IFilterGraph2* graph)
{
// FIXME: do not assert here -> result is RCP_E_CHANGED_MODE, which can be ignored
(CoInitialize(nullptr));
VARIANT name;
//LONGLONG start=MAXLONGLONG, stop=MAXLONGLONG;
devices.clear();
//create an enumerator for video input devices
ICreateDevEnum* dev_enum;
assert_hr(CoCreateInstance(CLSID_SystemDeviceEnum, nullptr, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&dev_enum));
IEnumMoniker* enum_moniker;
HRESULT hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &enum_moniker, 0);
// no devices
if (hr == S_FALSE)
return S_OK;
//get devices
IMoniker* moniker;
unsigned long dev_count;
const int MAX_DEVICES = 8;
assert_hr(enum_moniker->Next(MAX_DEVICES, &moniker, &dev_count));
for (size_t i=0; i < dev_count; ++i)
{
//get properties
IPropertyBag* pbag;
hr = moniker[i].BindToStorage(nullptr, nullptr, IID_IPropertyBag, (void**)&pbag);
if (hr >= 0)
{
VariantInit(&name);
//get the description
if(FAILED(pbag->Read(L"Description", &name, 0)))
hr = pbag->Read(L"FriendlyName", &name, 0);
if (SUCCEEDED(hr))
{
//Initialize the VideoDevice struct
video_device dev;
dev.name = name.bstrVal;
//add a filter for the device
if (SUCCEEDED(graph->AddSourceFilterForMoniker(moniker+i, 0, dev.name.c_str(), &dev.filter)))
devices.push_back(dev);
}
VariantClear(&name);
safe_release(pbag);
}
moniker[i].Release();
}
return S_OK;
}
void destroy()
{
safe_release(filter);
}
//=============================================================================================================
Game::~Game()
{
Clear();
safe_release(rendersurface);
}
RHI_RasterizerState::~RHI_RasterizerState()
{
safe_release(static_cast<ID3D11RasterizerState*>(m_buffer));
}
