uint32_t EEPROM_24XX1025::write(uint32_t fulladdr, const void *data, uint32_t bytesToWrite) { // Uses writeChunk to allow any-sized writes, not just <128 bytes if (bytesToWrite == 0) return 0; if (bytesToWrite <= 128) return writeChunk(fulladdr, data, bytesToWrite); if (fulladdr + bytesToWrite >= DEVICE_SIZE) bytesToWrite = DEVICE_SIZE - fulladdr; // constrain read size to end of device // If we get here, we have a >128 byte write that is now constrained to a valid range. uint32_t bytesWritten = 0; uint32_t t = 0; while (bytesWritten < bytesToWrite) { t = writeChunk(fulladdr + bytesWritten, (const void*)((byte *)data + bytesWritten), min(128, bytesToWrite - bytesWritten)); if (t == min(128, bytesToWrite - bytesWritten)) bytesWritten += t; else return bytesWritten; //Failure! } return bytesWritten; }
void writeWorld(World *world, char *file_path) { FILE *out = fopen(file_path, "wb"); if (!out) { fprintf(stderr, "Error writing %s: file not found\n", file_path); return; } fwrite(&world->size, sizeof(world->size), 1, out); for (int i = 0; i < world->num_chunks; i++) { writeChunk(world->chunks[i], out); } fclose(out); }
void writeChunk(Chunk *chunk, FILE *out) { RLE_BlockData buf = (RLE_BlockData){0}; BlockData data = (BlockData){0}; Block *block; for (int i=0; i < CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE; i++) { block = &chunk->blocks_lin[i]; data.logic = !!(block->logic); data.data = !data.logic && block->data; if (data.logic) { data.logic_type = block->logic->type; data.logic_roll = block->logic->roll; data.logic_pitch = block->logic->pitch; data.logic_yaw = block->logic->yaw; } data.color = block->color; char equal = data.logic == buf.data.logic && data.data == !!buf.data.data && (!data.logic || (data.logic_type == buf.data.logic_type && data.logic_roll == buf.data.logic_roll && data.logic_pitch == buf.data.logic_pitch && data.logic_yaw == buf.data.logic_yaw)) && data.color.all == buf.data.color.all && !data.data; if (equal) { buf.count++; } else { if (buf.count) fwrite(&buf, sizeof(RLE_BlockData), 1, out); buf.count = 1; buf.data = data; if (data.data) { fwrite(&buf, sizeof(buf), 1, out); buf.count = 0; buf.data = (BlockData){0}; writeChunk(block->data->chunk, out); } } data = (BlockData){0}; } if (buf.count) fwrite(&buf, sizeof(buf), 1, out); }
void HttpReqImpl::finishChunk() { if (!bNeedContinue && !closeConn) { while (remainPostData > 0) { char buff[256]; read(buff,256); } } if (useChunked) { if (!chunkBuff.empty()) { writeChunk(chunkBuff.data(),chunkBuff.length()); chunkBuff.clear(); } PrintTextA p(*inout); p.setNL("\r\n"); p("0\n\n"); } flush(); }
void writeAPNG( const std::string & filename, const std::vector<RMatrixXu8> & labels ) { eassert( labels.size()>0 ); int N=labels.size(),W=labels[0].cols(),H=labels[0].rows(); std::ofstream os( filename.c_str(), std::fstream::out | std::fstream::binary ); char magic[9]="\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"; os.write( magic, 8 ); writeHDR( os, W, H ); writePLTE( os, true ); writeACTL( os, N ); for( int i=0, seq_n=0; i<N; i++ ) { writeFCTL( os, seq_n++, W, H ); std::vector<char> data( H*(W+1), 0 ); RMatrixXu8::Map( reinterpret_cast<uint8_t*>(data.data()), H, W+1 ).rightCols(W) = labels[i]; if(!i) writeDat( os, data ); else writeFDat( os, data, seq_n++ ); } writeChunk( os, "IEND", std::vector<char>() ); }
void JPWiFly::sendPage(const prog_char* page, bool(*value)(const prog_char*, size_t, String&, bool*, void*), void* context) { writeDataLn_P(PSTR("HTTP/1.1 200 OK")); writeDataLn_P(PSTR("Content-Type: text/html")); writeDataLn_P(PSTR("Transfer-Encoding: chunked")); writeDataLn(); const prog_char* cur_ptr = page; const prog_char* next_ptr; while ((next_ptr = str_Pstr_P(cur_ptr, kThreeDots)) != NULL) { writeChunkN_P(cur_ptr, next_ptr - cur_ptr); const prog_char* var_name = next_ptr + kLenThreeDots; next_ptr = str_Pstr_P(var_name, kThreeDots); if (next_ptr) { String content; bool isLast = false; while (value && !isLast && (*value)(var_name, next_ptr - var_name, content, &isLast, context)) writeChunk(content.c_str()); cur_ptr = next_ptr + kLenThreeDots; } else cur_ptr = var_name; } writeChunk_P(cur_ptr); writeChunkln(); close(); }
bool writeSMM0 (FILE *file, const char **errorString, const sid_usage_t &usage, const SidTuneInfo &tuneInfo) { struct Smm_v0 smm0; uint_least32_t headings = 3; /* Mandatory */ endian_big32 (smm0.header.type, SMM0_ID); endian_big16 (smm0.error.flags, (uint_least16_t) usage.flags); // Optional if (usage.length == 0) smm0.time.length = 0; else { endian_big16 (smm0.time.stamp, (uint_least16_t) usage.length); headings++; } { uint_least16_t load = tuneInfo.loadAddr; uint_least16_t last = load + (tuneInfo.c64dataLen - 1); endian_big16 (smm0.info.startAddr, load); endian_big16 (smm0.info.stopAddr, last); } // Optional if ( usage.md5[0] == '\0' ) smm0.md5.length = 0; else { {for (int i = 0; i < 32; i++) smm0.md5.key[i] = usage.md5[i]; } headings++; } { uint8_t i = 0; smm0.body.length = 0; {for (int page = 0; page < 0x100; page++) { char used = 0; for (int j = 0; j < 0x100; j++) used |= (usage.memory[(page << 8) | j] & 0x7f); if (used) { smm0.body.length += 0x101; memcpy (smm0.body.usage[i].flags, &usage.memory[page << 8], 0x100); smm0.body.usage[i].page = (uint8_t) page; i++; } }} } uint_least32_t filelength = smm0.header.length + smm0.error.length + smm0.info.length + smm0.md5.length + smm0.time.length + smm0.body.length + (sizeof (uint8_t) * 8 * headings); if ( writeChunk (file, smm0.header, FORM_ID, filelength) == false ) goto writeSMM0_error; if ( writeChunk (file, smm0.error, ERR0_ID) == false ) goto writeSMM0_error; if ( writeChunk (file, smm0.info, INF0_ID) == false ) goto writeSMM0_error; if ( writeChunk (file, smm0.md5, MD5_ID) == false ) goto writeSMM0_error; if ( writeChunk (file, smm0.time, TIME_ID) == false ) goto writeSMM0_error; if ( writeChunk (file, smm0.body, BODY_ID) == false ) goto writeSMM0_error; return true; writeSMM0_error: *errorString = txt_writing; return false; }
void Profiler::writeProfileLog() { std::string filename = util::getDateTimeString() + ".arxprof"; LogInfo << "Writing profiler log to: " << filename; fs::ofstream out(fs::path(filename), std::ios::binary | std::ios::out); size_t pos = 0; int fileVersion = 1; LogDebug("Writing Header"); SavedProfilerHeader header; std::strncpy(header.magic, profilerMagic, 8); header.version = fileVersion; std::memset(header.padding, 0, sizeof(header.padding)); writeStruct(out, header, pos); LogDebug("Building string table"); ProfilerStringTable stringTable; std::vector<SavedProfilerThread> threadsData; std::vector<SavedProfilerSample> samplesData; for(ThreadInfos::const_iterator it = m_threads.begin(); it != m_threads.end(); ++it) { const ProfilerThread & thread = it->second; u32 stringIndex = stringTable.add(thread.threadName); SavedProfilerThread saved; saved.stringIndex = stringIndex; saved.threadId = thread.threadId; saved.startTime = thread.startTime; saved.endTime = thread.endTime; threadsData.push_back(saved); } // Profile points u32 index = 0; u32 numItems = m_writeIndex; if(numItems >= NB_SAMPLES) { index = numItems; numItems = NB_SAMPLES; } for(u32 i = 0; i < numItems; ++i, ++index) { ProfilerSample & sample = m_samples[index % NB_SAMPLES]; u32 stringIndex = stringTable.add(sample.tag); SavedProfilerSample saved; saved.stringIndex = stringIndex; saved.threadId = sample.threadId; saved.startTime = sample.startTime; saved.endTime = sample.endTime; samplesData.push_back(saved); } LogInfo << "Writing data: " " Strings " << stringTable.entries() << ", Threads " << threadsData.size() << ", Points " << samplesData.size(); { std::string stringsData = stringTable.data(); int dataSize = stringsData.size() + 1; // termination writeChunk(out, ArxProfilerChunkType_Strings, dataSize, pos); out.write(stringsData.c_str(), dataSize); pos += dataSize; } { int dataSize = threadsData.size() * sizeof(SavedProfilerThread); writeChunk(out, ArxProfilerChunkType_Threads, dataSize, pos); out.write((const char*) threadsData.data(), dataSize); pos += dataSize; } { int dataSize = samplesData.size() * sizeof(SavedProfilerSample); writeChunk(out, ArxProfilerChunkType_Samples, dataSize, pos); out.write((const char*) samplesData.data(), dataSize); pos += dataSize; } out.close(); }
static void writeACTL( std::ofstream & os, int N ) { std::vector<char> data( 8, 0 ); uint32_t uN = ntohl( N ); memcpy( data.data(), &uN, sizeof(uN) ); writeChunk( os, "acTL", data ); }
//----------------------------------------------------------------------------- bool PGChunk::AppendDataFromVP( InstParams *vp ) { if ( mReadOnly ) { return false; } int intValue; double doubleValue; //プログラム名 if (vp->pgname[0] != 0) { writeChunk(kAudioUnitCustomProperty_ProgramName, vp->pgname, PROGRAMNAME_MAX_LEN); } int brrSize = vp->brr.size; //最終ブロックをループフラグにする if (vp->loop) { vp->brr.data[brrSize - 9] |= 2; } else { vp->brr.data[brrSize - 9] &= ~2; } writeChunk(kAudioUnitCustomProperty_BRRData, vp->brr.data, brrSize); doubleValue = vp->rate; writeChunk(kAudioUnitCustomProperty_Rate, &doubleValue, sizeof(double)); intValue = vp->basekey; writeChunk(kAudioUnitCustomProperty_BaseKey, &intValue, sizeof(int)); intValue = vp->lowkey; writeChunk(kAudioUnitCustomProperty_LowKey, &intValue, sizeof(int)); intValue = vp->highkey; writeChunk(kAudioUnitCustomProperty_HighKey, &intValue, sizeof(int)); intValue = vp->lp; writeChunk(kAudioUnitCustomProperty_LoopPoint, &intValue, sizeof(int)); intValue = vp->ar; writeChunk(kAudioUnitCustomProperty_AR, &intValue, sizeof(int)); intValue = vp->dr; writeChunk(kAudioUnitCustomProperty_DR, &intValue, sizeof(int)); intValue = vp->sl; writeChunk(kAudioUnitCustomProperty_SL, &intValue, sizeof(int)); intValue = vp->sr; writeChunk(kAudioUnitCustomProperty_SR, &intValue, sizeof(int)); intValue = vp->volL; writeChunk(kAudioUnitCustomProperty_VolL, &intValue, sizeof(int)); intValue = vp->volR; writeChunk(kAudioUnitCustomProperty_VolR, &intValue, sizeof(int)); intValue = vp->echo ? 1:0; writeChunk(kAudioUnitCustomProperty_Echo, &intValue, sizeof(int)); intValue = vp->bank; writeChunk(kAudioUnitCustomProperty_Bank, &intValue, sizeof(int)); intValue = vp->sustainMode ? 1:0; writeChunk(kAudioUnitCustomProperty_SustainMode, &intValue, sizeof(int)); intValue = vp->monoMode ? 1:0; writeChunk(kAudioUnitCustomProperty_MonoMode, &intValue, sizeof(int)); intValue = vp->portamentoOn ? 1:0; writeChunk(kAudioUnitCustomProperty_PortamentoOn, &intValue, sizeof(int)); intValue = vp->portamentoRate; writeChunk(kAudioUnitCustomProperty_PortamentoRate, &intValue, sizeof(int)); intValue = vp->noteOnPriority; writeChunk(kAudioUnitCustomProperty_NoteOnPriority, &intValue, sizeof(int)); intValue = vp->releasePriority; writeChunk(kAudioUnitCustomProperty_ReleasePriority, &intValue, sizeof(int)); //元波形情報 intValue = vp->isEmphasized ? 1:0; writeChunk(kAudioUnitCustomProperty_IsEmaphasized, &intValue, sizeof(int)); if ( vp->sourceFile[0] ) { writeChunk(kAudioUnitCustomProperty_SourceFileRef, vp->sourceFile, PATH_LEN_MAX); } mNumPrograms++; return true; }