/*************************************************************************/ /* file_access_compressed.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* http://www.godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "file_access_compressed.h" #include "print_string.h" void FileAccessCompressed::configure(const String& p_magic, Compression::Mode p_mode, int p_block_size) { magic=p_magic.ascii().get_data(); if (magic.length()>4) magic=magic.substr(0,4); else { while(magic.length()<4) magic+=" "; } cmode=p_mode; block_size=p_block_size; } #define WRITE_FIT(m_bytes) \ {\ if (write_pos+(m_bytes) > write_max) {\ write_max=write_pos+(m_bytes);\ }\ if (write_max > write_buffer_size) {\ write_buffer_size = nearest_power_of_2( write_max );\ buffer.resize(write_buffer_size);\ write_ptr=buffer.ptr();\ }\ } Error FileAccessCompressed::open_after_magic(FileAccess *p_base) { f=p_base; cmode=(Compression::Mode)f->get_32(); block_size=f->get_32(); read_total=f->get_32(); int bc = (read_total/block_size)+1; int acc_ofs=f->get_pos()+bc*4; int max_bs=0; for(int i=0;iget_32(); acc_ofs+=rb.csize; max_bs=MAX(max_bs,rb.csize); read_blocks.push_back(rb); } comp_buffer.resize(max_bs); buffer.resize(block_size); read_ptr=buffer.ptr(); f->get_buffer(comp_buffer.ptr(),read_blocks[0].csize); at_end=false; read_eof=false; read_block_count=bc; read_block_size=read_blocks.size()==1?read_total:block_size; Compression::decompress(buffer.ptr(),read_block_size,comp_buffer.ptr(),read_blocks[0].csize,cmode); read_block=0; read_pos=0; return OK; } Error FileAccessCompressed::_open(const String& p_path, int p_mode_flags){ ERR_FAIL_COND_V(p_mode_flags==READ_WRITE,ERR_UNAVAILABLE); if (f) close(); Error err; f = FileAccess::open(p_path,p_mode_flags,&err); if (err!=OK) { //not openable f=NULL; return err; } if (p_mode_flags&WRITE) { buffer.clear(); writing=true; write_pos=0; write_buffer_size=256; buffer.resize(256); write_max=0; write_ptr=buffer.ptr(); //don't store anything else unless it's done saving! } else { char rmagic[5]; f->get_buffer((uint8_t*)rmagic,4); rmagic[4]=0; if (magic!=rmagic) { memdelete(f); f=NULL; return ERR_FILE_UNRECOGNIZED; } open_after_magic(f); } return OK; } void FileAccessCompressed::close(){ if (!f) return; if (writing) { //save block table and all compressed blocks CharString mgc = magic.utf8(); f->store_buffer((const uint8_t*)mgc.get_data(),mgc.length()); //write header 4 f->store_32(cmode); //write compression mode 4 f->store_32(block_size); //write block size 4 f->store_32(write_max); //max amount of data written 4 int bc=(write_max/block_size)+1; for(int i=0;istore_32(0); //compressed sizes, will update later } Vector block_sizes; for(int i=0;i cblock; cblock.resize(Compression::get_max_compressed_buffer_size(bl,cmode)); int s = Compression::compress(cblock.ptr(),bp,bl,cmode); f->store_buffer(cblock.ptr(),s); block_sizes.push_back(s); } f->seek(16); //ok write block sizes for(int i=0;istore_32(block_sizes[i]); f->seek_end(); f->store_buffer((const uint8_t*)mgc.get_data(),mgc.length()); //magic at the end too buffer.clear(); } else { comp_buffer.clear(); buffer.clear(); read_blocks.clear(); } memdelete(f); f=NULL; } bool FileAccessCompressed::is_open() const{ return f!=NULL; } void FileAccessCompressed::seek(size_t p_position){ ERR_FAIL_COND(!f); if (writing) { ERR_FAIL_COND(p_position>write_max); write_pos=p_position; } else { ERR_FAIL_COND(p_position>read_total); if (p_position==read_total) { at_end=true; } else { int block_idx = p_position/block_size; if (block_idx!=read_block) { read_block=block_idx; f->seek(read_blocks[read_block].offset); f->get_buffer(comp_buffer.ptr(),read_blocks[read_block].csize); Compression::decompress(buffer.ptr(),read_blocks.size()==1?read_total:block_size,comp_buffer.ptr(),read_blocks[read_block].csize,cmode); read_block_size=read_block==read_block_count-1?read_total%block_size:block_size; } read_pos=p_position%block_size; } } } void FileAccessCompressed::seek_end(int64_t p_position){ ERR_FAIL_COND(!f); if (writing) { seek(write_max+p_position); } else { seek(read_total+p_position); } } size_t FileAccessCompressed::get_pos() const{ ERR_FAIL_COND_V(!f,0); if (writing) { return write_pos; } else { return read_block*block_size+read_pos; } } size_t FileAccessCompressed::get_len() const{ ERR_FAIL_COND_V(!f,0); if (writing) { return write_max; } else { return read_total; } } bool FileAccessCompressed::eof_reached() const{ ERR_FAIL_COND_V(!f,false); if (writing) { return false; } else { return read_eof; } } uint8_t FileAccessCompressed::get_8() const{ ERR_FAIL_COND_V(writing,0); ERR_FAIL_COND_V(!f,0); if (at_end) { read_eof=true; return 0; } uint8_t ret = read_ptr[read_pos]; read_pos++; if (read_pos>=read_block_size) { read_block++; if (read_blockget_buffer(comp_buffer.ptr(),read_blocks[read_block].csize); Compression::decompress(buffer.ptr(),read_blocks.size()==1?read_total:block_size,comp_buffer.ptr(),read_blocks[read_block].csize,cmode); read_block_size=read_block==read_block_count-1?read_total%block_size:block_size; read_pos=0; } else { read_block--; at_end=true; ret =0; } } return ret; } int FileAccessCompressed::get_buffer(uint8_t *p_dst, int p_length) const{ ERR_FAIL_COND_V(writing,0); ERR_FAIL_COND_V(!f,0); if (at_end) { read_eof=true; return 0; } for(int i=0;i=read_block_size) { read_block++; if (read_blockget_buffer(comp_buffer.ptr(),read_blocks[read_block].csize); Compression::decompress(buffer.ptr(),read_blocks.size()==1?read_total:block_size,comp_buffer.ptr(),read_blocks[read_block].csize,cmode); read_block_size=read_block==read_block_count-1?read_total%block_size:block_size; read_pos=0; } else { read_block--; at_end=true; if (iget_modified_time(p_file); else return 0; } FileAccessCompressed::FileAccessCompressed() { f=NULL; magic="GCMP"; block_size=4096; cmode=Compression::MODE_FASTLZ; writing=false; write_ptr=0; write_buffer_size=0; write_max=0; block_size=0; read_eof=false; at_end=false; read_total=0; read_ptr=NULL; read_block=0; read_block_count=0; read_block_size=0; read_pos=0; } FileAccessCompressed::~FileAccessCompressed(){ if (f) close(); }