void GraphicLog::logImpl(int32_t tag, int32_t identity, int32_t buffer)
{
uint8_t scratch[2 + 3 + sizeof(int32_t) + sizeof(int32_t) + sizeof(int64_t)];
size_t pos = 0;
scratch[pos++] = EVENT_TYPE_LIST;
scratch[pos++] = 3;
writeInt32(scratch, pos, buffer);
writeInt32(scratch, pos, identity);
writeInt64(scratch, pos, ns2ms( systemTime( SYSTEM_TIME_MONOTONIC ) ));
android_bWriteLog(tag, scratch, sizeof(scratch));
}
status_t MPEG4Writer::start() {
if (mFile == NULL) {
return UNKNOWN_ERROR;
}
beginBox("ftyp");
writeFourcc("isom");
writeInt32(0);
writeFourcc("isom");
endBox();
mMdatOffset = mOffset;
write("\x00\x00\x00\x01mdat????????", 16);
for (List<Track *>::iterator it = mTracks.begin();
it != mTracks.end(); ++it) {
status_t err = (*it)->start();
if (err != OK) {
for (List<Track *>::iterator it2 = mTracks.begin();
it2 != it; ++it2) {
(*it2)->stop();
}
return err;
}
}
return OK;
}
//------------------------------------------------------------------------
bool PresetFile::writeChunkList ()
{
// Update list offset
TSize pos = 0;
stream->tell (&pos);
if (!(seekTo (kListOffsetPos) &&
writeSize (pos) &&
seekTo (pos)))
return false;
// Write list
if (!writeID (getChunkID (kChunkList)))
return false;
if (!writeInt32 (entryCount))
return false;
for (int32 i = 0; i < entryCount; i++)
{
Entry& e = entries[i];
if (!(writeID (e.id) &&
writeSize (e.offset) &&
writeSize (e.size)))
return false;
}
return true;
}
//------------------------------------------------------------------------
bool PresetFile::storeProgramData (IBStream* inStream, ProgramListID listID)
{
if (contains (kProgramData)) // already exists!
return false;
writeHeader ();
Entry e = {0};
if (beginChunk (e, kProgramData))
{
if (writeInt32 (listID))
{
int8 buffer[8192];
int32 read = 0;
int32 written = 0;
while (inStream->read (buffer, 8192, &read) == kResultTrue && read > 0)
{
if (stream->write (buffer, read, &written) != kResultTrue)
{
return false;
}
}
return endChunk (e);
}
}
return false;
}
void MPEG4Writer::beginBox(const char *fourcc) {
CHECK_EQ(strlen(fourcc), 4);
mBoxes.push_back(mOffset);
writeInt32(0);
writeFourcc(fourcc);
}
//--------------------------------------------------------------
void
DataStream::writeInt32BE(i32 n)
{
#ifdef AZURA_LITTLE_ENDIAN
_s4((_4*)&n);
#endif
writeInt32(n);
}
void BaseSerializedObj::writeInt32Array(int32_t array[], uint64_t s)
{
writeUInt64(s);
uint64_t i = 0;
while ( i!=s )
{
writeInt32(array[i]);
i++;
}
}
void MPEG4Writer::endBox() {
CHECK(!mBoxes.empty());
off_t offset = *--mBoxes.end();
mBoxes.erase(--mBoxes.end());
fseek(mFile, offset, SEEK_SET);
writeInt32(mOffset - offset);
mOffset -= 4;
fseek(mFile, mOffset, SEEK_SET);
}
void BaseSerializedObj::writeString(std::string input)
{
int size = input.length();
resizeBufferNeeded(size);
writeInt32(size);
int y = 0;
while( y < size )
{
writeByte(input[y]);
y++;
}
}
//------------------------------------------------------------------------
bool PresetFile::storeProgramData (IUnitData* unitData, UnitID unitID)
{
if (contains (kProgramData)) // already exists!
return false;
writeHeader ();
Entry e = {0};
return beginChunk (e, kProgramData) &&
writeInt32 (unitID) &&
verify (unitData->getUnitData (unitID, stream)) &&
endChunk (e);
}
//------------------------------------------------------------------------
bool PresetFile::storeProgramData (IProgramListData* programListData, ProgramListID listID, int32 programIndex)
{
if (contains (kProgramData)) // already exists!
return false;
writeHeader ();
Entry e = {0};
return beginChunk (e, kProgramData) &&
writeInt32 (listID) &&
verify (programListData->getProgramData (listID, programIndex, stream)) &&
endChunk (e);
}
//------------------------------------------------------------------------
bool PresetFile::writeHeader ()
{
// header id + version + class id + list offset (unknown yet)
char8 classString[kClassIDSize + 1] = {0};
classID.toString (classString);
return seekTo (0) &&
writeID (getChunkID (kHeader)) &&
writeInt32 (kFormatVersion) &&
verify (stream->write (classString, kClassIDSize)) &&
writeSize (0);
}
//only supports char arrays of length value of 4 bytes
void BaseSerializedObj::writeChars(char* input)
{
int size = strlen(input);
resizeBufferNeeded(size+1);
writeInt32(size);
int y = 0;
while( y < size )
{
writeByte(input[y]);
y++;
}
buffer[counter] = '\0';
}
void
BinaryOutputStream::writeAlignedString(std::string const & s, int alignment)
{
int length = (int)s.length();
writeInt32(length);
writeBytes(length, s.c_str());
int padding = (alignment - (length % alignment)) % alignment;
if (padding > 0)
{
for (int i = 0; i < padding; ++i)
writeUInt8(0); // zero not necessary but let's use it to keep things clean instead of calling skip(padding)
}
}
/*
* Geodata is stored according to ISO-6709 standard.
*/
void MPEG4Writer::writeGeoDataBox() {
beginBox("\xA9xyz");
/*
* For historical reasons, any user data start
* with "\0xA9", must be followed by its assoicated
* language code.
* 0x0012: text string length
* 0x15c7: lang (locale) code: en
*/
writeInt32(0x001215c7);
writeLatitude(mLatitudex10000);
writeLongitude(mLongitudex10000);
writeInt8(0x2F);
endBox();
}
void writeVarchar(char *buf,char *str){
unsigned int len=strlen(str);
writeInt32(buf,len);
memcpy(buf+4,str,len);
return ;
}
BEAST_API bool OutputStream::writeType <int32> (int32 v) { return writeInt32 (v); }
void PrintingStatus()
{
int16_t t;
int32_t t32;
writeString((char *)"{T0:");
t=degHotend(0);
if (t>999) t=999;
writeInt(t,3);
put('/');
t=degTargetHotend(0);
writeInt(t,3);
put('}');
writeString((char *)"{T1:");
t=degHotend(1);
if (t>999) t=999;
writeInt(t,3);
put('/');
t=degTargetHotend(1);
writeInt(t,3);
put('}');
writeString((char *)"{TP:");
t=degBed();
if (t>999) t=999;
writeInt(t,3);
put('/');
t=degTargetBed();
writeInt(t,3);
put('}');
writeString((char *)"{TQ:");
t=card.percentDone();
writeInt(t,3);
if (card.sdprinting) put('P');
else put('C');
/*switch(host::getHostState())
{
case host::HOST_STATE_BUILDING_ONBOARD:
case host::HOST_STATE_BUILDING:
case host::HOST_STATE_BUILDING_FROM_SD:
put('P');
break;
case host::HOST_STATE_HEAT_SHUTDOWN:
put('S');
break;
default:
put('C');
break;
}*/
put('}');
writeString((char *)"{TT:");
if(starttime != 0) t32 = millis()/60000 - starttime/60000;
else t32=0;
writeInt32(t32,6);
put('}');
writeString((char *)"{TR:");
//t32=command::estimatedTimeLeftInSeconds();
t32=0;
writeInt32(t32,6);
put('}');
writeString((char *)"{TF:");
//t32=command::filamentUsed();
t32=0;
writeInt32(t32,6);
put('}');
}
BEAST_API bool OutputStream::writeType <uint32> (uint32 v) { return writeInt32 (static_cast <int32> (v)); }
void MessageOut::writeBeingId(const BeingId value, const char *const str)
{
writeInt32(toInt(value, int32_t), str);
}
//--------------------------------------------------------------
void
DataStream::writeUint32(u32 n)
{
writeInt32((i32)n);
}
void MPEG4Writer::stop() {
if (mFile == NULL) {
return;
}
int64_t max_duration = 0;
for (List<Track *>::iterator it = mTracks.begin();
it != mTracks.end(); ++it) {
(*it)->stop();
int64_t duration = (*it)->getDuration();
if (duration > max_duration) {
max_duration = duration;
}
}
// Fix up the size of the 'mdat' chunk.
fseek(mFile, mMdatOffset + 8, SEEK_SET);
int64_t size = mOffset - mMdatOffset;
size = hton64(size);
fwrite(&size, 1, 8, mFile);
fseek(mFile, mOffset, SEEK_SET);
time_t now = time(NULL);
beginBox("moov");
beginBox("mvhd");
writeInt32(0); // version=0, flags=0
writeInt32(now); // creation time
writeInt32(now); // modification time
writeInt32(1000); // timescale
writeInt32(max_duration);
writeInt32(0x10000); // rate
writeInt16(0x100); // volume
writeInt16(0); // reserved
writeInt32(0); // reserved
writeInt32(0); // reserved
writeInt32(0x10000); // matrix
writeInt32(0);
writeInt32(0);
writeInt32(0);
writeInt32(0x10000);
writeInt32(0);
writeInt32(0);
writeInt32(0);
writeInt32(0x40000000);
writeInt32(0); // predefined
writeInt32(0); // predefined
writeInt32(0); // predefined
writeInt32(0); // predefined
writeInt32(0); // predefined
writeInt32(0); // predefined
writeInt32(mTracks.size() + 1); // nextTrackID
endBox(); // mvhd
int32_t id = 1;
for (List<Track *>::iterator it = mTracks.begin();
it != mTracks.end(); ++it, ++id) {
(*it)->writeTrackHeader(id);
}
endBox(); // moov
CHECK(mBoxes.empty());
fclose(mFile);
mFile = NULL;
}
void initFileObject(lua_State* L)
{
luaL_newmetatable(L, meta<File>());
// Duplicate the metatable on the stack.
lua_pushvalue(L, -1);
// metatable.__index = metatable
lua_setfield(L, -2, "__index");
// Put the members into the metatable.
const luaL_Reg functions[] = {
{"__gc", [](lua_State* L) { return script::wrapped<File>(L, 1)->gc(L); }},
{"__index", [](lua_State* L) { return script::wrapped<File>(L, 1)->index(L); }},
{"__newindex", [](lua_State* L) { return script::wrapped<File>(L, 1)->newindex(L); }},
{"__tostring", [](lua_State* L) { return script::wrapped<File>(L, 1)->tostring(L); }},
{"__pairs", [](lua_State* L) { return script::wrapped<File>(L, 1)->pairs(L); }},
{"close", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
file->close();
return 0;
}},
{"readUnsigned8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
uint8_t value;
if(file->readUnsigned8(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readUnsigned16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
uint16_t value;
if(file->readUnsigned16(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readUnsigned32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
uint32_t value;
if(file->readUnsigned32(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readInt8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
int8_t value;
if(file->readInt8(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readInt16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
int16_t value;
if(file->readInt16(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readInt32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
int32_t value;
if(file->readInt32(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readFloat", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
float value;
if(file->readFloat(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readDouble", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
double value;
if(file->readDouble(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readString", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto blockSize = script::get<int>(L, 2);
std::string buffer(blockSize, 0);
if(file->readString(buffer))
{
lua_pushlstring(L, buffer.data(), buffer.size());
return 1;
}
return 0;
}},
{"readLine", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
std::string value;
if(file->readLine(value))
{
script::push(L, value.c_str());
return 1;
}
return 0;
}},
{"readFully", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
// Get current position.
auto pos = file->tell();
if(pos == -1)
{
return 0;
}
// Length to read = position of end - current.
auto length = 0;
if(!file->seek(pos, FileSeekMode::End))
{
return 0;
}
length = file->tell() - pos;
if(!file->seek(pos, FileSeekMode::Start))
{
return 0;
}
// Read the entire file into a string.
std::string buf(length, 0);
if(file->readString(buf))
{
lua_pushlstring(L, buf.data(), buf.size());
return 1;
}
return 0;
}},
{"writeUnsigned8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeUnsigned8(value));
return 1;
}},
{"writeUnsigned16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeUnsigned16(value));
return 1;
}},
{"writeUnsigned32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeUnsigned32(value));
return 1;
}},
{"writeInt8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeInt8(value));
return 1;
}},
{"writeInt16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeInt16(value));
return 1;
}},
{"writeInt32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeInt32(value));
return 1;
}},
{"writeFloat", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<double>(L, 2);
script::push(L, file->writeFloat((float) value));
return 1;
}},
{"writeDouble", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<double>(L, 2);
script::push(L, file->writeDouble(value));
return 1;
}},
{"writeString", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
size_t length = 0;
const char* buffer = luaL_checklstring(L, 2, &length);
std::string value(buffer, buffer + length);
script::push(L, file->writeString(value));
return 1;
}},
{"writeLine", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
size_t length = 0;
const char* buffer = luaL_checklstring(L, 2, &length);
std::string value(buffer, buffer + length);
script::push(L, file->writeLine(value));
return 1;
}},
{"tell", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
script::push(L, int(file->tell()));
return 1;
}},
{"seek", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto position = script::get<int>(L, 2);
auto mode = FileSeekMode(script::get<int>(L, 3));
script::push(L, file->seek(position, mode));
return 1;
}},
{"flush", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
file->flush();
return 0;
}},
{nullptr, nullptr},
};
luaL_setfuncs(L, functions, 0);
lua_pop(L, 1);
// Push plum namespace.
lua_getglobal(L, "plum");
// plum.File = <function create>
script::push(L, "File");
lua_pushcfunction(L, [](lua_State* L)
{
auto filename = script::get<const char*>(L, 1);
auto mode = FileOpenMode(script::get<int>(L, 2));
auto f = new File(filename, mode);
// Failure.
if(!f->isActive())
{
delete f;
return 0;
}
script::push(L, f, LUA_NOREF);
return 1;
});
lua_settable(L, -3);
// Pop plum namespace.
lua_pop(L, 1);
}
