int encode_SNM_INFO( uint8_t *base, size_t *idx, const snm_hdr_t *hdr, const n2n_SNM_INFO_t *info ) { int i, retval = 0; retval += encode_SNM_hdr(base, idx, hdr); retval += encode_uint16(base, idx, info->sn_num); retval += encode_uint16(base, idx, info->comm_num); if (GET_S(hdr->flags) || GET_A(hdr->flags)) /* SNM / ADV adresses */ { for (i = 0; i < info->sn_num; i++) { retval += encode_sock(base, idx, &info->sn_ptr[i]); } } if (GET_C(hdr->flags) || GET_N(hdr->flags)) { for (i = 0; i < info->comm_num; i++) { retval += encode_SNM_comm(base, idx, &info->comm_ptr[i]); } } return retval; }
DVector<int> TileMap::_get_tile_data() const { DVector<int> data; data.resize(tile_map.size()*2); DVector<int>::Write w = data.write(); int idx=0; for(const Map<PosKey,Cell>::Element *E=tile_map.front();E;E=E->next()) { uint8_t *ptr = (uint8_t*)&w[idx]; encode_uint16(E->key().x,&ptr[0]); encode_uint16(E->key().y,&ptr[2]); uint32_t val = E->get().id; if (E->get().flip_h) val|=(1<<29); if (E->get().flip_v) val|=(1<<30); encode_uint32(val,&ptr[4]); idx+=2; } w = DVector<int>::Write(); return data; }
void test_command_with_args() { uint8_t buf[255]; int pos = 0; int rc; uint8_t dest; uint8_t code; uint16_t mref; rc = encode_cmd(buf, &pos, LS1P_ADDR_ARM, LS1P_REQ_CODE_CMDLOG, 314); assert(rc == LS1P_API_OK); assert(pos == 3); assert(buf[0] == 0x01); rc = encode_uint8(buf, &pos, 123); assert(rc == LS1P_API_OK); assert(pos == 4); rc = encode_uint16(buf, &pos, 4023); assert(rc == LS1P_API_OK); assert(pos == 6); assert(buf[0] == 0x01); assert(buf[1] == 0x01); assert(buf[2] == 0x3A); assert(buf[3] == 0x7B); assert(buf[4] == 0x0F); assert(buf[5] == 0xB7); rc = decode_cmd(buf, &pos, &dest, &code, &mref); assert(rc == LS1P_API_OK); assert(dest == LS1P_ADDR_ARM); assert(code == LS1P_REQ_CODE_CMDLOG); assert(mref == 314); assert(pos == 3); }
inline mtn::byte_t* encode_bytes(const mtn::byte_t* input, uint16_t size, mtn::byte_t* output) { memcpy(encode_uint16(size, output), input, size); return output + size + sizeof(uint16_t); }
size_t encode_string_list(size_t offset, const std::vector<std::string>& value) { size_t pos = encode_uint16(offset, static_cast<uint16_t>(value.size())); for (std::vector<std::string>::const_iterator it = value.begin(), end = value.end(); it != end; ++it) { pos = encode_string(pos, it->data(), static_cast<uint16_t>(it->size())); } return pos; }
size_t encode_string_map(size_t offset, const std::map<std::string, std::string>& value) { size_t pos = encode_uint16(offset, static_cast<uint16_t>(value.size())); for (std::map<std::string, std::string>::const_iterator it = value.begin(); it != value.end(); ++it) { pos = encode_string(pos, it->first.c_str(), static_cast<uint16_t>(it->first.size())); pos = encode_string(pos, it->second.c_str(), static_cast<uint16_t>(it->second.size())); } return pos; }
void StreamPeer::put_16(int16_t p_val) { if (big_endian) { p_val = BSWAP16(p_val); } uint8_t buf[2]; encode_uint16(p_val, buf); put_data(buf, 2); }
void Collection::encode_items_uint16(char* buf) const { for (BufferVec::const_iterator i = items_.begin(), end = items_.end(); i != end; ++i) { encode_uint16(buf, i->size()); buf += sizeof(uint16_t); memcpy(buf, i->data(), i->size()); buf += i->size(); } }
int encode_SNM_hdr( uint8_t *base, size_t *idx, const snm_hdr_t *hdr ) { int retval = 0; retval += encode_uint8(base, idx, hdr->type); retval += encode_uint8(base, idx, hdr->flags); retval += encode_uint16(base, idx, hdr->seq_num); return retval; }
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; }
void BufferCollection::encode(int version, char* buf) const { assert(version == 1 || version == 2); char* pos = buf; for (BufferVec::const_iterator it = bufs_.begin(), end = bufs_.end(); it != end; ++it) { encode_uint16(pos, it->size()); pos += sizeof(uint16_t); memcpy(pos, it->data(), it->size()); pos += it->size(); } }
bool Statement::calculate_routing_key(const std::vector<size_t>& key_indices, std::string* routing_key) const { if (key_indices.empty()) return false; if (key_indices.size() == 1) { assert(key_indices.front() < elements().size()); const AbstractData::Element& element(elements()[key_indices.front()]); if (element.is_unset() || element.is_null()) { return false; } Buffer buf(element.get_buffer(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION)); routing_key->assign(buf.data() + sizeof(int32_t), buf.size() - sizeof(int32_t)); } else { size_t length = 0; for (std::vector<size_t>::const_iterator i = key_indices.begin(); i != key_indices.end(); ++i) { assert(*i < elements().size()); const AbstractData::Element& element(elements()[*i]); if (element.is_unset() || element.is_null()) { return false; } size_t size = element.get_size(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION) - sizeof(int32_t); length += sizeof(uint16_t) + size + 1; } routing_key->clear(); routing_key->reserve(length); for (std::vector<size_t>::const_iterator i = key_indices.begin(); i != key_indices.end(); ++i) { const AbstractData::Element& element(elements()[*i]); Buffer buf(element.get_buffer(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION)); size_t size = buf.size() - sizeof(int32_t); char size_buf[sizeof(uint16_t)]; encode_uint16(size_buf, size); routing_key->append(size_buf, sizeof(uint16_t)); routing_key->append(buf.data() + sizeof(int32_t), size); routing_key->push_back(0); } } return true; }
int encode_SNM_REQ( uint8_t *base, size_t *idx, const snm_hdr_t *hdr, const n2n_SNM_REQ_t *req ) { int i, retval = 0; retval += encode_SNM_hdr(base, idx, hdr); if (GET_N(hdr->flags)) { retval += encode_uint16(base, idx, req->comm_num); for (i = 0; i < req->comm_num; i++) { retval += encode_SNM_comm(base, idx, &req->comm_ptr[i]); } } return retval; }
int encode_SNM_ADV( uint8_t *base, size_t *idx, const snm_hdr_t *hdr, const n2n_SNM_ADV_t *adv ) { int i, retval = 0; retval += encode_SNM_hdr(base, idx, hdr); retval += encode_sock(base, idx, &adv->sn); if (GET_N(hdr->flags)) { retval += encode_uint16(base, idx, adv->comm_num); for (i = 0; i < adv->comm_num; i++) { retval += encode_SNM_comm(base, idx, &adv->comm_ptr[i]); } } return retval; }
size_t encode_string(size_t offset, const char* value, uint16_t size) { size_t pos = encode_uint16(offset, size); return copy(pos, value, size); }
inline mtn::byte_t* encode_parition(uint16_t input, mtn::byte_t* output) { return encode_uint16(input, output); }
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_resources(Vector<uint8_t>& p_manifest) { const int UTF8_FLAG = 0x00000100; print_line("*******************GORRRGLE***********************"); uint32_t header = decode_uint32(&p_manifest[0]); uint32_t filesize = decode_uint32(&p_manifest[4]); uint32_t string_block_len = decode_uint32(&p_manifest[16]); uint32_t string_count = decode_uint32(&p_manifest[20]); uint32_t string_flags = decode_uint32(&p_manifest[28]); const uint32_t string_table_begins = 40; Vector<String> string_table; printf("stirng block len: %i\n",string_block_len); printf("stirng count: %i\n",string_count); printf("flags: %x\n",string_flags); for(int i=0;i<string_count;i++) { uint32_t offset = decode_uint32(&p_manifest[string_table_begins+i*4]); offset+=string_table_begins+string_count*4; String str = _parse_string(&p_manifest[offset],string_flags&UTF8_FLAG); if (str.begins_with("godot-project-name")) { if (str=="godot-project-name") { //project name str = get_project_name(); } else { String lang = str.substr(str.find_last("-")+1,str.length()).replace("-","_"); String prop = "application/name_"+lang; if (Globals::get_singleton()->has(prop)) { str = Globals::get_singleton()->get(prop); } else { str = get_project_name(); } } } string_table.push_back(str); } //write a new string table, but use 16 bits Vector<uint8_t> ret; ret.resize(string_table_begins+string_table.size()*4); for(int i=0;i<string_table_begins;i++) { ret[i]=p_manifest[i]; } int ofs=0; for(int i=0;i<string_table.size();i++) { encode_uint32(ofs,&ret[string_table_begins+i*4]); ofs+=string_table[i].length()*2+2+2; } ret.resize(ret.size()+ofs); uint8_t *chars=&ret[ret.size()-ofs]; for(int i=0;i<string_table.size();i++) { String s = string_table[i]; encode_uint16(s.length(),chars); chars+=2; for(int j=0;j<s.length();j++) { encode_uint16(s[j],chars); chars+=2; } encode_uint16(0,chars); chars+=2; } //pad while(ret.size()%4) ret.push_back(0); //change flags to not use utf8 encode_uint32(string_flags&~0x100,&ret[28]); //change length encode_uint32(ret.size()-12,&ret[16]); //append the rest... int rest_from = 12+string_block_len; int rest_to = ret.size(); int rest_len = (p_manifest.size() - rest_from); ret.resize(ret.size() + (p_manifest.size() - rest_from) ); for(int i=0;i<rest_len;i++) { ret[rest_to+i]=p_manifest[rest_from+i]; } //finally update the size encode_uint32(ret.size(),&ret[4]); p_manifest=ret; printf("end\n"); }
Ref<AudioStreamSample> AudioEffectRecord::get_recording() const { AudioStreamSample::Format dst_format = format; bool stereo = true; //forcing mono is not implemented PoolVector<uint8_t> dst_data; if (dst_format == AudioStreamSample::FORMAT_8_BITS) { int data_size = current_instance->recording_data.size(); dst_data.resize(data_size); PoolVector<uint8_t>::Write w = dst_data.write(); for (int i = 0; i < data_size; i++) { int8_t v = CLAMP(current_instance->recording_data[i] * 128, -128, 127); w[i] = v; } } else if (dst_format == AudioStreamSample::FORMAT_16_BITS) { int data_size = current_instance->recording_data.size(); dst_data.resize(data_size * 2); PoolVector<uint8_t>::Write w = dst_data.write(); for (int i = 0; i < data_size; i++) { int16_t v = CLAMP(current_instance->recording_data[i] * 32768, -32768, 32767); encode_uint16(v, &w[i * 2]); } } else if (dst_format == AudioStreamSample::FORMAT_IMA_ADPCM) { //byte interleave Vector<float> left; Vector<float> right; int tframes = current_instance->recording_data.size() / 2; left.resize(tframes); right.resize(tframes); for (int i = 0; i < tframes; i++) { left.set(i, current_instance->recording_data[i * 2 + 0]); right.set(i, current_instance->recording_data[i * 2 + 1]); } PoolVector<uint8_t> bleft; PoolVector<uint8_t> bright; ResourceImporterWAV::_compress_ima_adpcm(left, bleft); ResourceImporterWAV::_compress_ima_adpcm(right, bright); int dl = bleft.size(); dst_data.resize(dl * 2); PoolVector<uint8_t>::Write w = dst_data.write(); PoolVector<uint8_t>::Read rl = bleft.read(); PoolVector<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]; } } else { ERR_PRINT("Format not implemented."); } Ref<AudioStreamSample> sample; sample.instance(); sample->set_data(dst_data); sample->set_format(dst_format); sample->set_mix_rate(AudioServer::get_singleton()->get_mix_rate()); sample->set_loop_mode(AudioStreamSample::LOOP_DISABLED); sample->set_loop_begin(0); sample->set_loop_end(0); sample->set_stereo(stereo); return sample; }