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;
}
