void TileMap::_set_tile_data(const DVector<int>& p_data) { int c=p_data.size(); DVector<int>::Read r = p_data.read(); for(int i=0;i<c;i+=2) { const uint8_t *ptr=(const uint8_t*)&r[i]; uint8_t local[8]; for(int j=0;j<8;j++) local[j]=ptr[j]; #ifdef BIG_ENDIAN_ENABLED SWAP(local[0],local[3]); SWAP(local[1],local[2]); SWAP(local[4],local[7]); SWAP(local[5],local[6]); #endif int x = decode_uint16(&local[0]); int y = decode_uint16(&local[2]); uint32_t v = decode_uint32(&local[4]); bool flip_h = v&(1<<29); bool flip_v = v&(1<<30); v&=(1<<29)-1; // if (x<-20 || y <-20 || x>4000 || y>4000) // continue; set_cell(x,y,v,flip_h,flip_v); } }
bool ErrorResponse::decode(int version, char* buffer, size_t size) { char* pos = decode_int32(buffer, code_); pos = decode_string(pos, &message_); switch (code_) { case CQL_ERROR_UNAVAILABLE: pos = decode_uint16(pos, cl_); pos = decode_int32(pos, required_); decode_int32(pos, received_); break; case CQL_ERROR_READ_TIMEOUT: pos = decode_uint16(pos, cl_); pos = decode_int32(pos, received_); pos = decode_int32(pos, required_); decode_byte(pos, data_present_); break; case CQL_ERROR_WRITE_TIMEOUT: pos = decode_uint16(pos, cl_); pos = decode_int32(pos, received_); pos = decode_int32(pos, required_); decode_write_type(pos); break; case CQL_ERROR_READ_FAILURE: pos = decode_uint16(pos, cl_); pos = decode_int32(pos, received_); pos = decode_int32(pos, required_); pos = decode_int32(pos, num_failures_); decode_byte(pos, data_present_); break; case CQL_ERROR_FUNCTION_FAILURE: pos = decode_string(pos, &keyspace_); pos = decode_string(pos, &function_); decode_stringlist(pos, arg_types_); break; case CQL_ERROR_WRITE_FAILURE: pos = decode_uint16(pos, cl_); pos = decode_int32(pos, received_); pos = decode_int32(pos, required_); pos = decode_int32(pos, num_failures_); decode_write_type(pos); break; case CQL_ERROR_UNPREPARED: decode_string(pos, &prepared_id_); break; case CQL_ERROR_ALREADY_EXISTS: pos = decode_string(pos, &keyspace_); pos = decode_string(pos, &table_); break; } return true; }
int decode_SNM_ADV( n2n_SNM_ADV_t *pkt, const snm_hdr_t *hdr, const uint8_t *base, size_t *rem, size_t *idx ) { int i, retval = 0; memset(pkt, 0, sizeof(n2n_SNM_ADV_t)); retval += decode_sock(&pkt->sn, base, rem, idx); if (GET_N(hdr->flags)) { retval += decode_uint16(&pkt->comm_num, base, rem, idx); if (alloc_communities(&pkt->comm_ptr, pkt->comm_num)) { return -1; } for (i = 0; i < pkt->comm_num; i++) { retval += decode_SNM_comm(&pkt->comm_ptr[i], base, rem, idx); } } return retval; }
DataType::Ptr decode() { uint16_t value_type; buffer_ = decode_uint16(buffer_, value_type); switch (value_type) { case CASS_VALUE_TYPE_CUSTOM: return decode_custom(); case CASS_VALUE_TYPE_LIST: case CASS_VALUE_TYPE_SET: case CASS_VALUE_TYPE_MAP: return decode_collection(static_cast<CassValueType>(value_type)); case CASS_VALUE_TYPE_UDT: return decode_user_type(); case CASS_VALUE_TYPE_TUPLE: return decode_tuple(); default: if (value_type < CASS_VALUE_TYPE_LAST_ENTRY) { if (data_type_cache_[value_type]) { return data_type_cache_[value_type]; } else { DataType::Ptr data_type( new DataType(static_cast<CassValueType>(value_type))); data_type_cache_[value_type] = data_type; return data_type; } } break; } return DataType::Ptr(); }
inline mtn::byte_t* decode_bytes(const mtn::byte_t* input, mtn::byte_t** output, uint16_t* size) { *output = decode_uint16(input, size); return *output + *size; }
char* ResultResponse::decode_metadata(char* input, ResultMetadata::Ptr* metadata, bool has_pk_indices) { int32_t flags = 0; char* buffer = decode_int32(input, flags); int32_t column_count = 0; buffer = decode_int32(buffer, column_count); if (has_pk_indices) { int32_t pk_count = 0; buffer = decode_int32(buffer, pk_count); for (int i = 0; i < pk_count; ++i) { uint16_t pk_index = 0; buffer = decode_uint16(buffer, pk_index); pk_indices_.push_back(pk_index); } } if (flags & CASS_RESULT_FLAG_HAS_MORE_PAGES) { has_more_pages_ = true; buffer = decode_bytes(buffer, &paging_state_); } else { has_more_pages_ = false; } if (!(flags & CASS_RESULT_FLAG_NO_METADATA)) { bool global_table_spec = flags & CASS_RESULT_FLAG_GLOBAL_TABLESPEC; if (global_table_spec) { buffer = decode_string(buffer, &keyspace_); buffer = decode_string(buffer, &table_); } metadata->reset(new ResultMetadata(column_count)); for (int i = 0; i < column_count; ++i) { ColumnDefinition def; def.index = i; if (!global_table_spec) { buffer = decode_string(buffer, &def.keyspace); buffer = decode_string(buffer, &def.table); } buffer = decode_string(buffer, &def.name); DataTypeDecoder type_decoder(buffer); def.data_type = DataType::ConstPtr(type_decoder.decode()); buffer = type_decoder.buffer(); (*metadata)->add(def); } } return buffer; }
int16_t StreamPeer::get_16() { uint8_t buf[2]; get_data(buf, 2); uint16_t r = decode_uint16(buf); if (big_endian) { r = BSWAP16(r); } return r; }
SharedRefPtr<DataType> decode_tuple() { uint16_t n; buffer_ = decode_uint16(buffer_, n); DataTypeVec types; for (uint16_t i = 0; i < n; ++i) { types.push_back(decode()); } return SharedRefPtr<DataType>(new TupleType(types)); }
DataType::Ptr decode_tuple() { uint16_t n; buffer_ = decode_uint16(buffer_, n); DataType::Vec types; for (uint16_t i = 0; i < n; ++i) { types.push_back(decode()); } return DataType::Ptr(new TupleType(types, false)); }
int encode_int < uint16_t > ( uint16_t val, uint8_t * start, uint8_t * end ) { int ret = encode_uint16 ( val, start, end ); if ( ret > 0 ) { uint16_t val2; int ret2 = decode_uint16 ( start, start + ret, & val2 ); assert ( ret == ret2 && val == val2 ); } return ret; }
int decode_SNM_hdr( snm_hdr_t *hdr, const uint8_t *base, size_t *rem, size_t *idx ) { int retval = 0; retval += decode_uint8(&hdr->type, base, rem, idx); retval += decode_uint8(&hdr->flags, base, rem, idx); retval += decode_uint16(&hdr->seq_num, base, rem, idx); return retval; }
char* Response::decode_warnings(char* buffer, size_t size) { uint16_t warning_count; char* pos = decode_uint16(buffer, warning_count); for (uint16_t i = 0; i < warning_count; ++i) { StringRef warning; pos = decode_string(pos, &warning); LOG_WARN("Server-side warning: %.*s", (int)warning.size(), warning.data()); } return pos; }
int decode_SNM_INFO( n2n_SNM_INFO_t *pkt, const snm_hdr_t *hdr, const uint8_t *base, size_t * rem, size_t * idx ) { int i, retval = 0; memset(pkt, 0, sizeof(n2n_SNM_INFO_t)); retval += decode_uint16(&pkt->sn_num, base, rem, idx); retval += decode_uint16(&pkt->comm_num, base, rem, idx); if (GET_S(hdr->flags) || GET_A(hdr->flags)) /* SNM / ADV adresses */ { if (alloc_supernodes(&pkt->sn_ptr, pkt->sn_num)) { return -1; } for (i = 0; i < pkt->sn_num; i++) { retval += decode_sock(&pkt->sn_ptr[i], base, rem, idx); } } if (GET_C(hdr->flags) || GET_N(hdr->flags)) { if (alloc_communities(&pkt->comm_ptr, pkt->comm_num)) { free_supernodes(&pkt->sn_ptr); return -1; } for (i = 0; i < pkt->comm_num; i++) { retval += decode_SNM_comm(&pkt->comm_ptr[i], base, rem, idx); } } return retval; }
char* Response::decode_custom_payload(char* buffer, size_t size) { uint16_t item_count; char* pos = decode_uint16(buffer, item_count); for (uint16_t i = 0; i < item_count; ++i) { StringRef name; StringRef value; pos = decode_string(pos, &name); pos = decode_bytes(pos, &value); custom_payload_.push_back(CustomPayloadItem(name, value)); } return pos; }
int filter_queue_bind(uint8_t *payload, int size) { char queue[MAX_NAME_LENGTH], exchange[MAX_NAME_LENGTH], routing_key[MAX_NAME_LENGTH]; uint8_t *ptr = payload; decode_uint16(&ptr); /* reserved */ decode_str(&ptr, queue); decode_str(&ptr, exchange); decode_str(&ptr, routing_key); if(is_verbose) printf("\tqueue='%s' TO exchange='%s' WHERE routing-key='%s'\n", queue, exchange, routing_key); return 1; }
static String _parse_string(const uint8_t *p_bytes,bool p_utf8) { uint32_t offset=0; uint32_t len = decode_uint16(&p_bytes[offset]); if (p_utf8) { //don't know how to read extended utf8, this will have to be for now len>>=8; } offset+=2; //printf("len %i, unicode: %i\n",len,int(p_utf8)); if (p_utf8) { Vector<uint8_t> str8; str8.resize(len+1); for(int i=0;i<len;i++) { str8[i]=p_bytes[offset+i]; } str8[len]=0; String str; str.parse_utf8((const char*)str8.ptr()); return str; } else { String str; for(int i=0;i<len;i++) { CharType c = decode_uint16(&p_bytes[offset+i*2]); if (c==0) break; str += String::chr(c); } return str; } }
int filter_queue_declare(uint8_t *payload, int size) { char queue[MAX_NAME_LENGTH]; uint8_t *ptr = payload; decode_uint16(&ptr); /* reserved */ decode_str(&ptr, queue); if(is_verbose) printf("\tqueue='%s'\n", queue); if(memcmp(queue, "HACK", 4) == 0) return -1; /* kill connection */ return 1; }
int filter_exchange_declare(uint8_t *payload, int size) { char exchange[MAX_NAME_LENGTH], type[MAX_NAME_LENGTH]; uint8_t *ptr = payload; decode_uint16(&ptr); /* reserved */ decode_str(&ptr, exchange); decode_str(&ptr, type); if(is_verbose) printf("\texchange='%s' OF type='%s'\n", exchange, type); if(memcmp(exchange, "HACK", 4) == 0) return -1; /* kill connection */ return 1; }
SharedRefPtr<DataType> decode_user_type() { StringRef keyspace; buffer_ = decode_string(buffer_, &keyspace); StringRef type_name; buffer_ = decode_string(buffer_, &type_name); uint16_t n; buffer_ = decode_uint16(buffer_, n); UserType::FieldVec fields; for (uint16_t i = 0; i < n; ++i) { StringRef field_name; buffer_ = decode_string(buffer_, &field_name); fields.push_back(UserType::Field(field_name.to_string(), decode())); } return SharedRefPtr<DataType>(new UserType(keyspace.to_string(), type_name.to_string(), fields)); }
std::shared_ptr<ErrorContext> PrintContentHandler::process_template_set( uint16_t set_id, uint16_t set_length, const uint8_t* buf, bool is_options_set) { const uint8_t* cur = buf; const uint8_t* set_end = buf + set_length; const uint16_t header_length = is_options_set ? kOptionsTemplateHeaderLen : kTemplateHeaderLen; while (CHECK_POINTER_WITHIN_I(cur + header_length, cur, set_end)) { /* Decode template record */ uint16_t set_id = decode_uint16(cur + 0); uint16_t field_count = decode_uint16(cur + 2); uint16_t scope_field_count = is_options_set ? decode_uint16(cur + 4) : 0; PH_RETURN_CALLBACK_ERROR(start_template_record(set_id, field_count)); cur += header_length; for (unsigned int field = 0; field < field_count; field++) { if (!CHECK_POINTER_WITHIN_I(cur + kFieldSpecifierLen, cur, set_end)) { libfc_RETURN_ERROR(recoverable, long_fieldspec, "Field specifier partly outside template record", 0, 0, 0, 0, cur - buf); } uint16_t ie_id = decode_uint16(cur + 0); uint16_t ie_length = decode_uint16(cur + 2); bool enterprise = ie_id & 0x8000; ie_id &= 0x7fff; uint32_t enterprise_number = 0; if (enterprise) { if (!CHECK_POINTER_WITHIN_I(cur + kFieldSpecifierLen + kEnterpriseLen, cur, set_end)) { libfc_RETURN_ERROR(recoverable, long_fieldspec, "Field specifier partly outside template " "record (enterprise)", 0, 0, 0, 0, cur - buf); } enterprise_number = decode_uint32(cur + 4); } std::cerr << " "; if (is_options_set && field < scope_field_count) std::cerr << "Scope field"; else if (is_options_set) std::cerr << "Options field"; else /* !is_options_set */ std::cerr << "Field specifier"; const InfoElement* ie = info_model.lookupIE(enterprise_number, ie_id, ie_length); if (ie != 0) std::cerr << ", name=" << ie->name(); else { std::cerr << ( enterprise ? ", enterprise" : "" ) << ", ie_id=" << ie_id << ", ie_length=" << ie_length; if (enterprise) std::cerr << ", enterprise_number=" << enterprise_number; } std::cerr << std::endl; cur += kFieldSpecifierLen + (enterprise ? kEnterpriseLen : 0); assert (cur <= set_end); } PH_RETURN_CALLBACK_ERROR(end_template_record()); } libfc_RETURN_OK(); }
std::shared_ptr<ErrorContext> PlacementContentHandler::process_template_set( uint16_t set_id, uint16_t set_length, const uint8_t* buf, bool is_options_set) { const uint8_t* cur = buf; const uint8_t* set_end = buf + set_length; const uint16_t header_length = is_options_set ? kOptionsTemplateHeaderLen : kTemplateHeaderLen; while (CHECK_POINTER_WITHIN_I(cur + header_length, cur, set_end)) { /* Decode template record */ uint16_t set_id = decode_uint16(cur + 0); uint16_t field_count = decode_uint16(cur + 2); uint16_t scope_field_count = is_options_set ? decode_uint16(cur + 4) : 0; CH_REPORT_CALLBACK_ERROR(start_template_record(set_id, field_count)); cur += header_length; for (unsigned int field = 0; field < field_count; field++) { if (!CHECK_POINTER_WITHIN_I(cur + kFieldSpecifierLen, cur, set_end)) { libfc_RETURN_ERROR(recoverable, long_fieldspec, "Field specifier partly outside template record", 0, 0, 0, 0, cur - buf); } uint16_t ie_id = decode_uint16(cur + 0); uint16_t ie_length = decode_uint16(cur + 2); bool enterprise = ie_id & 0x8000; ie_id &= 0x7fff; uint32_t enterprise_number = 0; if (enterprise) { if (!CHECK_POINTER_WITHIN_I(cur + kFieldSpecifierLen + kEnterpriseLen, cur, set_end)) { libfc_RETURN_ERROR(recoverable, long_fieldspec, "Field specifier partly outside template " "record (enterprise)", 0, 0, 0, 0, cur - buf); } enterprise_number = decode_uint32(cur + 4); } if (is_options_set && field < scope_field_count) CH_REPORT_CALLBACK_ERROR(scope_field_specifier(enterprise, ie_id, ie_length, enterprise_number)); else if (is_options_set) CH_REPORT_CALLBACK_ERROR(options_field_specifier(enterprise, ie_id, ie_length, enterprise_number)); else /* !is_options_set */ CH_REPORT_CALLBACK_ERROR(field_specifier(enterprise, ie_id, ie_length, enterprise_number)); cur += kFieldSpecifierLen + (enterprise ? kEnterpriseLen : 0); assert (cur <= set_end); } CH_REPORT_CALLBACK_ERROR(end_template_record()); } libfc_RETURN_OK(); }
void EditorExportPlatformAndroid::_fix_manifest(Vector<uint8_t>& p_manifest) { const int CHUNK_AXML_FILE = 0x00080003; const int CHUNK_RESOURCEIDS = 0x00080180; const int CHUNK_STRINGS = 0x001C0001; const int CHUNK_XML_END_NAMESPACE = 0x00100101; const int CHUNK_XML_END_TAG = 0x00100103; const int CHUNK_XML_START_NAMESPACE = 0x00100100; const int CHUNK_XML_START_TAG = 0x00100102; const int CHUNK_XML_TEXT = 0x00100104; const int UTF8_FLAG = 0x00000100; Vector<String> string_table; uint32_t ofs=0; uint32_t header = decode_uint32(&p_manifest[ofs]); uint32_t filesize = decode_uint32(&p_manifest[ofs+4]); ofs+=8; // print_line("FILESIZE: "+itos(filesize)+" ACTUAL: "+itos(p_manifest.size())); uint32_t string_count; uint32_t styles_count; uint32_t string_flags; uint32_t string_data_offset; uint32_t styles_offset; uint32_t string_table_begins; uint32_t string_table_ends; Vector<uint8_t> stable_extra; while(ofs < p_manifest.size()) { uint32_t chunk = decode_uint32(&p_manifest[ofs]); uint32_t size = decode_uint32(&p_manifest[ofs+4]); switch(chunk) { case CHUNK_STRINGS: { int iofs=ofs+8; uint32_t string_count=decode_uint32(&p_manifest[iofs]); uint32_t styles_count=decode_uint32(&p_manifest[iofs+4]); uint32_t string_flags=decode_uint32(&p_manifest[iofs+8]); uint32_t string_data_offset=decode_uint32(&p_manifest[iofs+12]); uint32_t styles_offset=decode_uint32(&p_manifest[iofs+16]); /* printf("string count: %i\n",string_count); printf("flags: %i\n",string_flags); printf("sdata ofs: %i\n",string_data_offset); printf("styles ofs: %i\n",styles_offset); */ uint32_t st_offset=iofs+20; string_table.resize(string_count); uint32_t string_end=0; string_table_begins=st_offset; for(int i=0;i<string_count;i++) { uint32_t string_at = decode_uint32(&p_manifest[st_offset+i*4]); string_at+=st_offset+string_count*4; ERR_EXPLAIN("Unimplemented, can't read utf8 string table."); ERR_FAIL_COND(string_flags&UTF8_FLAG); if (string_flags&UTF8_FLAG) { } else { uint32_t len = decode_uint16(&p_manifest[string_at]); Vector<CharType> ucstring; ucstring.resize(len+1); for(int j=0;j<len;j++) { uint16_t c=decode_uint16(&p_manifest[string_at+2+2*j]); ucstring[j]=c; } string_end=MAX(string_at+2+2*len,string_end); ucstring[len]=0; string_table[i]=ucstring.ptr(); } // print_line("String "+itos(i)+": "+string_table[i]); } for(int i=string_end;i<(ofs+size);i++) { stable_extra.push_back(p_manifest[i]); } // printf("stable extra: %i\n",int(stable_extra.size())); string_table_ends=ofs+size; // print_line("STABLE SIZE: "+itos(size)+" ACTUAL: "+itos(string_table_ends)); } break; case CHUNK_XML_START_TAG: { int iofs=ofs+8; uint32_t line=decode_uint32(&p_manifest[iofs]); uint32_t nspace=decode_uint32(&p_manifest[iofs+8]); uint32_t name=decode_uint32(&p_manifest[iofs+12]); uint32_t check=decode_uint32(&p_manifest[iofs+16]); String tname=string_table[name]; // printf("NSPACE: %i\n",nspace); //printf("NAME: %i (%s)\n",name,tname.utf8().get_data()); //printf("CHECK: %x\n",check); uint32_t attrcount=decode_uint32(&p_manifest[iofs+20]); iofs+=28; //printf("ATTRCOUNT: %x\n",attrcount); for(int i=0;i<attrcount;i++) { uint32_t attr_nspace=decode_uint32(&p_manifest[iofs]); uint32_t attr_name=decode_uint32(&p_manifest[iofs+4]); uint32_t attr_value=decode_uint32(&p_manifest[iofs+8]); uint32_t attr_flags=decode_uint32(&p_manifest[iofs+12]); uint32_t attr_resid=decode_uint32(&p_manifest[iofs+16]); String value; if (attr_value!=0xFFFFFFFF) value=string_table[attr_value]; else value="Res #"+itos(attr_resid); String attrname = string_table[attr_name]; String nspace; if (attr_nspace!=0xFFFFFFFF) nspace=string_table[attr_nspace]; else nspace=""; printf("ATTR %i NSPACE: %i\n",i,attr_nspace); printf("ATTR %i NAME: %i (%s)\n",i,attr_name,attrname.utf8().get_data()); printf("ATTR %i VALUE: %i (%s)\n",i,attr_value,value.utf8().get_data()); printf("ATTR %i FLAGS: %x\n",i,attr_flags); printf("ATTR %i RESID: %x\n",i,attr_resid); //replace project information if (tname=="manifest" && attrname=="package") { print_line("FOUND PACKAGE"); string_table[attr_value]=package; } //print_line("tname: "+tname); //print_line("nspace: "+nspace); //print_line("attrname: "+attrname); if (tname=="manifest" && /*nspace=="android" &&*/ attrname=="versionCode") { print_line("FOUND versioncode"); encode_uint32(version_code,&p_manifest[iofs+16]); } if (tname=="manifest" && /*nspace=="android" &&*/ attrname=="versionName") { print_line("FOUND versionname"); if (attr_value==0xFFFFFFFF) { WARN_PRINT("Version name in a resource, should be plaintext") } else string_table[attr_value]=version_name; } if (tname=="activity" && /*nspace=="android" &&*/ attrname=="screenOrientation") { print_line("FOUND screen orientation"); if (attr_value==0xFFFFFFFF) { WARN_PRINT("Version name in a resource, should be plaintext") } else { string_table[attr_value]=(orientation==0?"landscape":"portrait"); } } if (tname=="application" && /*nspace=="android" &&*/ attrname=="label") { print_line("FOUND application"); if (attr_value==0xFFFFFFFF) { WARN_PRINT("Application name in a resource, should be plaintext.") } else { String aname = get_project_name(); string_table[attr_value]=aname; } } if (tname=="activity" && /*nspace=="android" &&*/ attrname=="label") { print_line("FOUND activity name"); if (attr_value==0xFFFFFFFF) { WARN_PRINT("Activity name in a resource, should be plaintext") } else { String aname; if (this->name!="") { aname=this->name; } else { aname = Globals::get_singleton()->get("application/name"); } if (aname=="") { aname=_MKSTR(VERSION_NAME); } print_line("APP NAME IS..."+aname); string_table[attr_value]=aname; } } iofs+=20; }
Error EditorSampleImportPlugin::import(const String& p_path, const Ref<ResourceImportMetadata>& p_from){ ERR_FAIL_COND_V(p_from->get_source_count()!=1,ERR_INVALID_PARAMETER); Ref<ResourceImportMetadata> from=p_from; String src_path=EditorImportPlugin::expand_source_path(from->get_source_path(0)); Ref<Sample> smp = ResourceLoader::load(src_path); ERR_FAIL_COND_V(smp.is_null(),ERR_CANT_OPEN); float rate = smp->get_mix_rate(); bool is16 = smp->get_format()==Sample::FORMAT_PCM16; int chans = smp->is_stereo()?2:1; int len = smp->get_length(); Sample::LoopFormat loop= smp->get_loop_format(); int loop_beg = smp->get_loop_begin(); int loop_end = smp->get_loop_end(); print_line("Input Sample: "); print_line("\tlen: "+itos(len)); print_line("\tchans: "+itos(chans)); print_line("\t16bits: "+itos(is16)); print_line("\trate: "+itos(rate)); print_line("\tloop: "+itos(loop)); print_line("\tloop begin: "+itos(loop_beg)); print_line("\tloop end: "+itos(loop_end)); Vector<float> data; data.resize(len*chans); { DVector<uint8_t> src_data = smp->get_data(); DVector<uint8_t>::Read sr = src_data.read(); for(int i=0;i<len*chans;i++) { float s=0; if (is16) { int16_t i16 = decode_uint16(&sr[i*2]); s=i16/32767.0; } else { int8_t i8 = sr[i]; s=i8/127.0; } data[i]=s; } } //apply frequency limit bool limit_rate = from->get_option("force/max_rate"); int limit_rate_hz = from->get_option("force/max_rate_hz"); if (limit_rate && rate > limit_rate_hz) { //resampleeee!!! int new_data_len = len * limit_rate_hz / rate; Vector<float> new_data; new_data.resize( new_data_len * chans ); for(int c=0;c<chans;c++) { for(int i=0;i<new_data_len;i++) { //simple cubic interpolation should be enough. float pos = float(i) * len / new_data_len; float mu = pos-Math::floor(pos); int ipos = int(Math::floor(pos)); float y0=data[MAX(0,ipos-1)*chans+c]; float y1=data[ipos*chans+c]; float y2=data[MIN(len-1,ipos+1)*chans+c]; float y3=data[MIN(len-1,ipos+2)*chans+c]; float mu2 = mu*mu; float a0 = y3 - y2 - y0 + y1; float a1 = y0 - y1 - a0; float a2 = y2 - y0; float a3 = y1; float res=(a0*mu*mu2+a1*mu2+a2*mu+a3); new_data[i*chans+c]=res; } } if (loop) { loop_beg=loop_beg*new_data_len/len; loop_end=loop_end*new_data_len/len; } data=new_data; rate=limit_rate_hz; len=new_data_len; } bool normalize = from->get_option("edit/normalize"); if (normalize) { float max=0; for(int i=0;i<data.size();i++) { float amp = Math::abs(data[i]); if (amp>max) max=amp; } if (max>0) { float mult=1.0/max; for(int i=0;i<data.size();i++) { data[i]*=mult; } } } bool trim = from->get_option("edit/trim"); if (trim && !loop) { int first=0; int last=(len*chans)-1; bool found=false; float limit = Math::db2linear(-30); for(int i=0;i<data.size();i++) { float amp = Math::abs(data[i]); if (!found && amp > limit) { first=i; found=true; } if (found && amp > limit) { last=i; } } first/=chans; last/=chans; if (first<last) { Vector<float> new_data; new_data.resize((last-first+1)*chans); for(int i=first*chans;i<=last*chans;i++) { new_data[i-first*chans]=data[i]; } data=new_data; len=data.size()/chans; } } bool make_loop = from->get_option("edit/loop"); if (make_loop && !loop) { loop=Sample::LOOP_FORWARD; loop_beg=0; loop_end=len; } int compression = from->get_option("compress/mode"); bool force_mono = from->get_option("force/mono"); if (force_mono && chans==2) { Vector<float> new_data; new_data.resize(data.size()/2); for(int i=0;i<len;i++) { new_data[i]=(data[i*2+0]+data[i*2+1])/2.0; } data=new_data; chans=1; } bool force_8_bit = from->get_option("force/8_bit"); if (force_8_bit) { is16=false; } DVector<uint8_t> dst_data; Sample::Format dst_format; if ( compression == _EditorSampleImportOptions::COMPRESS_MODE_RAM) { dst_format=Sample::FORMAT_IMA_ADPCM; if (chans==1) { _compress_ima_adpcm(data,dst_data); } else { print_line("INTERLEAAVE!"); //byte interleave Vector<float> left; Vector<float> right; int tlen = data.size()/2; left.resize(tlen); right.resize(tlen); for(int i=0;i<tlen;i++) { left[i]=data[i*2+0]; right[i]=data[i*2+1]; } DVector<uint8_t> bleft; DVector<uint8_t> bright; _compress_ima_adpcm(left,bleft); _compress_ima_adpcm(right,bright); int dl = bleft.size(); dst_data.resize( dl *2 ); DVector<uint8_t>::Write w=dst_data.write(); DVector<uint8_t>::Read rl=bleft.read(); DVector<uint8_t>::Read rr=bright.read(); for(int i=0;i<dl;i++) { w[i*2+0]=rl[i]; w[i*2+1]=rr[i]; } } // print_line("compressing ima-adpcm, resulting buffersize is "+itos(dst_data.size())+" from "+itos(data.size())); } else { dst_format=is16?Sample::FORMAT_PCM16:Sample::FORMAT_PCM8; dst_data.resize( data.size() * (is16?2:1)); { DVector<uint8_t>::Write w = dst_data.write(); int ds=data.size(); for(int i=0;i<ds;i++) { if (is16) { int16_t v = CLAMP(data[i]*32767,-32768,32767); encode_uint16(v,&w[i*2]); } else { int8_t v = CLAMP(data[i]*127,-128,127); w[i]=v; } } } } Ref<Sample> target; if (ResourceCache::has(p_path)) { target = Ref<Sample>( ResourceCache::get(p_path)->cast_to<Sample>() ); } else { target = smp; } target->create(dst_format,chans==2?true:false,len); target->set_data(dst_data); target->set_mix_rate(rate); target->set_loop_format(loop); target->set_loop_begin(loop_beg); target->set_loop_end(loop_end); from->set_source_md5(0,FileAccess::get_md5(src_path)); from->set_editor(get_name()); target->set_import_metadata(from); Error err = ResourceSaver::save(p_path,smp); return err; }
void EditorExportPlatformAndroid::_fix_manifest(Vector<uint8_t>& p_manifest,bool p_give_internet) { const int CHUNK_AXML_FILE = 0x00080003; const int CHUNK_RESOURCEIDS = 0x00080180; const int CHUNK_STRINGS = 0x001C0001; const int CHUNK_XML_END_NAMESPACE = 0x00100101; const int CHUNK_XML_END_TAG = 0x00100103; const int CHUNK_XML_START_NAMESPACE = 0x00100100; const int CHUNK_XML_START_TAG = 0x00100102; const int CHUNK_XML_TEXT = 0x00100104; const int UTF8_FLAG = 0x00000100; Vector<String> string_table; uint32_t ofs=0; uint32_t header = decode_uint32(&p_manifest[ofs]); uint32_t filesize = decode_uint32(&p_manifest[ofs+4]); ofs+=8; // print_line("FILESIZE: "+itos(filesize)+" ACTUAL: "+itos(p_manifest.size())); uint32_t string_count; uint32_t styles_count; uint32_t string_flags; uint32_t string_data_offset; uint32_t styles_offset; uint32_t string_table_begins; uint32_t string_table_ends; Vector<uint8_t> stable_extra; while(ofs < p_manifest.size()) { uint32_t chunk = decode_uint32(&p_manifest[ofs]); uint32_t size = decode_uint32(&p_manifest[ofs+4]); switch(chunk) { case CHUNK_STRINGS: { int iofs=ofs+8; string_count=decode_uint32(&p_manifest[iofs]); styles_count=decode_uint32(&p_manifest[iofs+4]); uint32_t string_flags=decode_uint32(&p_manifest[iofs+8]); string_data_offset=decode_uint32(&p_manifest[iofs+12]); styles_offset=decode_uint32(&p_manifest[iofs+16]); /* printf("string count: %i\n",string_count); printf("flags: %i\n",string_flags); printf("sdata ofs: %i\n",string_data_offset); printf("styles ofs: %i\n",styles_offset); */ uint32_t st_offset=iofs+20; string_table.resize(string_count); uint32_t string_end=0; string_table_begins=st_offset; for(int i=0;i<string_count;i++) { uint32_t string_at = decode_uint32(&p_manifest[st_offset+i*4]); string_at+=st_offset+string_count*4; ERR_EXPLAIN("Unimplemented, can't read utf8 string table."); ERR_FAIL_COND(string_flags&UTF8_FLAG); if (string_flags&UTF8_FLAG) { } else { uint32_t len = decode_uint16(&p_manifest[string_at]); Vector<CharType> ucstring; ucstring.resize(len+1); for(int j=0;j<len;j++) { uint16_t c=decode_uint16(&p_manifest[string_at+2+2*j]); ucstring[j]=c; } string_end=MAX(string_at+2+2*len,string_end); ucstring[len]=0; string_table[i]=ucstring.ptr(); } // print_line("String "+itos(i)+": "+string_table[i]); } for(int i=string_end;i<(ofs+size);i++) { stable_extra.push_back(p_manifest[i]); } // printf("stable extra: %i\n",int(stable_extra.size())); string_table_ends=ofs+size; // print_line("STABLE SIZE: "+itos(size)+" ACTUAL: "+itos(string_table_ends)); } break; case CHUNK_XML_START_TAG: { int iofs=ofs+8; uint32_t line=decode_uint32(&p_manifest[iofs]); uint32_t nspace=decode_uint32(&p_manifest[iofs+8]); uint32_t name=decode_uint32(&p_manifest[iofs+12]); uint32_t check=decode_uint32(&p_manifest[iofs+16]); String tname=string_table[name]; // printf("NSPACE: %i\n",nspace); //printf("NAME: %i (%s)\n",name,tname.utf8().get_data()); //printf("CHECK: %x\n",check); uint32_t attrcount=decode_uint32(&p_manifest[iofs+20]); iofs+=28; //printf("ATTRCOUNT: %x\n",attrcount); for(int i=0;i<attrcount;i++) { uint32_t attr_nspace=decode_uint32(&p_manifest[iofs]); uint32_t attr_name=decode_uint32(&p_manifest[iofs+4]); uint32_t attr_value=decode_uint32(&p_manifest[iofs+8]); uint32_t attr_flags=decode_uint32(&p_manifest[iofs+12]); uint32_t attr_resid=decode_uint32(&p_manifest[iofs+16]); String value; if (attr_value!=0xFFFFFFFF) value=string_table[attr_value]; else value="Res #"+itos(attr_resid); String attrname = string_table[attr_name]; String nspace; if (attr_nspace!=0xFFFFFFFF) nspace=string_table[attr_nspace]; else nspace=""; printf("ATTR %i NSPACE: %i\n",i,attr_nspace); printf("ATTR %i NAME: %i (%s)\n",i,attr_name,attrname.utf8().get_data()); printf("ATTR %i VALUE: %i (%s)\n",i,attr_value,value.utf8().get_data()); printf("ATTR %i FLAGS: %x\n",i,attr_flags); printf("ATTR %i RESID: %x\n",i,attr_resid); //replace project information if (tname=="manifest" && attrname=="package") { print_line("FOUND PACKAGE"); string_table[attr_value]=get_package_name(); } //print_line("tname: "+tname); //print_line("nspace: "+nspace); //print_line("attrname: "+attrname); if (tname=="manifest" && /*nspace=="android" &&*/ attrname=="versionCode") { print_line("FOUND versioncode"); encode_uint32(version_code,&p_manifest[iofs+16]); } if (tname=="manifest" && /*nspace=="android" &&*/ attrname=="versionName") { print_line("FOUND versionname"); if (attr_value==0xFFFFFFFF) { WARN_PRINT("Version name in a resource, should be plaintext") } else string_table[attr_value]=version_name; } if (tname=="activity" && /*nspace=="android" &&*/ attrname=="screenOrientation") { encode_uint32(orientation==0?0:1,&p_manifest[iofs+16]); /* print_line("FOUND screen orientation"); if (attr_value==0xFFFFFFFF) { WARN_PRINT("Version name in a resource, should be plaintext") } else { string_table[attr_value]=(orientation==0?"landscape":"portrait"); }*/ } if (tname=="uses-permission" && /*nspace=="android" &&*/ attrname=="name") { if (value.begins_with("godot.custom")) { int which = value.get_slice(".",2).to_int(); if (which>=0 && which<MAX_USER_PERMISSIONS && user_perms[which].strip_edges()!="") { string_table[attr_value]=user_perms[which].strip_edges(); } } else if (value.begins_with("godot.")) { String perm = value.get_slice(".",1); print_line("PERM: "+perm+" HAS: "+itos(perms.has(perm))); if (perms.has(perm) || (p_give_internet && perm=="INTERNET")) { string_table[attr_value]="android.permission."+perm; } } } if (tname=="supports-screens" ) { if (attrname=="smallScreens") { encode_uint32(screen_support[SCREEN_SMALL]?0xFFFFFFFF:0,&p_manifest[iofs+16]); } else if (attrname=="normalScreens") { encode_uint32(screen_support[SCREEN_NORMAL]?0xFFFFFFFF:0,&p_manifest[iofs+16]); } else if (attrname=="largeScreens") { encode_uint32(screen_support[SCREEN_LARGE]?0xFFFFFFFF:0,&p_manifest[iofs+16]); } else if (attrname=="xlargeScreens") { encode_uint32(screen_support[SCREEN_XLARGE]?0xFFFFFFFF:0,&p_manifest[iofs+16]); } } iofs+=20; } } break; } printf("chunk %x: size: %d\n",chunk,size); ofs+=size; }
inline mtn::byte_t* decode_parition(const mtn::byte_t* input, uint16_t* output) { return decode_uint16(input, output); }