SDL_Surface *GetCIcon(FrameBuf *screen, short cicn_id) { char file[256]; DataDir data_dir; SDL_Surface *cicn; SDL_RWops *cicn_src; Uint8 *pixels, *mask; Uint16 w, h; /* Open the cicn sprite file.. */ snprintf(file, sizeof(file), "Images/Maelstrom_Icon#%hd.cicn", cicn_id); if ( (cicn_src=SDL_RWFromFile(data_dir.FullPath(file), "r")) == NULL ) { error("GetCIcon(%hd): Can't open CICN %s: ", cicn_id, data_dir.FullPath(file)); return(NULL); } w = SDL_ReadBE16(cicn_src); h = SDL_ReadBE16(cicn_src); pixels = new Uint8[w*h]; if ( SDL_RWread(cicn_src, pixels, 1, w*h) != (w*h) ) { error("GetCIcon(%hd): Corrupt CICN!\n", cicn_id); delete[] pixels; SDL_RWclose(cicn_src); return(NULL); } mask = new Uint8[(w/8)*h]; if ( SDL_RWread(cicn_src, mask, 1, (w/8)*h) != ((w/8)*h) ) { error("GetCIcon(%hd): Corrupt CICN!\n", cicn_id); delete[] pixels; delete[] mask; SDL_RWclose(cicn_src); return(NULL); } SDL_RWclose(cicn_src); cicn = screen->LoadImage(w, h, pixels, mask); delete[] pixels; delete[] mask; if ( cicn == NULL ) { error("GetCIcon(%hd): Couldn't convert CICN!\n", cicn_id); } return(cicn); }
/* Given a file_path and buffer, attempts to load save data into the buffer * up to the suppled size in bytes. Returns the size of the file if successful, * returns 0 if unsuccessful. Buffer should at least be of length size*/ unsigned long load_SRAM(const char *file_path, unsigned char *data, unsigned long size) { log_message(LOG_INFO, "Attempting to load SRAM for file: %s\n",file_path); SDL_RWops *rw = SDL_RWFromFile(file_path, "rb"); if (rw == NULL) { log_message(LOG_ERROR, "Error opening file %s: %s\n", file_path, SDL_GetError()); return 0; } Sint64 res_size = SDL_RWsize(rw); if (res_size > size) { log_message(LOG_ERROR, "Error opening file %s: File is too large to be SRAM snapshot\n", file_path); return 0; } if (res_size == 0) { log_message(LOG_WARN, "File %s has a size of 0 bytes\n", file_path); return 0; } Sint64 nb_read_total = 0, nb_read = 1; unsigned char* buf = data; while (nb_read_total < res_size && nb_read != 0) { nb_read = SDL_RWread(rw, buf, 1, (res_size - nb_read_total)); nb_read_total += nb_read; buf += nb_read; } SDL_RWclose(rw); if (nb_read_total != res_size) { log_message(LOG_ERROR, "Bytes expected (%lu) is not equal to bytes read (%lu)\n", res_size, nb_read_total); free(data); return 0; } return res_size; }
void SdlAudio::BGM_Play(std::string const& file, int volume, int /* pitch */, int fadein) { std::string const path = FileFinder::FindMusic(file); if (path.empty()) { Output::Debug("Music not found: %s", file.c_str()); return; } SDL_RWops *rw = SDL_RWFromFile(path.c_str(), "rb"); #if SDL_MIXER_MAJOR_VERSION>1 bgm.reset(Mix_LoadMUS_RW(rw, 1), &Mix_FreeMusic); #else bgm.reset(Mix_LoadMUS_RW(rw), &Mix_FreeMusic); #endif if (!bgm) { Output::Warning("Couldn't load %s BGM.\n%s\n", file.c_str(), Mix_GetError()); return; } #if SDL_MAJOR_VERSION>1 // SDL2_mixer produces noise when playing wav. // Workaround: Use Mix_LoadWAV // https://bugzilla.libsdl.org/show_bug.cgi?id=2094 if (bgs_playing) { BGS_Stop(); } if (Mix_GetMusicType(bgm.get()) == MUS_WAV) { BGM_Stop(); BGS_Play(file, volume, 0, fadein); return; } #endif BGM_Volume(volume); if (!me_stopped_bgm && #ifdef _WIN32 (Mix_GetMusicType(bgm.get()) == MUS_MID && WindowsUtils::GetWindowsVersion() >= 6 ? Mix_PlayMusic(bgm.get(), -1) : Mix_FadeInMusic(bgm.get(), -1, fadein)) #else Mix_FadeInMusic(bgm.get(), -1, fadein) #endif == -1) { Output::Warning("Couldn't play %s BGM.\n%s\n", file.c_str(), Mix_GetError()); return; } }
void Map::loadFromFile(const std::string filename){ this->map = new Tmx::Map(); this->map->ParseFile(filename); if(map->HasError() == true) { throw map->GetErrorText(); } if(this->renderer == nullptr) { throw new ExNoRenderer(); } // Load image files const std::vector<Tmx::Tileset*>& tileSets = map->GetTilesets(); for(int i = 0; i < tileSets.size(); ++i) { const Tmx::Tileset * tileSet = tileSets[i]; const Tmx::Image * image = tileSet->GetImage(); const std::string source = image->GetSource(); SDL_RWops * rwop = SDL_RWFromFile(source.c_str(),"r"); SDL_Surface * surf = IMG_LoadPNG_RW(rwop); SDL_Texture * tex = SDL_CreateTextureFromSurface(this->renderer, surf); this->images.push_back(tex); } }
int init_gaia(void) { struct SDL_Surface *Z; struct SDL_RWops *F; Sint32 w; int i, x=0; if( (F = SDL_RWFromFile("data/hblk01.dat","r")) == NULL) abend(0); for(i=0; i < 256*6; i++) { w = SDL_ReadLE32(F); w = (w < 6144)? 0: (w - 6144) / 320; subtile_table[i] = w; x = (w > x)? w : x; } printf("Gaia tile module:\n + %d unique subtiles.\n", x); x++; if(!(Z = CreateZSurface(get_pal("data/hpal01.dat"), 32,16*x)) ) SDL_RWclose(F), abend(0); load_subtiles(F, Z->pixels, x); if(1) subtiles = Z; else { if( (subtiles = SDL_CreateRGBSurface(SDL_HWSURFACE, 32,16*x,32, RR,GG,BB,AA)) ) SDL_BlitSurface(Z, NULL, subtiles, NULL); SDL_FreeSurface(Z); } SDL_RWclose(F); lua_pushnumber(L, SCALE); lua_setfield(L, LUA_GLOBALSINDEX, "scale"); lua_register(L, "s2m", s2m); lua_register(L, "m2s", m2s); REG_CLASS(L, map); return subtiles != NULL; }
/*static*/ bool tqt::is_tqt_file(const char* filename) // Return true if the given file looks like a .tqt file of our // appropriate version. Do this by attempting to read the header. { SDL_RWops* in = SDL_RWFromFile(filename, "rb"); if (in == NULL) { return false; } // Read header. tqt_header_info info = read_tqt_header_info(in); SDL_RWclose(in); if (info.m_version != TQT_VERSION) { return false; } return true; }
Sound_Sample *Sound_NewSampleFromFile(const char *filename, Sound_AudioInfo *desired, Uint32 bufferSize) { const char *ext; SDL_RWops *rw; BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, NULL); BAIL_IF_MACRO(filename == NULL, ERR_INVALID_ARGUMENT, NULL); ext = strrchr(filename, '.'); rw = SDL_RWFromFile(filename, "rb"); BAIL_IF_MACRO(rw == NULL, SDL_GetError(), NULL); if (ext != NULL) ext++; return(Sound_NewSample(rw, ext, desired, bufferSize)); } /* Sound_NewSampleFromFile */
static int open_font(lua_State * L) { const char * filename; lua_Integer fontsize; TTF_Font * font; TTF_Font ** ud; char adjusted_filename[MAX_ADJUSTED_FILENAME_LEN]; SDL_RWops * file; filename = luaL_checkstring(L, 1); prepend_data_path(adjusted_filename, filename, MAX_ADJUSTED_FILENAME_LEN); file = SDL_RWFromFile(adjusted_filename, "rt"); fontsize = luaL_checkinteger(L, 2); font = TTF_OpenFontRW(file, 1, fontsize); if (!font) fatal(TTF_GetError()); ud = (TTF_Font **) lua_newuserdata(L, sizeof(TTF_Font *)); if (ud == NULL) fatal("ud NULL in open_font"); *ud = font; return 1; }
BaseD::Profile::Profile(const char* spc_filename) { is_profiling = true; old_gain_db = BaseD::player->gain_db; BaseD::player->pause(1, true, false); BaseD::reload(); BaseD::player->pause(0, false, false); BaseD::player->pause(1, false, false); //BaseD::player->restart_track(); // Set Volume to 0 player->set_gain_db(Music_Player::min_gain_db, true); // get pointer to spc_file_t // open the SPC File //DEBUGLOG("spc file path = %s\n", BaseD::g_cfg.playlist[BaseD::g_cur_entry]); //const char *spc_filename = BaseD::g_cfg.playlist[BaseD::g_cur_entry]; // need to open a file SDL_RWops *orig_spc_file = SDL_RWFromFile(spc_filename, "rb"); if (orig_spc_file == NULL) { sprintf(BaseD::tmpbuf, "Warning: Unable to open file %s!\n %s", spc_filename, SDL_GetError() ); SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Could not open FILE!", BaseD::tmpbuf, NULL); //return -1; is_profiling=false; delete this; } if (SDL_RWread(orig_spc_file, orig_spc_state, Snes_Spc::spc_file_size, 1) == 0) { sprintf(BaseD::tmpbuf, "Warning: Unable to read file %s!\n %s", spc_filename, SDL_GetError() ); SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Could not read file!", BaseD::tmpbuf, NULL); SDL_RWclose(orig_spc_file); //return -1; is_profiling=false; delete this; } else SDL_RWclose(orig_spc_file); }
void *inhale_file(const char *name, Uint32 blk, Uint32 off) { struct SDL_RWops *F = NULL; Uint32 x, *n; void *p; if(!(F = SDL_RWFromFile(name,"r"))) abend(0); /* determine size */ x = SDL_RWseek(F, 0, SEEK_END), SDL_RWseek(F, 0, SEEK_SET); off += sizeof(Uint32); if((n = p = malloc(off+x)) == NULL) abend(0); *n = SDL_RWread(F, p+off, blk, x/blk); SDL_RWclose(F); return p; }
void raw_save_file(terrain* t, char* filename) { SDL_RWops* file = SDL_RWFromFile(filename, "wb"); if (!file) { error("Could not load file %s\n", filename); } uint16_t* pixels = malloc(sizeof(uint16_t) * t->width * t->height); for(int i = 0; i < t->width * t->height; i++) { pixels[i] = t->heightmap[i] * (65536.0 / MAX_HEIGHT); } SDL_RWwrite(file, pixels, sizeof(uint16_t) * t->width * t->height, 1); SDL_RWclose(file); }
void close() { //Open data for writing SDL_RWops* file = SDL_RWFromFile( "33_file_reading_and_writing/nums.bin", "w+b" ); if( file != NULL ) { //Save data for( int i = 0; i < TOTAL_DATA; ++i ) { SDL_RWwrite( file, &gData[ i ], sizeof(Sint32), 1 ); } //Close file handler SDL_RWclose( file ); } else { printf( "Error: Unable to save file! %s\n", SDL_GetError() ); } //Free loaded images gPromptTextTexture.free(); for( int i = 0; i < TOTAL_DATA; ++i ) { gDataTextures[ i ].free(); } //Free global font TTF_CloseFont( gFont ); gFont = NULL; //Destroy window SDL_DestroyRenderer( gRenderer ); SDL_DestroyWindow( gWindow ); gWindow = NULL; gRenderer = NULL; //Quit SDL subsystems TTF_Quit(); IMG_Quit(); SDL_Quit(); }
static int DISKAUD_OpenDevice(_THIS, const char *devname, int iscapture) { const char *envr = SDL_getenv(DISKENVR_WRITEDELAY); const char *fname = DISKAUD_GetOutputFilename(devname); this->hidden = (struct SDL_PrivateAudioData *) SDL_malloc(sizeof(*this->hidden)); if (this->hidden == NULL) { SDL_OutOfMemory(); return 0; } SDL_memset(this->hidden, 0, sizeof(*this->hidden)); /* Open the audio device */ this->hidden->output = SDL_RWFromFile(fname, "wb"); if (this->hidden->output == NULL) { DISKAUD_CloseDevice(this); return 0; } /* Allocate mixing buffer */ this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen); if (this->hidden->mixbuf == NULL) { DISKAUD_CloseDevice(this); return 0; } SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size); this->hidden->mixlen = this->spec.size; this->hidden->write_delay = (envr) ? SDL_atoi(envr) : DISKDEFAULT_WRITEDELAY; #if HAVE_STDIO_H fprintf(stderr, "WARNING: You are using the SDL disk writer audio driver!\n" " Writing to file [%s].\n", fname); #endif /* We're ready to rock and roll. :-) */ return 1; }
static SDL_RWops* get_standard_rwop(PyObject* obj) { if(PyString_Check(obj) || PyUnicode_Check(obj)) { int result; char* name; PyObject* tuple = PyTuple_New(1); PyTuple_SET_ITEM(tuple, 0, obj); Py_INCREF(obj); if(!tuple) return NULL; result = PyArg_ParseTuple(tuple, "s", &name); Py_DECREF(tuple); if(!result) return NULL; return SDL_RWFromFile(name, "rb"); } // else if(PyFile_Check(obj)) // return SDL_RWFromFP(PyFile_AsFile(obj), 0); return NULL; }
static void extract_fork(SDL_RWops *fin, int req_id, const char *file_name, const char *fork_name) { long id, fork_start, fork_size; int num_entries, fork_found; SDL_RWops *fout; // Look for fork in source file SDL_RWseek(fin, 0x18, SEEK_SET); num_entries = SDL_ReadBE16(fin); while (num_entries--) { Uint32 id = SDL_ReadBE32(fin); Sint32 ofs = SDL_ReadBE32(fin); Sint32 len = SDL_ReadBE32(fin); if (id == req_id) { fork_found = 1; fork_start = ofs; fork_size = len; } } if (!fork_found) { fprintf(stderr, "Warning: source file doesn't contain a %s fork.\n", fork_name); return; } // Found, open destination file fout = SDL_RWFromFile(file_name, "wb"); if (fout == NULL) { perror("Can't open destination file"); exit(1); } // Copy fork SDL_RWseek(fin, fork_start, SEEK_SET); while (fork_size) { long length = fork_size > BUFFER_SIZE ? BUFFER_SIZE : fork_size; SDL_RWread(fin, buffer, 1, length); SDL_RWwrite(fout, buffer, 1, length); fork_size -= length; } SDL_FreeRW(fout); }
texture* lut_load_file( char* filename ) { SDL_RWops* file = SDL_RWFromFile(filename, "r"); if(file == NULL) { error("Cannot load file %s", filename); } long size = SDL_RWseek(file,0,SEEK_END); unsigned char* contents = malloc(size+1); contents[size] = '\0'; SDL_RWseek(file, 0, SEEK_SET); SDL_RWread(file, contents, size, 1); SDL_RWclose(file); int head = sizeof("CORANGE-LUT")-1; int lut_size = (unsigned char)contents[head] | (unsigned char)contents[head + 1]; int offset = head + 3; texture* t = malloc(sizeof(texture)); texture tex_id; glEnable(GL_TEXTURE_3D); glGenTextures(1, &tex_id); glBindTexture(GL_TEXTURE_3D, tex_id); glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, lut_size, lut_size, lut_size, 0, GL_RGB, GL_UNSIGNED_BYTE, contents + offset); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_MIRRORED_REPEAT); glDisable(GL_TEXTURE_3D); *t = tex_id; free(contents); return t; }
/* Given a file_path and buffer to store file data in, attempts to * read the file into the buffer. Returns the size of the file if successful, * returns 0 if unsuccessful. Buffer should be at minimum of size "MAX_FILE_SIZE"*/ unsigned long load_rom_from_file(const char* filename, unsigned char *data) { SDL_RWops *rw = SDL_RWFromFile(filename, "rb"); if (rw == NULL) { log_message(LOG_ERROR, "Error opening file %s: %s\n", filename, SDL_GetError()); return 0; } Sint64 res_size = SDL_RWsize(rw); if (res_size > MAX_FILE_SIZE) { log_message(LOG_ERROR, "Error opening file %s: File is too large to be a Gameboy ROM\n", filename); return 0; } if (res_size == 0) { log_message(LOG_WARN, "File %s has a size of 0 bytes\n", filename); return 0; } Sint64 nb_read_total = 0, nb_read = 1; unsigned char* buf = data; while (nb_read_total < res_size && nb_read != 0) { nb_read = SDL_RWread(rw, buf, 1, (res_size - nb_read_total)); nb_read_total += nb_read; buf += nb_read; } SDL_RWclose(rw); if (nb_read_total != res_size) { log_message(LOG_ERROR, "Bytes expected (%lu) is not equal to bytes read (%lu)\n", res_size, nb_read_total); free(data); return 0; } return res_size; }
int savePNG(const std::string &filename, const unsigned char * data,int w,int h,_XColorMode color, int compression) { if(data == NULL) return XFalse; SDL_RWops *fp; int ret; if((fp = SDL_RWFromFile(filename.c_str(),"wb")) == NULL) return -1; SDL_Surface * picArm = NULL; switch(color) { case COLOR_RGB: case COLOR_BGR: #if SDL_BYTEORDER == SDL_BIG_ENDIAN picArm = SDL_CreateRGBSurface(SDL_SWSURFACE,w,h,24,0xff000000, 0x00ff0000, 0x0000ff00, 0x00000000); #else picArm = SDL_CreateRGBSurface(SDL_SWSURFACE,w,h,24,0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000); #endif break; case COLOR_RGBA: case COLOR_BGRA: #if SDL_BYTEORDER == SDL_BIG_ENDIAN picArm = SDL_CreateRGBSurface(SDL_SWSURFACE,w,h,32,0xff000000, 0x00ff0000, 0x0000ff00, 0x00000000); #else picArm = SDL_CreateRGBSurface(SDL_SWSURFACE,w,h,32,0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000); #endif break; default: //其他格式不支持 return -1; break; } //这里可以考虑保存成24位色提升效率 memcpy(picArm->pixels,data,w * h * picArm->format->BytesPerPixel); ret = IMG_SavePNG_RW(fp,picArm,compression); SDL_FreeSurface(picArm); picArm = NULL; SDL_RWclose(fp); return ret; }
int main(int argc, char *argv[]) { if (argc != 2) { fprintf(stderr, "usage: %s <filename>\n", argv[0]); return 1; } if (SDL_Init(SDL_INIT_AUDIO) != 0) { fprintf(stderr, "Error: %s\n", SDL_GetError()); return 1; } if (Sound_Init() == 0) { fprintf(stderr, "Error: %s\n", Sound_GetError()); return 1; } SDL_RWops* rw = SDL_RWFromFile(argv[1], "r"); if (rw == NULL) { fprintf(stderr, "Error: %s\n", SDL_GetError()); return 1; } Sound_AudioInfo wantedFormat; wantedFormat.channels = 2; wantedFormat.rate = 44100; wantedFormat.format = AUDIO_S16LSB; Sound_Sample* sample = Sound_NewSample(rw, 0, &wantedFormat, 8192); if (sample == 0) { fprintf(stderr, "Error: %s\n", Sound_GetError()); return 1; } Sound_DecodeAll(sample); printf("Format: %s\n", sample->decoder->description); printf("Decoded %d bytes of data.\n", sample->buffer_size); Sound_FreeSample(sample); return 0; }
bool Sample::Load(const char* filename) { Unload(); SDL_RWops* rw = SDL_RWFromFile(filename, "rb"); if (!rw) { SDL_RWclose(rw); return false; } SDL_AudioSpec audiospec; memset(&audiospec, 0, sizeof(audiospec)); SDL_AudioSpec* spec = SDL_LoadWAV_RW(rw, false, &audiospec, &data, (Uint32*)&length); if (spec != NULL) { format.freq = spec->freq; format.format = spec->format; format.channels = spec->channels; issdlwav = true; } else { return false; } return true; }
// // Open() // open file // bool FileIO::Open(const _TCHAR* filename, uint flg) { SDL_RWops *ops; Close(); // support readonly mode if (flg != readonly) { return false; } // open with 'rb' mode ops = SDL_RWFromFile(filename, "rb"); if (ops == NULL) { return false; } // return hfile = ops; return true; }
void *FontInfo::openFont( char *font_file, int ratio1, int ratio2 ) { int font_size; if ( font_size_xy[0] < font_size_xy[1] ) font_size = font_size_xy[0]; else font_size = font_size_xy[1]; FontContainer *fc = &root_font_container; while( fc->next ){ if ( fc->next->size == font_size ) break; fc = fc->next; } if ( !fc->next ){ fc->next = new FontContainer(); fc->next->size = font_size; FILE *fp = fopen( font_file, "r" ); if ( fp == NULL ) return NULL; fclose( fp ); #if defined(PSP) fc->next->rw_ops = SDL_RWFromFile(font_file, "r"); fc->next->font = TTF_OpenFontRW( fc->next->rw_ops, SDL_TRUE, font_size * ratio1 / ratio2 ); fc->next->power_resume_number = psp_power_resume_number; strcpy(fc->next->name, font_file); #else fc->next->font = TTF_OpenFont( font_file, font_size * ratio1 / ratio2 ); #endif } #if defined(PSP) else if (fc->next->power_resume_number != psp_power_resume_number){ FILE *fp = fopen(fc->next->name, "r"); fc->next->rw_ops->hidden.stdio.fp = fp; fc->next->power_resume_number = psp_power_resume_number; } #endif ttf_font = (void*)fc->next->font; return fc->next->font; }
void LoadFile(const String& fileName, const String& reference, SDL_Renderer* renderer) { //Setup the text data filename String dataFileName = fileName.substr(0, fileName.length() - 4) + ".txt"; #ifdef __ANDROID__ //Open the file with RWops function and process each line SDL_RWops *rw = SDL_RWFromFile(dataFileName.c_str(), "rb"); if(rw > 0) { __android_log_write(ANDROID_LOG_INFO, "Chain Drop", "Loading texture file"); ProcessAndroidTextFile(rw, reference); SDL_FreeRW(rw); textureReferences[reference] = LoadTextureFromFile(fileName, renderer); } else logError(std::cout, "LoadFile: error opening: " + dataFileName); #elif _WIN32 //Open the file with a filestream and process each line std::ifstream file(dataFileName); if (file.is_open()) { String line; while(getline(file, line)) { ProcessFileLine(line, reference); } file.close(); textureReferences[reference] = LoadTextureFromFile(fileName, renderer); } else logError(std::cout, "LoadFile: error opening: " + dataFileName); #endif }
static void mavlink_parseDoc (char *docname) { xmlDocPtr doc; xmlNodePtr cur; if (strncmp(docname, "./", 2) == 0) { docname += 2; } char *buffer = NULL; int len = 0; SDL_RWops *ops_file = SDL_RWFromFile(docname, "r"); if (ops_file == NULL) { SDL_Log("map: Document open failed: %s\n", docname); return; } len = SDL_RWseek(ops_file, 0, SEEK_END); SDL_RWseek(ops_file, 0, SEEK_SET); buffer = malloc(len); SDL_RWread(ops_file, buffer, 1, len); doc = xmlParseMemory(buffer, len); SDL_RWclose(ops_file); free(buffer); if (doc == NULL) { SDL_Log("mavlink: Document parsing failed: %s\n", docname); return; } cur = xmlDocGetRootElement(doc); if (cur == NULL) { xmlFreeDoc(doc); SDL_Log("mavlink: Document is Empty!!!\n"); return; } cur = cur->xmlChildrenNode; while (cur != NULL) { if ((xmlStrcasecmp(cur->name, (const xmlChar *)"text"))) { mavlink_parseParams(doc, cur); } cur = cur->next; } xmlFreeDoc(doc); return; }
static int audiosourcefile_Read(struct audiosource* source, char* buffer, unsigned int bytes) { struct audiosourcefile_internaldata* idata = source->internaldata; if (idata->file == NULL) { if (idata->eof) { return -1; } #ifdef SDLRW idata->file = SDL_RWFromFile(idata->path, "rb"); #else idata->file = fopen(idata->path,"rb"); #endif if (!idata->file) { idata->file = NULL; return -1; } } #ifdef SDLRW int bytesread = idata->file->read(idata->file, buffer, 1, bytes); #else int bytesread = fread(buffer, 1, bytes, idata->file); #endif if (bytesread > 0) { return bytesread; }else{ #ifdef SDLRW idata->file->close(idata->file); #else fclose(idata->file); #endif idata->file = NULL; idata->eof = 1; if (bytesread < 0) { return -1; } return 0; } }
//------------------------------------------------------------------------------------ // Проверка наличия файла в VFS или FS //------------------------------------------------------------------------------------ int FileDetect(const char *FileName) { //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // поиск в VFS //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ eVFS_Entry *Tmp = StarVFSArray; while (Tmp != 0) { eVFS_Entry *Tmp1 = Tmp->Next; if(strcmp(FileName, Tmp->Name) == 0) { // нашли return VFS_FILE_VFS; } Tmp = Tmp1; } //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // поиск в FS //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ SDL_RWops *temp = SDL_RWFromFile(FileName, "rb"); // смогли открыть файл if (temp != NULL) { SDL_RWclose(temp); return VFS_FILE_FS; } //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Файл не найден //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ return -1; }
/** * @brief Tests writing from file. * * \sa * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile * http://wiki.libsdl.org/moin.cgi/SDL_RWClose */ int rwops_testFileWrite(void) { SDL_RWops *rw; int result; /* Write test. */ rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+"); SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\") succeeded"); SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL"); /* Bail out if NULL */ if (rw == NULL) return TEST_ABORTED; /* Check type */ #if defined(ANDROID) SDLTest_AssertCheck( rw->type == SDL_RWOPS_STDFILE || rw->type == SDL_RWOPS_JNIFILE, "Verify RWops type is SDL_RWOPS_STDFILE or SDL_RWOPS_JNIFILE; expected: %d|%d, got: %d", SDL_RWOPS_STDFILE, SDL_RWOPS_JNIFILE, rw->type); #elif defined(__WIN32__) SDLTest_AssertCheck( rw->type == SDL_RWOPS_WINFILE, "Verify RWops type is SDL_RWOPS_WINFILE; expected: %d, got: %d", SDL_RWOPS_WINFILE, rw->type); #else SDLTest_AssertCheck( rw->type == SDL_RWOPS_STDFILE, "Verify RWops type is SDL_RWOPS_STDFILE; expected: %d, got: %d", SDL_RWOPS_STDFILE, rw->type); #endif /* Run generic tests */ _testGenericRWopsValidations( rw, 1 ); /* Close handle */ result = SDL_RWclose(rw); SDLTest_AssertPass("Call to SDL_RWclose() succeeded"); SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result); return TEST_COMPLETED; }
//------------------------------------------------------------------------------------ // запись данных в VFS //------------------------------------------------------------------------------------ int vw_WriteIntoVFSfromFile(const char *SrcName, const char *DstName) { if (SrcName == 0) return -1; if (DstName == 0) return -1; // читаем данные файла в буфер SDL_RWops *Ftmp = SDL_RWFromFile(SrcName, "rb"); // Если файл не найден - выходим if (Ftmp == NULL) { fprintf(stderr, "Can't find file %s !!!\n", SrcName); return -1; } // получаем размер файла SDL_RWseek(Ftmp, 0, SEEK_END); int tmpLength = SDL_RWtell(Ftmp); SDL_RWseek(Ftmp, 0, SEEK_SET); // копируем все данные файла в массив BYTE *tmp = 0; tmp = new BYTE[tmpLength]; SDL_RWread(Ftmp, tmp, tmpLength, 1); SDL_RWclose(Ftmp); // запись в VFS if (0 != vw_WriteIntoVFSfromMemory(DstName, tmp, tmpLength)) { // какая-то ошибка, не можем записать в VFS delete [] tmp; tmp = 0; fprintf(stderr, "Can't write into VFS from memory %s !!!\n", DstName); return -1; } // Освобождаем память delete [] tmp; tmp = 0; return 0; }
// Apple provides both stream and file loading functions in ImageIO. // Potentially, Apple can optimize for either case. SDL_Surface* IMG_Load(const char *file) { SDL_Surface* sdl_surface = NULL; sdl_surface = LoadImageFromFile(file); if(NULL == sdl_surface) { // Either the file doesn't exist or ImageIO doesn't understand the format. // For the latter case, fallback to the native SDL_image handlers. SDL_RWops *src = SDL_RWFromFile(file, "rb"); char *ext = strrchr(file, '.'); if(ext) { ext++; } if(!src) { /* The error message has been set in SDL_RWFromFile */ return NULL; } sdl_surface = IMG_LoadTyped_RW(src, 1, ext); } return sdl_surface; }
void SourceMusic::CreateSample(void) { _rwops = SDL_RWFromFile(_filename, "rb"); char *ext = _filename; for(int i = 0; *(_filename + i); i++) { if(*(_filename + i) == '.') ext = _filename + i + 1; } _sample = Sound_NewSample(_rwops, ext, _system->GetAudioInfo(), _sample_buffersize ); if(_sample == NULL) { fprintf(stderr, "[error] failed loading sample type %s, from %s: %s\n", ext, _filename, Sound_GetError()); return; } _read = 0; _decoded = 0; // fprintf(stderr, "created sample\n"); }