/** * Closes the given display. * * @pre disp is a display we know about. * @post disp has been removed from the list of displays * (notifyDrawMgr == true) && (drawMgr != NULL) && (disp is active) * ==> Draw manager has been told to clode the window for the display */ int DisplayManager::closeDisplay(DisplayPtr disp, bool notifyDrawMgr) { vprASSERT(isMemberDisplay(disp)); // Make sure that display actually exists vprDEBUG(vrjDBG_DISP_MGR, vprDBG_STATE_LVL) << "[vrj::DisplayManager::closeDisplay()] Closing display named '" << disp->getName() << "'" << std::endl << vprDEBUG_FLUSH; // Notify the draw manager to get rid of it // Note: if it is not active, then the draw manager doesn't know about it if ((notifyDrawMgr) && (mDrawManager != NULL) && (disp->isActive())) { mDrawManager->removeDisplay(disp); } // Remove it from local data structures size_t num_before_close = mActiveDisplays.size() + mInactiveDisplays.size(); mActiveDisplays.erase( std::remove(mActiveDisplays.begin(), mActiveDisplays.end(), disp), mActiveDisplays.end()); mInactiveDisplays.erase( std::remove(mInactiveDisplays.begin(), mInactiveDisplays.end(), disp), mInactiveDisplays.end()); vprASSERT(num_before_close == (1+mActiveDisplays.size() + mInactiveDisplays.size())); boost::ignore_unused_variable_warning(num_before_close); return 1; }
/** * Adds the element to the configuration. * * @pre configCanHandle(element) == true * @post (display of same name already loaded) ==> old display closed, new one opened<br> * (display is new) ==> (new display is added)<br> * Draw Manager is notified of the display change. */ bool DisplayManager::configAddDisplay(jccl::ConfigElementPtr element) { vprASSERT(configCanHandle(element)); // We must be able to handle it first of all vprDEBUG_BEGIN(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "------- DisplayManager::configAddDisplay -------\n" << vprDEBUG_FLUSH; // Find out if we already have a window of this name // If so, then close it before we open a new one of the same name // This basically allows re-configuration of a window DisplayPtr cur_disp = findDisplayNamed(element->getName()); if (cur_disp != NULL) // We have an old display { vprDEBUG(vrjDBG_DISP_MGR,vprDBG_CONFIG_LVL) << "Removing old window: " << cur_disp->getName().c_str() << vprDEBUG_FLUSH; closeDisplay(cur_disp,true); // Close the display and notify the draw manager to close the window } // --- Add a display (of the correct type) ---- // if (element->getID() == std::string("display_window")) // Display window { DisplayPtr newDisp = Display::create(); // Create the display newDisp->config(element); addDisplay(newDisp,true); // Add it vprDEBUG(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "Adding display: " << newDisp->getName().c_str() << std::endl << vprDEBUG_FLUSH; vprDEBUG(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "Display: " << newDisp << std::endl << vprDEBUG_FLUSH; } vprDEBUG_END(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "------- DisplayManager::configAddDisplay Done. --------\n" << vprDEBUG_FLUSH; return true; }
// notifyDrawMgr = 0; Defaults to 0 int DisplayManager::addDisplay(DisplayPtr disp, bool notifyDrawMgr) { vprDEBUG(vrjDBG_DISP_MGR, vprDBG_VERB_LVL) << "vrj::DisplayManager::addDisplay()\n" << vprDEBUG_FLUSH; // Test if active or not, to determine correct list // The place it in the list // --- Update Local Display structures if (disp->isActive()) { mActiveDisplays.push_back(disp); } else { mInactiveDisplays.push_back(disp); } // If we are supposed to notify about, and valid draw mgr, and disp is active if ((notifyDrawMgr) && (mDrawManager != NULL) && (disp->isActive())) { mDrawManager->addDisplay(disp);; // Tell Draw Manager to add dislay; } return 1; }
IECore::ConstCompoundObjectPtr Displays::computeProcessedGlobals( const Gaffer::Context *context, IECore::ConstCompoundObjectPtr inputGlobals ) const { const CompoundPlug *dsp = displaysPlug(); if( !dsp->children().size() ) { return inputGlobals; } CompoundObjectPtr result = inputGlobals->copy(); // add our displays to the result for( InputCompoundPlugIterator it( dsp ); it != it.end(); it++ ) { const CompoundPlug *displayPlug = *it; if( displayPlug->getChild<BoolPlug>( "active" )->getValue() ) { std::string name = displayPlug->getChild<StringPlug>( "name" )->getValue(); std::string type = displayPlug->getChild<StringPlug>( "type" )->getValue(); std::string data = displayPlug->getChild<StringPlug>( "data" )->getValue(); if( name.size() && type.size() && data.size() ) { DisplayPtr d = new Display( name, type, data ); displayPlug->getChild<CompoundDataPlug>( "parameters" )->fillCompoundData( d->parameters() ); result->members()["display:" + name] = d; } } } return result; }
ImagePtr VaapiImage::create(const DisplayPtr& display, uint32_t format, uint32_t width, uint32_t height) { ImagePtr image; VAStatus status; if (!display || !width || !height) return image; DEBUG_FOURCC("create image with fourcc: ", format); const VAImageFormat *vaFormat = display->getVaFormat(format); if (!vaFormat) { ERROR("Create image failed, not supported fourcc"); return image; } VAImagePtr vaImage(new VAImage); status = vaCreateImage(display->getID(), vaFormat, width, height, vaImage.get()); if (status != VA_STATUS_SUCCESS || vaImage->format.fourcc != vaFormat->fourcc) { ERROR("fourcc mismatch wated = 0x%x, got = 0x%x", vaFormat->fourcc, vaImage->format.fourcc); return image; } image.reset(new VaapiImage(display, vaImage)); return image; }
/** * Callback when display is added to display manager. * @pre Must be in kernel controlling thread. * @note This function can only be called by the display manager * functioning on behalf of a thread the holds the kernel * reconfiguration lock. * This guarantees that we are not rendering currently. * We will most likely be waiting for a render trigger. */ void D3dDrawManager::addDisplay(DisplayPtr disp) { vprASSERT(disp != NULL); // Can't add a null display vprDEBUG(vrjDBG_DRAW_MGR, 0) << "========= vrj::D3dDrawManager::addDisplay: " << disp << std::endl << vprDEBUG_FLUSH; // -- Finish Simulator setup std::vector<vrj::Viewport*>::size_type num_vp(disp->getNumViewports()); std::vector<vrj::Viewport*>::size_type i; for ( i = 0 ; i < num_vp ; ++i ) { Viewport* vp = disp->getViewport(i); if (vp->isSimulator()) { jccl::ConfigElementPtr vp_element = vp->getConfigElement(); SimViewport* sim_vp(NULL); sim_vp = dynamic_cast<SimViewport*>(vp); vprASSERT(NULL != sim_vp); sim_vp->setDrawSimInterface(DrawSimInterfacePtr()); // Create the simulator stuff vprASSERT(1 == vp_element->getNum("simulator_plugin") && "You must supply a simulator plugin."); // Create the simulator stuff jccl::ConfigElementPtr sim_element = vp_element->getProperty<jccl::ConfigElementPtr>("simulator_plugin"); vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL) << "D3dDrawManager::addDisplay() creating simulator of type '" << sim_element->getID() << "'\n" << vprDEBUG_FLUSH; DrawSimInterfacePtr new_sim_i( D3dSimInterfaceFactory::instance()->createObject(sim_element->getID()) ); // XXX: Change this to an error once the new simulator loading code is // more robust. -PH (4/13/2003) vprASSERT(NULL != new_sim_i.get() && "Failed to create draw simulator"); sim_vp->setDrawSimInterface(new_sim_i); new_sim_i->initialize(sim_vp); new_sim_i->config(sim_element); } } // -- Create a window for new display // -- Store the window in the wins vector // Create the gl window object. NOTE: The glPipe actually "creates" the opengl window and context later D3dWindow* new_win = new D3dWindow(); new_win->configWindow(disp); // Configure it mNewWins.push_back(new_win); // Add to our local window list //vprASSERT(isValidWindow(new_win)); // Make sure it was added to draw manager }
ImageRawPtr VaapiImageRaw::create(const DisplayPtr& display, const ImagePtr& image, VideoDataMemoryType memoryType) { ImageRawPtr raw; RealeaseCallback release; uintptr_t handle; VAStatus status; VAImagePtr& vaImage = image->m_image; if (memoryType == VIDEO_DATA_MEMORY_TYPE_RAW_POINTER || memoryType == VIDEO_DATA_MEMORY_TYPE_RAW_COPY) { void* data; status = vaMapBuffer(display->getID(), vaImage->buf, &data); release = vaUnmapBuffer; handle = (uintptr_t)data; } else { VABufferInfo bufferInfo; if (memoryType == VIDEO_DATA_MEMORY_TYPE_DRM_NAME) bufferInfo.mem_type = VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM; else if (memoryType == VIDEO_DATA_MEMORY_TYPE_DMA_BUF) bufferInfo.mem_type = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME; else ASSERT(0); status = vaAcquireBufferHandle(display->getID(), vaImage->buf, &bufferInfo); release = vaReleaseBufferHandle; handle = (uintptr_t)bufferInfo.handle; } if (!checkVaapiStatus(status, "VaapiImageRaw::create()")) return raw; raw.reset(new VaapiImageRaw(display, image, memoryType, handle, release)); return raw; }
DisplayPtr DisplayCache::createDisplay(const NativeDisplay& nativeDisplay) { NativeDisplayPtr nativeDisplayObj; VADisplay vaDisplay = NULL; DisplayPtr vaapiDisplay; YamiMediaCodec::AutoLock locker(m_lock); m_cache.remove_if(expired); //lockup first list<weak_ptr<VaapiDisplay> >::iterator it; for (it = m_cache.begin(); it != m_cache.end(); ++it) { vaapiDisplay = (*it).lock(); if (vaapiDisplay->isCompatible(nativeDisplay)) { return vaapiDisplay; } } vaapiDisplay.reset(); //crate new one DEBUG("nativeDisplay: (type : %d), (handle : 0x%x)", nativeDisplay.type, nativeDisplay.handle); switch (nativeDisplay.type) { case NATIVE_DISPLAY_AUTO: #if __ENABLE_X11__ case NATIVE_DISPLAY_X11: nativeDisplayObj.reset (new NativeDisplayX11()); if (nativeDisplayObj && nativeDisplayObj->initialize(nativeDisplay)) vaDisplay = vaGetDisplay((Display*)(nativeDisplayObj->nativeHandle())); if (vaDisplay) INFO("use vaapi x11 backend"); if(vaDisplay || nativeDisplay.type == NATIVE_DISPLAY_X11) break; INFO("try to init va with x11 display (%p) but failed", (Display*)(nativeDisplayObj->nativeHandle())); // NATIVE_DISPLAY_AUTO continue, no break #endif case NATIVE_DISPLAY_DRM: nativeDisplayObj.reset (new NativeDisplayDrm()); if (nativeDisplayObj && nativeDisplayObj->initialize(nativeDisplay)) vaDisplay = vaGetDisplayDRM(nativeDisplayObj->nativeHandle()); INFO("use vaapi drm backend"); break; default: break; } if (vaDisplay == NULL) { ERROR("vaGetDisplay failed."); return vaapiDisplay; } if (vaInit(vaDisplay)) vaapiDisplay.reset(new VaapiDisplay(nativeDisplayObj, vaDisplay)); if (vaapiDisplay) { weak_ptr<VaapiDisplay> weak(vaapiDisplay); m_cache.push_back(weak); } return vaapiDisplay; }
IECore::ConstCompoundObjectPtr Outputs::computeProcessedGlobals( const Gaffer::Context *context, IECore::ConstCompoundObjectPtr inputGlobals ) const { const CompoundPlug *dsp = outputsPlug(); if( !dsp->children().size() ) { return inputGlobals; } IECore::CompoundObjectPtr result = new IECore::CompoundObject; // Since we're not going to modify any existing members (only add new ones), // and our result becomes const on returning it, we can directly reference // the input members in our result without copying. Be careful not to modify // them though! result->members() = inputGlobals->members(); // add our outputs to the result for( InputCompoundPlugIterator it( dsp ); it != it.end(); it++ ) { const CompoundPlug *outputPlug = it->get(); if( outputPlug->getChild<BoolPlug>( "active" )->getValue() ) { // backwards compatibility with old plug layout const StringPlug *namePlug = outputPlug->getChild<StringPlug>( "label" ); if( !namePlug ) { namePlug = outputPlug->getChild<StringPlug>( "name" ); } const std::string name = namePlug->getValue(); const StringPlug *fileNamePlug = outputPlug->getChild<StringPlug>( "fileName" ); if( !fileNamePlug ) { // backwards compatibility with old plug layout fileNamePlug = outputPlug->getChild<StringPlug>( "name" ); } const std::string fileName = fileNamePlug->getValue(); const std::string type = outputPlug->getChild<StringPlug>( "type" )->getValue(); const std::string data = outputPlug->getChild<StringPlug>( "data" )->getValue(); if( name.size() && fileName.size() && type.size() && data.size() ) { DisplayPtr d = new Display( fileName, type, data ); outputPlug->getChild<CompoundDataPlug>( "parameters" )->fillCompoundData( d->parameters() ); result->members()["output:" + name] = d; } } } return result; }
void DisplayRenderTargetGeometry::RenderBegin() { //DevicePtr pDevice = m_rDisplay.GetDevicePtr(); //pDevice->GetStreamSource(0, &m_pPreviousVertexBuffer, &m_uPreviousVBOffset, &m_uPreviousVBStride); //pDevice->GetVertexDeclaration(&m_pPreviousVertexDecl); //if (m_pPreviousVertexDecl != m_uVertexDecl) //{ // pDevice->SetVertexDeclaration(m_uVertexDecl); //} DisplayPtr pDisplay = Display::GetInstance(); if (m_uVertexDecl != pDisplay->GetCurrentVertexDeclaration()) { pDisplay->SetVertexDeclaration(m_uVertexDecl); } }
ImagePtr VaapiImage::derive(const SurfacePtr& surface) { ImagePtr image; if (!surface) return image; DisplayPtr display = surface->getDisplay(); VAImagePtr vaImage(new VAImage); VAStatus status = vaDeriveImage(display->getID(), surface->getID(), vaImage.get()); if (!checkVaapiStatus(status, "vaDeriveImage()")) { return image; } image.reset(new VaapiImage(display, surface, vaImage)); return image; }
void DisplayMaterial::Render() { m_pEffect->SetTechnique(m_hTechnique); #if 0 for_each(m_vRenderList.begin(), m_vRenderList.end(), RenderObjectFunction(this)); #else DisplayPtr pDisplay = Display::GetInstance(); DisplayStateManagerPtr pStateManager = pDisplay->GetStateManagerInterface(); EffectPtr pEffect = GetEffect()->GetEffect(); size_t uCount = m_vRenderList.size(); UInt uPassCount; UInt uChangeCount; UInt uDuplicateCount; pEffect->Begin(&uPassCount, EFFECT_RENDER_FLAGS); for (UInt uPass = 0 ; uPass < uPassCount ; ++uPass) { pDisplay->MRTRenderBeginPass(uPass); pStateManager->BeginPass(uPass); pEffect->BeginPass(uPass); for (size_t i = 0 ; uCount > i ; ++i) { DisplayObjectPtr pDisplayObject = m_vRenderList[i]; pDisplayObject->RenderBegin(); pDisplay->SetCurrentWorldMatrix(pDisplayObject->GetWorldMatrix()); UseParams(); pEffect->CommitChanges(); pDisplayObject->Render(); pDisplayObject->RenderEnd(); } pEffect->EndPass(); pStateManager->EndPass(uChangeCount, uDuplicateCount); pDisplay->MRTRenderEndPass(); } pEffect->End(); #endif m_vRenderList.clear(); }
BufObjectPtr VaapiBufObject::create(const ContextPtr& context, VABufferType bufType, uint32_t size, const void *data, void **mapped_data) { BufObjectPtr buf; if (size == 0) { ERROR("buffer size is zero"); return buf; } DisplayPtr display = context->getDisplay(); VABufferID bufID; if (!vaapiCreateBuffer(display->getID(), context->getID(), bufType, size, data, &bufID, mapped_data)) { ERROR("create buffer failed"); return buf; } void *mapped = mapped_data ? *mapped_data : NULL; buf.reset(new VaapiBufObject(display, bufID, mapped, size)); return buf; }
VaapiDecSurfacePool::VaapiDecSurfacePool(const DisplayPtr& display, std::vector<SurfacePtr> surfaces): m_cond(m_lock), m_flushing(false) { size_t size = surfaces.size(); m_surfaces.swap(surfaces); m_renderBuffers.resize(size); for (size_t i = 0; i < size; ++i) { const SurfacePtr& s = m_surfaces[i]; VASurfaceID id = m_surfaces[i]->getID(); m_renderBuffers[i].display = display->getID(); m_renderBuffers[i].surface = id; m_renderBuffers[i].timeStamp = 0; m_renderMap[id] = &m_renderBuffers[i]; m_surfaceMap[id] = s.get(); m_freed.push_back(id); } }
SurfacePtr VaapiSurface::create(const DisplayPtr& display, VaapiChromaType chromaType, uint32_t width, uint32_t height, void *surfAttribArray, uint32_t surfAttribNum) { VAStatus status; uint32_t format, i; VASurfaceAttrib *surfAttribs = (VASurfaceAttrib *) surfAttribArray; SurfacePtr surface; VASurfaceID id; assert((surfAttribs && surfAttribNum) || (!surfAttribs && !surfAttribNum)); format = vaapiChromaToVaChroma(chromaType); uint32_t externalBufHandle = 0; status = vaCreateSurfaces(display->getID(), format, width, height, &id, 1, surfAttribs, surfAttribNum); if (!checkVaapiStatus(status, "vaCreateSurfacesWithAttribute()")) return surface; for (int i = 0; i < surfAttribNum; i++) { if (surfAttribs[i].type == VASurfaceAttribExternalBufferDescriptor) { VASurfaceAttribExternalBuffers *surfAttribExtBuf = (VASurfaceAttribExternalBuffers *) surfAttribs[i].value. value.p; externalBufHandle = surfAttribExtBuf->buffers[0]; break; } } surface.reset(new VaapiSurface(display, id, chromaType, width, height,externalBufHandle)); return surface; }
bool isCompatible(const DisplayPtr display, const NativeDisplay& native) { return display->isCompatible(native); }