/** \fn init */ bool libvaRender::init( GUI_WindowInfo * window, uint32_t w, uint32_t h,renderZoom zoom) { ADM_info("[libva]Xv start\n"); info=*window; if(admLibVA::isOperationnal()==false) { ADM_warning("[libva] Not operationnal\n"); return false; } for(int i=0;i<2;i++) { VASurfaceID surface=admLibVA::allocateSurface(w,h); if(surface==VA_INVALID) { ADM_warning("[libva] cannot allocate surface\n"); return false; } mySurface[i]=new ADM_vaSurface(NULL,w,h); mySurface[i]->surface=surface; } baseInit(w,h,zoom); return true; }
sp<Retval> GdMonCpustat::draw(int num, sp<info>& info, sp<MonBase>& dest , const char* path) { sp<Retval> retval; if( DFW_RET(retval, MonCpustat::draw(num, info, dest, path)) ) return DFW_RETVAL_D(retval); if( DFW_RET(retval, baseInit()) ) return DFW_RETVAL_D(retval); struct max_st max; struct data_st dt; getMax(&max, info, m_g.cs.w); setData(&dt); drawHead(dest->m_sec, info->m_sec); uint64_t first_sec; uint64_t last_sec = dest->m_sec; for(int k=info->m_aLists.size(), dx=m_g.cr.ex; ((k>0)&&(dx>m_g.cr.sx));) { sp<GdMonCpustat> p = info->m_aLists.get(k-1); sp<GdMonCpustat> pp = info->m_aLists.get(k-2); procData(dx, &max, &dt, p, pp); drawData(dx, &dt); k--; dx--; first_sec = p->m_sec; } drawBottom(dest, &max, &dt); drawLast(first_sec, last_sec); if( DFW_RET(retval, savePng(path, savename(), 0)) ) return DFW_RETVAL_D(retval); return NULL; }
/** \brief Create a mixer object * * The mixer will be initialized with default values: scaling of all * axes is set to 1.0, offsets of throttle, spoiler, retract are set to 0.5. * Mixers are enabled but not effective. */ T_TX_Mixer::T_TX_Mixer(T_TX_Interface *parent) { baseInit(parent); #if DEBUG_TX_INTERFACE > 0 printf("T_TX_Mixer::T_TX_Mixer()\n"); #endif }
/** \fn changeZoom */ bool simpleRender::init( GUI_WindowInfo * window, uint32_t w, uint32_t h,renderZoom zoom) { info=*window; baseInit(w,h,zoom); ADM_info("init, simple render. w=%d, h=%d,zoom=%d\n",(int)w,(int)h,(int)zoom); allocateStuff(); return true; }
void AIEntity::init(Brain* _Brain, Weapon* _weapon, AbstractFactoryBase<Entity>* _damageSprayFactory, Skin* _skin) { assert(!mBrain); mBrain = _Brain; weapon = _weapon; mBrain->setEntity(this); damageSprayFactory = _damageSprayFactory; baseInit(_skin); }
/** \brief Create and initialize a mixer object * * The mixer will be initialized from the given child * in the SimpleXMLTransfer. This does the same as if you * would call <code>T_TX_Mixer::init(cfg, child)</code> * after calling the empty constructor. * * \param cfg Pointer to an XML tree containing the config info. * \param child The name of the child which holds the mixer info. */ T_TX_Mixer::T_TX_Mixer(T_TX_Interface *parent, SimpleXMLTransfer* cfg, std::string child) { baseInit(parent); #if DEBUG_TX_INTERFACE > 0 printf("T_TX_Mixer::T_TX_Mixer(cfg, child)\n"); #endif init(cfg, child); }
/** \fn init */ bool vdpauRender::init( GUI_WindowInfo *window, uint32_t w, uint32_t h, float zoom) { if(!w || !h) { ADM_info("[VDPAU] Not trying to initialize with zero size dimensions\n"); return false; } ADM_info("[Vdpau]Init\n"); info=*window; if(admVdpau::isOperationnal()==false) { ADM_warning("[Vdpau] Not operationnal\n"); } baseInit(w,h,zoom); // Create couple of outputSurface surface[0]=surface[1]=VDP_INVALID_HANDLE; currentSurface=0; // int widthToUse=admVdpau::dimensionRoundUp(w); int heightToUse=admVdpau::dimensionRoundUp(h); ADM_info("[VDpau] Allocating surfaces %d x%d , %d x %d, %d x x%d\n",w,h,widthToUse,heightToUse,displayWidth,displayHeight); if(!reallocOutputSurface(displayWidth,displayHeight)) { goto badInit; } if(VDP_STATUS_OK!=admVdpau::surfaceCreate(widthToUse,heightToUse,&input)) { ADM_error("Cannot create input Surface\n"); goto badInit; } if(VDP_STATUS_OK!=admVdpau::presentationQueueCreate(&queue)) { ADM_error("Cannot create queue\n"); goto badInit; } if(VDP_STATUS_OK!=admVdpau::mixerCreate(widthToUse,heightToUse,&mixer)) { ADM_error("Cannot create mixer\n"); goto badInit; } return true; badInit: return false; }
void ControllerDirectRead::Init() { Release(); stringstream ss; //ss.str(""); //ss << "IsRealModel = " << IsRealModel << endl; //MFCConsole::Output(ss.str()); if (IsRealModel) { int virtualCamEnable = 1; if (SettingHelper::GetKeyInt("E2V", "Virtual_Cam_Enable", virtualCamEnable)) IsRealModel = virtualCamEnable == 0; } //ss.str(""); //ss << "IsRealModel = " << IsRealModel << endl; //MFCConsole::Output(ss.str()); //初始化E2V相机 if (IsRealModel) { int COLOR_TYPE_IS_GRAY = 1; SettingHelper::GetKeyInt("E2V", "COLOR_TYPE_IS_GRAY", COLOR_TYPE_IS_GRAY); if (COLOR_TYPE_IS_GRAY != 0) p_e2v = new E2VCameraDirectRead(4096, PhotoHeight, CV_8U, 0, PORT_A); else p_e2v = new E2VCameraDirectRead(4096, PhotoHeight, CV_8UC3, 0, PORT_A); if (!p_e2v->HasBeenInited) { //若初始化e2v_EV71YC1CCL4005BA0失败 //则删除已实例化的对象,切换为虚拟相机模式 if (p_e2v != NULL) { delete p_e2v; p_e2v = NULL; } e2vInited = false; } else e2vInited = true; } baseInit(); }
void TIMERONE::begin(uint32_t period,uint32_t prescaler) { NVIC_InitTypeDef NVIC_InitStructure; baseInit(period,prescaler); NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_IRQn;// NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;// NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;// NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); interrupt(DISABLE); stop(); }
/** \fn changeZoom */ bool dxvaRender::init( GUI_WindowInfo * window, uint32_t w, uint32_t h,renderZoom zoom) { ADM_info("Initializing dxva2/D3D render\n"); info=*window; baseInit(w,h,zoom); windowId=(HWND)window->systemWindowId; if(!d3dHandle) { ADM_warning("No D3DHandle\n"); return false; } if (ADM_FAILED(IDirect3D9_GetAdapterDisplayMode(d3dHandle, D3DADAPTER_DEFAULT, &displayMode))) { ADM_warning("Dxv2/D3D Render: Cannot get display mode\n"); return 0; } D3DCAPS9 deviceCapabilities; ADM_info("D3D Checking device capabilities\n"); if (ADM_FAILED(IDirect3D9_GetDeviceCaps(d3dHandle, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &deviceCapabilities))) { ADM_warning("Cannot get device capabilities"); return false; } int texture = deviceCapabilities.TextureCaps; ADM_info("Power of 2 : %d\n", (texture & D3DPTEXTURECAPS_POW2) && !(texture & D3DPTEXTURECAPS_NONPOW2CONDITIONAL)); ADM_info("Square only: %d\n", (texture & D3DPTEXTURECAPS_SQUAREONLY)); // Check if we support YV12 D3DFORMAT fmt=displayMode.Format; D3DFORMAT yv12=(D3DFORMAT)MAKEFOURCC('Y','V','1','2'); if (ADM_FAILED(IDirect3D9_CheckDeviceFormatConversion( d3dHandle, // adapter D3DADAPTER_DEFAULT, // device type D3DDEVTYPE_HAL, // adapter format yv12, // render target format fmt))) // depth stencil format { useYV12=false; ADM_info("D3D YV12 not supported\n"); } else { useYV12=true; ADM_info("D3D YV12 is supported\n"); } if(!setup()) { ADM_warning("Dxva/D3D setup failed\n"); return false; } videoWidget=(ADM_Qvideo *)info.widget; videoWidget->useExternalRedraw(true); // deactivate Qt Double buffering videoWidget->setDrawer(this); ADM_info("Dxva (D3D) init successful, dxva render. w=%d, h=%d,zoom=%d, displayWidth=%d, displayHeight=%d\n",(int)w,(int)h,(int)zoom,(int)displayWidth,(int)displayHeight); return true; }
LLNameValue::LLNameValue() { baseInit(); }
// data is in the format: // "NameValueName Type Class Data" LLNameValue::LLNameValue(const char *data) { baseInit(); static char name[NV_BUFFER_LEN]; /*Flawfinder: ignore*/ static char type[NV_BUFFER_LEN]; /*Flawfinder: ignore*/ static char nvclass[NV_BUFFER_LEN]; /*Flawfinder: ignore*/ static char nvsendto[NV_BUFFER_LEN]; /*Flawfinder: ignore*/ static char nvdata[NV_BUFFER_LEN]; /*Flawfinder: ignore*/ S32 i; S32 character_count = 0; S32 length = 0; // go to first non-whitespace character while (1) { if ( (*(data + character_count) == ' ') ||(*(data + character_count) == '\n') ||(*(data + character_count) == '\t') ||(*(data + character_count) == '\r')) { character_count++; } else { break; } } // read in the name sscanf((data + character_count), "%2047s", name); /*Flawfinder: ignore*/ // bump past it and add null terminator length = (S32)strlen(name); /* Flawfinder: ignore */ name[length] = 0; character_count += length; // go to the next non-whitespace character while (1) { if ( (*(data + character_count) == ' ') ||(*(data + character_count) == '\n') ||(*(data + character_count) == '\t') ||(*(data + character_count) == '\r')) { character_count++; } else { break; } } // read in the type sscanf((data + character_count), "%2047s", type); /*Flawfinder: ignore*/ // bump past it and add null terminator length = (S32)strlen(type); /* Flawfinder: ignore */ type[length] = 0; character_count += length; // go to the next non-whitespace character while (1) { if ( (*(data + character_count) == ' ') ||(*(data + character_count) == '\n') ||(*(data + character_count) == '\t') ||(*(data + character_count) == '\r')) { character_count++; } else { break; } } // do we have a type argument? for (i = NVC_READ_ONLY; i < NVC_EOF; i++) { if (!strncmp(NameValueClassStrings[i], data + character_count, strlen(NameValueClassStrings[i]))) /* Flawfinder: ignore */ { break; } } if (i != NVC_EOF) { // yes we do! // read in the class sscanf((data + character_count), "%2047s", nvclass); /*Flawfinder: ignore*/ // bump past it and add null terminator length = (S32)strlen(nvclass); /* Flawfinder: ignore */ nvclass[length] = 0; character_count += length; // go to the next non-whitespace character while (1) { if ( (*(data + character_count) == ' ') ||(*(data + character_count) == '\n') ||(*(data + character_count) == '\t') ||(*(data + character_count) == '\r')) { character_count++; } else { break; } } } else { // no type argument given, default to read-write strncpy(nvclass, "READ_WRITE", sizeof(nvclass) -1); /* Flawfinder: ignore */ nvclass[sizeof(nvclass) -1] = '\0'; } // Do we have a sendto argument? for (i = NVS_SIM; i < NVS_EOF; i++) { if (!strncmp(NameValueSendtoStrings[i], data + character_count, strlen(NameValueSendtoStrings[i]))) /* Flawfinder: ignore */ { break; } } if (i != NVS_EOF) { // found a sendto argument sscanf((data + character_count), "%2047s", nvsendto); /*Flawfinder: ignore*/ // add null terminator length = (S32)strlen(nvsendto); /* Flawfinder: ignore */ nvsendto[length] = 0; character_count += length; // seek to next non-whitespace characer while (1) { if ( (*(data + character_count) == ' ') ||(*(data + character_count) == '\n') ||(*(data + character_count) == '\t') ||(*(data + character_count) == '\r')) { character_count++; } else { break; } } } else { // no sendto argument given, default to sim only strncpy(nvsendto, "SIM", sizeof(nvsendto) -1); /* Flawfinder: ignore */ nvsendto[sizeof(nvsendto) -1] ='\0'; } // copy the rest character by character into data length = 0; while ( (*(nvdata + length++) = *(data + character_count++)) ) ; init(name, nvdata, type, nvclass, nvsendto); }
// Initialize without any initial data. LLNameValue::LLNameValue(const char *name, const char *type, const char *nvclass) { baseInit(); mName = mNVNameTable->addString(name); // Nota Bene: Whatever global structure manages this should have these in the name table already! mStringType = mNVNameTable->addString(type); if (!strcmp(mStringType, "STRING")) { mType = NVT_STRING; mNameValueReference.string = NULL; } else if (!strcmp(mStringType, "F32")) { mType = NVT_F32; mNameValueReference.f32 = NULL; } else if (!strcmp(mStringType, "S32")) { mType = NVT_S32; mNameValueReference.s32 = NULL; } else if (!strcmp(mStringType, "VEC3")) { mType = NVT_VEC3; mNameValueReference.vec3 = NULL; } else if (!strcmp(mStringType, "U32")) { mType = NVT_U32; mNameValueReference.u32 = NULL; } else if (!strcmp(mStringType, "U64")) { mType = NVT_U64; mNameValueReference.u64 = NULL; } else if(!strcmp(mStringType, (const char*)NameValueTypeStrings[NVT_ASSET])) { mType = NVT_ASSET; mNameValueReference.string = NULL; } else { mType = NVT_NULL; llinfos << "Unknown name-value type " << mStringType << llendl; } // Nota Bene: Whatever global structure manages this should have these in the name table already! mStringClass = mNVNameTable->addString(nvclass); if (!strcmp(mStringClass, "READ_ONLY")) { mClass = NVC_READ_ONLY; } else if (!strcmp(mStringClass, "READ_WRITE")) { mClass = NVC_READ_WRITE; } else { mClass = NVC_NULL; } // Initialize the sendto variable mStringSendto = mNVNameTable->addString("SIM"); mSendto = NVS_SIM; }
LLNameValue::LLNameValue(const char *name, const char *data, const char *type, const char *nvclass, const char *nvsendto) { baseInit(); init(name, data, type, nvclass, nvsendto); }
LLNameValue::LLNameValue(const char *name, const char *data, const char *type, const char *nvclass) { baseInit(); // if not specified, send to simulator only init(name, data, type, nvclass, "SIM"); }
void SceneBase::start() { baseInit(); run(); }
/** * Initializes a file object but does *not* open the file on the guest * yet. This is done in the dedidcated openFile call. * * @return IPRT status code. * @param pConsole Pointer to console object. * @param pSession Pointer to session object. * @param uFileID Host-based file ID (part of the context ID). * @param openInfo File opening information. */ int GuestFile::init(Console *pConsole, GuestSession *pSession, ULONG uFileID, const GuestFileOpenInfo &openInfo) { LogFlowThisFunc(("pConsole=%p, pSession=%p, uFileID=%RU32, strPath=%s\n", pConsole, pSession, uFileID, openInfo.mFileName.c_str())); AssertPtrReturn(pConsole, VERR_INVALID_POINTER); AssertPtrReturn(pSession, VERR_INVALID_POINTER); /* Enclose the state transition NotReady->InInit->Ready. */ AutoInitSpan autoInitSpan(this); AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED); int vrc = bindToSession(pConsole, pSession, uFileID /* Object ID */); if (RT_SUCCESS(vrc)) { mSession = pSession; mData.mID = uFileID; mData.mInitialSize = 0; mData.mStatus = FileStatus_Undefined; mData.mOpenInfo = openInfo; unconst(mEventSource).createObject(); HRESULT hr = mEventSource->init(); if (FAILED(hr)) vrc = VERR_COM_UNEXPECTED; } if (RT_SUCCESS(vrc)) { try { GuestFileListener *pListener = new GuestFileListener(); ComObjPtr<GuestFileListenerImpl> thisListener; HRESULT hr = thisListener.createObject(); if (SUCCEEDED(hr)) hr = thisListener->init(pListener, this); if (SUCCEEDED(hr)) { com::SafeArray <VBoxEventType_T> eventTypes; eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged); eventTypes.push_back(VBoxEventType_OnGuestFileOffsetChanged); eventTypes.push_back(VBoxEventType_OnGuestFileRead); eventTypes.push_back(VBoxEventType_OnGuestFileWrite); hr = mEventSource->RegisterListener(thisListener, ComSafeArrayAsInParam(eventTypes), TRUE /* Active listener */); if (SUCCEEDED(hr)) { vrc = baseInit(); if (RT_SUCCESS(vrc)) { mLocalListener = thisListener; } } else vrc = VERR_COM_UNEXPECTED; } else vrc = VERR_COM_UNEXPECTED; } catch(std::bad_alloc &) { vrc = VERR_NO_MEMORY; } } if (RT_SUCCESS(vrc)) { /* Confirm a successful initialization when it's the case. */ autoInitSpan.setSucceeded(); } else autoInitSpan.setFailed(); LogFlowFuncLeaveRC(vrc); return vrc; }
/** \fn init */ bool sdlRenderImpl::init( GUI_WindowInfo * window, uint32_t w, uint32_t h,renderZoom zoom) { ADM_info("[SDL] Initializing video subsystem\n"); int bpp; int flags; baseInit(w,h,zoom); if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) { ADM_warning("[SDL] FAILED initialising video subsystem\n"); ADM_warning("[SDL] ERROR: %s\n", SDL_GetError()); return false; } ADM_info("[SDL] Video subsystem init ok\n"); sdl_running=true; ADM_info("[SDL] Creating window (at %x,%d)\n",window->x,window->y); int nbDriver=listOfSDLDrivers.size(); if(!nbDriver) { ADM_warning("[SDL] No driver loaded\n"); return false; } if(sdlDriverIndex==-1 || sdlDriverIndex>=nbDriver) { ADM_warning("[SDL] No available driver found\n"); return false; } #if 0 sdl_window = SDL_CreateWindow("avidemux_sdl2", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, w, h, SDL_WINDOW_BORDERLESS | SDL_WINDOW_FOREIGN*1); SDL_SetWindowPosition(sdl_window,window->x,window->y); #else sdl_window=SDL_CreateWindowFrom((void*)window->systemWindowId); #endif if(!sdl_window) { ADM_info("[SDL] Creating window failed!\n"); ADM_warning("[SDL] ERROR: %s\n", SDL_GetError()); cleanup(); return false; } sdl_renderer = SDL_CreateRenderer(sdl_window, sdlDriverIndex, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); if(!sdl_renderer) sdl_renderer = SDL_CreateRenderer(sdl_window, sdlDriverIndex, 0); if(!sdl_renderer) { ADM_warning("[SDL] FAILED to create a renderer\n"); cleanup(); return false; } sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, w, h); if(sdl_texture) { useYV12=true; }else { useYV12=false; sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, w, h); if(!sdl_texture) { ADM_warning("[SDL] FAILED to create a texture (rgb)\n"); cleanup(); return false; } } ADM_info("[SDL] Setting final size\n"); changeZoom(zoom); ADM_info("[SDL] All init done.\n"); return true; }