static void check_renderbutton_framerate(RenderData *rd, ReportList *reports) { // to keep float framerates consistent between the codec dialog and frs/sec button. OSErr err; err = SCGetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings); CheckError(err, "SCGetInfo fr error", reports); if( (rd->frs_sec == 24 || rd->frs_sec == 30 || rd->frs_sec == 60) && (qtdata->gTemporalSettings.frameRate == 1571553 || qtdata->gTemporalSettings.frameRate == 1964113 || qtdata->gTemporalSettings.frameRate == 3928227)) { /* do nothing */ } else { if (rd->frs_sec_base > 0) qtdata->gTemporalSettings.frameRate = ((float)(rd->frs_sec << 16) / rd->frs_sec_base) ; } err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType, &qtdata->gTemporalSettings); CheckError( err, "SCSetInfo error", reports ); if(qtdata->gTemporalSettings.frameRate == 1571553) { // 23.98 fps qtdata->kVideoTimeScale = 24000; qtdata->duration = 1001; } else if (qtdata->gTemporalSettings.frameRate == 1964113) { // 29.97 fps qtdata->kVideoTimeScale = 30000; qtdata->duration = 1001; } else if (qtdata->gTemporalSettings.frameRate == 3928227) { // 59.94 fps qtdata->kVideoTimeScale = 60000; qtdata->duration = 1001; } else { qtdata->kVideoTimeScale = (qtdata->gTemporalSettings.frameRate >> 16) * 100; qtdata->duration = 100; } }
bool CEGLWrapper::ChooseConfig(EGLDisplay display, EGLint *configAttrs, EGLConfig *config) { EGLint configCount = 0; EGLConfig* configList = NULL; // Find out how many configurations suit our needs EGLBoolean eglStatus = eglChooseConfig(display, configAttrs, NULL, 0, &configCount); CheckError(); if (!eglStatus || !configCount) { CLog::Log(LOGERROR, "EGL failed to return any matching configurations: %i", configCount); return false; } // Allocate room for the list of matching configurations configList = (EGLConfig*)malloc(configCount * sizeof(EGLConfig)); if (!configList) { CLog::Log(LOGERROR, "EGL failure obtaining configuration list"); return false; } // Obtain the configuration list from EGL eglStatus = eglChooseConfig(display, configAttrs, configList, configCount, &configCount); CheckError(); if (!eglStatus || !configCount) { CLog::Log(LOGERROR, "EGL failed to populate configuration list: %d", eglStatus); return false; } // Select an EGL configuration that matches the native window *config = configList[0]; free(configList); return m_result == EGL_SUCCESS; }
int OWStatement::GetInteger( OCINumber* ppoData ) { sb4 nRetVal; CheckError( OCINumberToInt( hError, ppoData, (uword) sizeof(sb4), OCI_NUMBER_SIGNED, (dvoid *) &nRetVal ), hError ); return nRetVal; }
/* =================================== STEAM_BlockForResources Instruct the STEAM resource preload system to get the indicated resources and block until all are obtained. ***NOTE*** THIS BLOCKS (DUH) SO DON'T USE WANTONLY =================================== */ int STEAM_BlockForResources( const char *hintlist ) { int val = TRUE; #if STEAM_SYNCHRONIZED_PRELOADING { // val = SteamHintResourceNeed(hintlist, TRUE, &steamError); // Temporary implementation. val = SteamWaitForResources(hintlist, &steamError); CheckError(NULL, &steamError); } #endif return val; }
bool CEGLWrapper::CreateSurface(EGLDisplay display, EGLConfig config, EGLSurface *surface) { if (!surface || !m_nativeTypes) return false; EGLNativeWindowType *nativeWindow=NULL; if (!m_nativeTypes->GetNativeWindow((XBNativeWindowType**)&nativeWindow)) return false; *surface = eglCreateWindowSurface(display, config, *nativeWindow, NULL); CheckError(); return *surface != EGL_NO_SURFACE; }
/* =================================== STEAM_ResumeResourcePreloading Resume STEAM resource preloading =================================== */ int STEAM_ResumeResourcePreloading(void) { int val = TRUE; #if STEAM_SYNCHRONIZED_PRELOADING { val = SteamResumeCachePreloading(&steamError); CheckError(NULL, &steamError); } #endif return val; }
int CONetCDF4::getGroup(const CNetCDF4Path & path) { int retvalue = this->ncidp; CNetCDF4Path::const_iterator it = path.begin(), end = path.end(); for (;it != end; it++) { const std::string & groupid = *it; CheckError(nc_inq_ncid(retvalue, const_cast<char*>(groupid.c_str()), &retvalue)); } return (retvalue); }
static int ArrayGetInt_(lua_State *L, GLuint array, GLenum pname, int boolean) #define ArrayGetInt(L, array, pname) ArrayGetInt_((L), (array), (pname), 0) #define ArrayGetBoolean(L, array, pname) ArrayGetInt_((L), (array), (pname), 1) { GLint param; GLuint index = luaL_checkinteger(L, 3); glGetVertexArrayIndexediv(array, index, pname, ¶m); CheckError(L); if(boolean) lua_pushboolean(L, param); else lua_pushinteger(L, param); return 1; }
int InsertServerPrerequisiteForMessageType(int msgType, vector<string> * v){ char query[200]; char * fixedInsertStr; unsigned int len; int holder; char * cTemp; MYSQL * conn; if(WaitForSingleObject(mysqlMutex, INFINITE) != WAIT_OBJECT_0){ printf("InsertServerPrerequisiteForMessageType: Couldn't acquire mutex. Returning\n"); return GENERIC_ERROR; } conn = OpenDatabaseConnection(gffServerDBName); if(conn == NULL){ printf("InsertServerPrerequisiteForMessageType: OpenDatabaseConnection(gffServerDBName) failed\n"); v->clear(); return ReleaseMutexAndReturnError(mysqlMutex, GENERIC_ERROR); } //For each host to measure in the vector for(unsigned int i=0; i < v->size(); i++){ string temp = v->at(i); cTemp = (char *)temp.c_str(); fixedInsertStr = "INSERT INTO TableVerificationPrerequisiteModules VALUES(NULL,%i,'%s')"; len = sprintf_s(query, 200, fixedInsertStr, msgType, cTemp); ////////////////////////////////// if(0 != mysql_real_query(conn, query, len)){ holder = CheckError(conn,mysql_errno(conn)); // if error code is 1062, the entry already exists, so it's ok if(holder != 1062){ CloseDatabaseConnection(conn); v->clear(); return ReleaseMutexAndReturnError(mysqlMutex, holder); } } } CloseDatabaseConnection(conn); v->clear(); ////////////////////////////////// if(!ReleaseMutex(mysqlMutex)){ printf("InsertServerPrerequisiteForMessageType: Couldn't release mutex. Returning\n"); return GENERIC_ERROR; } return GENERIC_SUCCESS; }
static int GetEnumOptIndex(lua_State *L, GLenum pname, uint32_t domain) /* index is optional */ { GLint data; GLuint index; if(!lua_isnoneornil(L, 2)) { index = luaL_checkinteger(L, 2); glGetIntegeri_v(pname, index, &data); } else glGetIntegerv(pname, &data); CheckError(L); return enums_push(L, domain, data); }
void Listener::updateListener() { update(); if(mParentNode) { mPosition = mLastParentPosition; mDirection = mLastParentOrientation.zAxis(); mUp = mLastParentOrientation.yAxis(); } alListener3f(AL_POSITION, mPosition.x, mPosition.y, mPosition.z); CheckError(alGetError(), "Failed to set Position"); mOrientation[0]= -mDirection.x; // Forward.x mOrientation[1]= -mDirection.y; // Forward.y mOrientation[2]= -mDirection.z; // Forward.z mOrientation[3]= mUp.x; // Up.x mOrientation[4]= mUp.y; // Up.y mOrientation[5]= mUp.z; // Up.z alListenerfv(AL_ORIENTATION, mOrientation); CheckError(alGetError(), "Failed to set Orientation"); }
void AudioChannel::SetVolume(float newVolume) { volume = std::max(newVolume, 0.f); if (cur_sources.empty()) return; boost::recursive_mutex::scoped_lock lck(soundMutex); for (std::map<CSoundSource*, bool>::iterator it = cur_sources.begin(); it != cur_sources.end(); ++it) { it->first->UpdateVolume(); } CheckError("AudioChannel::SetVolume"); }
void FOpenGLDrv::DrawArrayedPrimitive(GLenum InMode, GLint InStart, GLsizei InCount) { // bind shader program SetupPendingShaderProgram(); // Set Program Parameters SetupPendingShaderProgramParameters(); // Bind Vertex Attributes SetupPendingVertexAttributeArray(); // Setup Texture SetupPendingTexture(); glDrawArrays(InMode, InStart, InCount); CheckError(__FILE__, __LINE__); }
GLint LinkProgram(GLint vshader, GLint fshader) { GLint program = glCreateProgram(); glAttachShader(program, vshader); glAttachShader(program, fshader); glLinkProgram(program); // todo return placeholder program instead? cpAssertHard(CheckError(program, GL_LINK_STATUS, glGetProgramiv, glGetProgramInfoLog), "Error linking shader program"); return program; }
bool CEGLWrapper::InitDisplay(EGLDisplay *display) { if (!display || !m_nativeTypes) return false; //nativeDisplay can be (and usually is) NULL. Don't use if(nativeDisplay) as a test! EGLint status; EGLNativeDisplayType *nativeDisplay = NULL; if (!m_nativeTypes->GetNativeDisplay((XBNativeDisplayType**)&nativeDisplay)) return false; *display = eglGetDisplay(*nativeDisplay); CheckError(); if (*display == EGL_NO_DISPLAY) { CLog::Log(LOGERROR, "EGL failed to obtain display"); return false; } status = eglInitialize(*display, 0, 0); CheckError(); return status; }
bool PaPlayer::initStream() { close(); PaStreamParameters outputParameters; PaError err; outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ if (outputParameters.device == paNoDevice) { m_lastError = "No default output device."; return false; } outputParameters.channelCount = m_wavFile->channelsCount(); /* stereo/mono output */ outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */ outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; const double sampleRate = m_wavFile->audioSampleRate(); const unsigned int framesPerBuffer = 64; err = Pa_OpenStream( &m_stream, NULL, // no input &outputParameters, sampleRate, framesPerBuffer, paClipOff, // we won't output out of range samples so don't bother clipping them wavPlayCallback, this ); CheckError(err); err = Pa_SetStreamFinishedCallback( m_stream, &StreamFinished ); CheckError(err); err = Pa_StartStream( m_stream ); CheckError(err); return true; }
// Write a socket wxInt32 BufferedSocket::SendData(wxInt32 Timeout) { CreateSocket(); // create a transfer buffer, from memory stream to socket wxStopWatch sw; // clear it memset(sData, 0, sizeof(sData)); // copy data wxInt32 actual_size = send_buf->CopyTo(sData, MAX_PAYLOAD); // set the start ping // (Horrible, needs to be improved) SendPing = sw.Time(); // send the data if (!Socket->WaitForWrite(0,Timeout)) { CheckError(); SendPing = 0; RecvPing = 0; DestroySocket(); return 0; } else Socket->SendTo(to_addr, sData, actual_size); CheckError(); // return the amount of bytes sent return Socket->LastCount(); }
HRESULT CModuleConfiguration::GetString(IAppHostElement* section, LPCWSTR propertyName, LPWSTR* value) { HRESULT hr = S_OK; BSTR sysPropertyName = NULL; BSTR sysPropertyValue = NULL; IAppHostProperty* prop = NULL; CheckNull(value); *value = NULL; ErrorIf(NULL == (sysPropertyName = SysAllocString(propertyName)), ERROR_NOT_ENOUGH_MEMORY); CheckError(section->GetPropertyByName(sysPropertyName, &prop)); CheckError(prop->get_StringValue(&sysPropertyValue)); ErrorIf(NULL == (*value = new WCHAR[wcslen(sysPropertyValue) + 1]), ERROR_NOT_ENOUGH_MEMORY); wcscpy(*value, sysPropertyValue); Error: if ( sysPropertyName ) { SysFreeString(sysPropertyName); sysPropertyName = NULL; } if ( sysPropertyValue ) { SysFreeString(sysPropertyValue); sysPropertyValue = NULL; } if (prop) { prop->Release(); prop = NULL; } return hr; }
bool Init (GetProcAddressCallback callback) { std::vector <std::string> needed_extensions = { "GL_ARB_separate_shader_objects", "GL_ARB_sampler_objects", "GL_ARB_direct_state_access" }; std::stringstream version; int major, minor; #ifdef _WIN32 internal::_opengl32dllhandle = LoadLibrary ("OPENGL32.DLL"); internal::_usergetprocaddress = callback; InitPrototypes (internal::_getprocaddress); #else InitPrototypes (callback); #endif if (!GetString || GetString == (PFNGLGETSTRINGPROC) oglp::Unsupported) { #ifdef OGLP_THROW_EXCEPTIONS throw std::runtime_error ("No entry point for glGetString found."); #else return false; #endif } version << GetString (GL_VERSION); CheckError (); version >> major; version.ignore (1); version >> minor; if (major < 3) { #ifdef OGLP_THROW_EXCEPTIONS throw std::runtime_error ("OpenGL version 3.0 or higher is required."); #else return false; #endif } for (std::string &extension : needed_extensions) { if (!IsExtensionSupported (extension)) { #ifdef OGLP_THROW_EXCEPTIONS throw std::runtime_error (extension + " is required."); #else return false; #endif } } return true; }
int STEAM_fputc(int c, FILE *stream) { unsigned char chr = (unsigned char)c; SteamHandle_t hndl = (SteamHandle_t)stream; int n; TSteamError steamError; n = SteamWriteFile(&chr, sizeof(chr), 1, hndl, &steamError); if ( n != 1 || steamError.eSteamError != eSteamErrorNone ) { CheckError((FILE *)hndl, &steamError); return EOF; } return c; }
//----------------------------- void GameMain() { DDraw->FillSurface(DDraw->DDSBack,0) ; //turn CheckAction(mouse,EditInfo,world) ; mouse.button = mouse_NO ; //map scroll ThisTickCount = GetTickCount() ; if(ThisTickCount-MouseScrollTickCount>map_scroll_DELAY) { MouseScrollTickCount=ThisTickCount ; MoveMapByMouse(mouse.x,mouse.y, (world->player[player_ID]).current_x_screen,(world->player[player_ID]).current_y_screen, screen_HEIGHT,screen_WIDTH) ; } ; //drawind res=world->Draw(player_ID,screen,DDraw->DDSBack) ; // draw world CheckError(res,"world->Draw") ; if(mouse.x_frame>=0&&mouse.y_frame>=0) // { // Draw res=(mouse.sprite)->Draw(DDraw->DDSBack,(mouse.x>>5)<<5,(mouse.y>>5)<<5,mouse.x_frame,mouse.y_frame) ;// mouse CheckError(res,"mouse->Draw") ; // } ; //
void AudioChannel::SetVolume(float newVolume) { volume = std::max(newVolume, 0.0f); if (curSources.empty()) return; std::lock_guard<spring::recursive_mutex> lck(soundMutex); for (auto it = curSources.begin(); it != curSources.end(); ++it) { (*it)->UpdateVolume(); } CheckError("AudioChannel::SetVolume"); }
static int GetBooleanOptIndex(lua_State *L, GLenum pname) /* index is optional */ { GLboolean data; GLuint index; if(!lua_isnoneornil(L, 2)) { index = luaL_checkinteger(L, 2); glGetBooleani_v(pname, index, &data); } else glGetBooleanv(pname, &data); CheckError(L); lua_pushboolean(L, data); return 1; }
bool qtCanvas::Impl::setupMovie() { OSErr err; Handle dataRefH = nil; OSType dataRefType = 0; err = QTNewDataReferenceFromFullPathCFString( mPath, (UInt32)kQTNativeDefaultPathStyle, 0, &dataRefH, &dataRefType); CheckError(err, "QTNewDataReferenceFromFullPathCFString"); CreateMovieStorage(dataRefH, dataRefType, 'TVOD', smSystemScript, createMovieFileDeleteCurFile | createMovieFileDontCreateResFile | newMovieActive, &mDataHandler, &mMovie); CheckMoviesError("CreateMovieStorage"); CheckError((OSErr)((nil != mMovie) ? noErr : -1), "CreateMovieStorage movie"); return (err == noErr) && (GetMoviesError() == noErr) && (nil != mMovie); }
void qtCanvas::Impl::setupImage() { MacSetRect(&mFrame, 0, 0, mWidth, mHeight); mImageStride = mWidth * 4; mImageData = new unsigned char[mImageStride * mHeight]; OSErr err; err = QTNewGWorldFromPtr(&mGWorld, k32ARGBPixelFormat, &mFrame, nil, nil, (GWorldFlags)0, mImageData, mImageStride); CheckError(err, "QTNewGWorldFromPtr"); }
unsigned int STEAM_FileSize( FILE *file ) { SteamHandle_t hFile = (SteamHandle_t)file; TSteamError steamError; unsigned int result; if ( STEAMtrackingProgress ) { DoEventTic(FALSE); } result = SteamSizeFile(hFile, &steamError); CheckError(file, &steamError); return result; }
int STEAM_findclose(long dir) { SteamHandle_t hDir = (SteamHandle_t)dir; TSteamError steamError; int result; if ( STEAMtrackingProgress ) { DoEventTic(FALSE); } result = SteamFindClose(hDir, &steamError); CheckError(NULL, &steamError); return result; }
void SimCudaHelper::Initialize(int cudaDevice) { cudaDevice = Init(cudaDevice); cudaError res; // From CUDA prog guide: cudaSetDevice()and cudaGLSetGLDevice() are mutually exclusive. res = cudaSetDevice(cudaDevice); if (res != cudaSuccess) { CheckError(res, "cudaGetDeviceCount failed"); } else { cout << "CUDA: Successful cudaSetDevice, using device " << cudaDevice << "\n"; } }
// Sets the outgoing address void BufferedSocket::SetRemoteAddress(const wxString &Address, const wxInt16 &Port) { struct hostent *he; if((he = gethostbyname((const char *)Address.char_str())) == NULL) { CheckError(); return; } m_RemoteAddress.sin_family = PF_INET; m_RemoteAddress.sin_port = htons(Port); m_RemoteAddress.sin_addr = *((struct in_addr *)he->h_addr); memset(m_RemoteAddress.sin_zero, '\0', sizeof m_RemoteAddress.sin_zero); }
int STEAM_fputs(const char *string, FILE *stream) { SteamHandle_t hndl = (SteamHandle_t)stream; int len = strlen(string); int n; TSteamError steamError; n = SteamWriteFile((void*)string, sizeof(char), len, hndl, &steamError); if ( n != len || steamError.eSteamError != eSteamErrorNone ) { CheckError((FILE *)hndl, &steamError); return EOF; } return 1; }