mirror of
https://github.com/godotengine/godot.git
synced 2025-10-31 13:41:03 +00:00
421 lines
9.3 KiB
C++
421 lines
9.3 KiB
C++
/*************************************************************************/
|
|
/* file_access_compressed.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2015 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;i<bc;i++) {
|
|
|
|
ReadBlock rb;
|
|
rb.offset=acc_ofs;
|
|
rb.csize=f->get_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;i<bc;i++) {
|
|
f->store_32(0); //compressed sizes, will update later
|
|
}
|
|
|
|
|
|
Vector<int> block_sizes;
|
|
for(int i=0;i<bc;i++) {
|
|
|
|
int bl = i==(bc-1) ? write_max % block_size : block_size;
|
|
uint8_t *bp = &write_ptr[i*block_size];
|
|
|
|
Vector<uint8_t> 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;i<bc;i++)
|
|
f->store_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_block<read_block_count) {
|
|
//read another block of compressed data
|
|
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=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<p_length;i++) {
|
|
|
|
|
|
p_dst[i]=read_ptr[read_pos];
|
|
read_pos++;
|
|
if (read_pos>=read_block_size) {
|
|
read_block++;
|
|
|
|
if (read_block<read_block_count) {
|
|
//read another block of compressed data
|
|
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=0;
|
|
|
|
} else {
|
|
read_block--;
|
|
at_end=true;
|
|
if (i<p_length-1)
|
|
read_eof=true;
|
|
return i;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return p_length;
|
|
|
|
}
|
|
|
|
Error FileAccessCompressed::get_error() const{
|
|
|
|
return read_eof?ERR_FILE_EOF:OK;
|
|
}
|
|
|
|
void FileAccessCompressed::store_8(uint8_t p_dest){
|
|
|
|
ERR_FAIL_COND(!f);
|
|
ERR_FAIL_COND(!writing);
|
|
|
|
WRITE_FIT(1);
|
|
write_ptr[write_pos++]=p_dest;
|
|
|
|
}
|
|
|
|
bool FileAccessCompressed::file_exists(const String& p_name){
|
|
|
|
FileAccess *fa = FileAccess::open(p_name,FileAccess::READ);
|
|
if (!fa)
|
|
return false;
|
|
memdelete(fa);
|
|
return true;
|
|
}
|
|
|
|
uint64_t FileAccessCompressed::_get_modified_time(const String& p_file) {
|
|
|
|
if (f)
|
|
return f->get_modified_time(p_file);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
FileAccessCompressed::FileAccessCompressed() {
|
|
|
|
f=NULL;
|
|
magic="GCMP";
|
|
block_size=16384;
|
|
cmode=Compression::MODE_DEFLATE;
|
|
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();
|
|
|
|
}
|