void DataFlash_Block::WriteBlock(const void *pBuffer, uint16_t size)
{
if (!CardInserted() || !log_write_started || !_writes_enabled) {
return;
}
while (size > 0) {
uint16_t n = df_PageSize - df_BufferIdx;
if (n > size) {
n = size;
}
if (df_BufferIdx == 0) {
// if we are at the start of a page we need to insert a
// page header
if (n > df_PageSize - sizeof(struct PageHeader)) {
n = df_PageSize - sizeof(struct PageHeader);
}
struct PageHeader ph = { df_FileNumber, df_FilePage };
BlockWrite(df_BufferNum, df_BufferIdx, &ph, sizeof(ph), pBuffer, n);
df_BufferIdx += n + sizeof(ph);
} else {
BlockWrite(df_BufferNum, df_BufferIdx, NULL, 0, pBuffer, n);
df_BufferIdx += n;
}
size -= n;
pBuffer = (const void *)(n + (uintptr_t)pBuffer);
if (df_BufferIdx == df_PageSize) {
FinishWrite();
df_FilePage++;
}
}
}
XnStatus EndRecord::Encode()
{
XnStatus nRetVal = StartWrite(RECORD_END);
XN_IS_STATUS_OK(nRetVal);
nRetVal = FinishWrite();
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
/*
Read the log and print it on port
*/
void DataFlash_Block::LogReadProcess(uint16_t log_num,
uint16_t start_page, uint16_t end_page,
print_mode_fn print_mode,
AP_HAL::BetterStream *port)
{
uint8_t log_step = 0;
uint16_t page = start_page;
bool first_entry = true;
if (df_BufferIdx != 0) {
FinishWrite();
hal.scheduler->delay(100);
}
StartRead(start_page);
while (true) {
uint8_t data;
if (!ReadBlock(&data, 1)) {
break;
}
// This is a state machine to read the packets
switch(log_step) {
case 0:
if (data == HEAD_BYTE1) {
log_step++;
}
break;
case 1:
if (data == HEAD_BYTE2) {
log_step++;
} else {
log_step = 0;
}
break;
case 2:
log_step = 0;
if (first_entry && data != LOG_FORMAT_MSG) {
_print_log_formats(port);
}
first_entry = false;
_print_log_entry(data, print_mode, port);
break;
}
uint16_t new_page = GetPage();
if (new_page != page) {
if (new_page == end_page+1 || new_page == start_page) {
return;
}
page = new_page;
}
}
}
XnStatus NodeAdded_1_0_0_5_Record::Encode()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = StartWrite(RECORD_NODE_ADDED_1_0_0_5);
XN_IS_STATUS_OK(nRetVal);
nRetVal = EncodeImpl();
XN_IS_STATUS_OK(nRetVal);
nRetVal = FinishWrite();
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
/*
Read the log and print it on port
*/
void DataFlash_Block::LogReadProcess(uint16_t log_num,
uint16_t start_page, uint16_t end_page,
uint8_t num_types,
const struct LogStructure *structure,
void (*print_mode)(AP_HAL::BetterStream *port, uint8_t mode),
AP_HAL::BetterStream *port)
{
uint8_t log_step = 0;
uint16_t page = start_page;
if (df_BufferIdx != 0) {
FinishWrite();
hal.scheduler->delay(100);
}
StartRead(start_page);
while (true) {
uint8_t data;
ReadBlock(&data, 1);
// This is a state machine to read the packets
switch(log_step) {
case 0:
if (data == HEAD_BYTE1) {
log_step++;
}
break;
case 1:
if (data == HEAD_BYTE2) {
log_step++;
} else {
log_step = 0;
}
break;
case 2:
log_step = 0;
_print_log_entry(data, num_types, structure, print_mode, port);
break;
}
uint16_t new_page = GetPage();
if (new_page != page) {
if (new_page == end_page+1 || new_page == start_page) {
return;
}
page = new_page;
}
}
}
// This function finds the first and last pages of a log file
// The first page may be greater than the last page if the DataFlash has been filled and partially overwritten.
void DataFlash_Block::get_log_boundaries(uint16_t log_num, uint16_t & start_page, uint16_t & end_page)
{
uint16_t num = get_num_logs();
uint16_t look;
if (df_BufferIdx != 0) {
FinishWrite();
hal.scheduler->delay(100);
}
if(num == 1)
{
StartRead(df_NumPages);
if (GetFileNumber() == 0xFFFF)
{
start_page = 1;
end_page = find_last_page_of_log((uint16_t)log_num);
} else {
end_page = find_last_page_of_log((uint16_t)log_num);
start_page = end_page + 1;
}
} else {
if(log_num==1) {
StartRead(df_NumPages);
if(GetFileNumber() == 0xFFFF) {
start_page = 1;
} else {
start_page = find_last_page() + 1;
}
} else {
if(log_num == find_last_log() - num + 1) {
start_page = find_last_page() + 1;
} else {
look = log_num-1;
do {
start_page = find_last_page_of_log(look) + 1;
look--;
} while (start_page <= 0 && look >=1);
}
}
}
if (start_page == df_NumPages+1 || start_page == 0) {
start_page = 1;
}
end_page = find_last_page_of_log(log_num);
if (end_page == 0) {
end_page = start_page;
}
}
void MP4FreeAtom::Write()
{
ASSERT(m_pFile);
bool use64 = (GetSize() > (0xFFFFFFFF - 8));
BeginWrite(use64);
#if 1
for (uint64_t ix = 0; ix < GetSize(); ix++) {
m_pFile->WriteUInt8(0);
}
#else
m_pFile->SetPosition(m_pFile->GetPosition() + GetSize());
#endif
FinishWrite(use64);
}
bool DataFlash_Block::WritePrioritisedBlock(const void *pBuffer, uint16_t size,
bool is_critical)
{
// is_critical is ignored - we're a ring buffer and never run out
// of space. possibly if we do more complicated bandwidth
// limiting we can reservice bandwidth based on is_critical
if (!CardInserted() || !log_write_started || !_writes_enabled) {
return false;
}
if (! WriteBlockCheckStartupMessages()) {
return false;
}
while (size > 0) {
uint16_t n = df_PageSize - df_BufferIdx;
if (n > size) {
n = size;
}
if (df_BufferIdx == 0) {
// if we are at the start of a page we need to insert a
// page header
if (n > df_PageSize - sizeof(struct PageHeader)) {
n = df_PageSize - sizeof(struct PageHeader);
}
struct PageHeader ph = { df_FileNumber, df_FilePage };
BlockWrite(df_BufferNum, df_BufferIdx, &ph, sizeof(ph), pBuffer, n);
df_BufferIdx += n + sizeof(ph);
} else {
BlockWrite(df_BufferNum, df_BufferIdx, NULL, 0, pBuffer, n);
df_BufferIdx += n;
}
size -= n;
pBuffer = (const void *)(n + (uintptr_t)pBuffer);
if (df_BufferIdx == df_PageSize) {
FinishWrite();
df_FilePage++;
}
}
return true;
}
void DataFlash_Block::EraseAll()
{
Erase_Sectors(0,32); // Erase 32 sectors * 256 bytes
// write the logging format in the first page
hal.scheduler->delay(100);
df_BufferIdx = 0;
df_BufferNum = 0;
df_PageAdr = DF_LAST_PAGE;
uint32_t version = DF_LOGGING_FORMAT;
log_write_started = true;
df_FileNumber = 1;
df_FilePage = 1;
WriteBlock(&version, sizeof(version));
log_write_started = false;
FinishWrite();
hal.scheduler->delay(100);
}
void DataFlash_Block::EraseAll()
{
for (uint16_t j = 1; j <= (df_NumPages+1)/8; j++) {
BlockErase(j);
if (j%6 == 0) {
hal.scheduler->delay(6);
}
}
// write the logging format in the last page
hal.scheduler->delay(100);
StartWrite(df_NumPages+1);
uint32_t version = DF_LOGGING_FORMAT;
log_write_started = true;
WriteBlock(&version, sizeof(version));
log_write_started = false;
FinishWrite();
hal.scheduler->delay(100);
}
void MP4FreeAtom::Write()
{
if(m_File.GetRealTimeMode() > MP4_NORMAL)
{
bool use64 = (GetSize() > (0xFFFFFFFF - 8));
BeginWrite(use64);
#if 1
bool bIsInFlag = true;
bool bIsInFlag2 = true;
bool bIsInFlag3 = true;
bool bIsInFlag4 = true;
bool bIsInFlag5 = true;
if(m_File.m_ExeFreeTimes%2 == 0)
{
for (uint64_t ix = 0; ix < GetSize(); ix++)
{
if(3 == ix)
{//版本
m_File.WriteUInt8(1);
}
else if(7 == ix)
{//加密标识
m_File.WriteUInt8(m_File.m_encryptionFlag);
}
else if((8 <= ix) && (ix <= 15))
{//mdat大小
if(bIsInFlag)
{
m_File.WriteUInt64(m_File.GetMdatSize());
bIsInFlag = false;
}
}
else
{
m_File.WriteUInt8(0);
}
}
}
else
{
for (uint64_t ix = 0; ix < GetSize(); ix++)
{
if(3 == ix)
{//版本
m_File.WriteUInt8(1);
}
else if((4 <= ix) && (ix <= 11))
{//休庭信息
if(bIsInFlag)
{
m_File.WriteUInt64(m_File.m_AdjournPos);
bIsInFlag = false;
}
}
else if((12 <= ix) && (ix <= 15))
{//加密标识
if(bIsInFlag3)
{
m_File.WriteBytes((uint8_t*)(&m_File.m_Encryption), 4);
bIsInFlag3 = false;
}
}
else if((16 <= ix) && (ix <= 19))
{//音频类型
if(bIsInFlag4)
{
m_File.WriteBytes((uint8_t*)(&m_File.m_AudioEncode), 4);
bIsInFlag4 = false;
}
}
else if((20 <= ix) && (ix <= 27))
{//优化使用
if(bIsInFlag5)
{
m_File.WriteUInt64(m_File.m_NormalVirtualFramePos);
bIsInFlag5 = false;
}
}
else if((120 <= ix) && (ix <= 127))
{//优化使用
if(bIsInFlag2)
{
m_File.WriteUInt64(m_File.m_MoovPos);
bIsInFlag2 = false;
}
}
else{
m_File.WriteUInt8(0);
}
}
}
m_File.m_ExeFreeTimes++;
if(10 == m_File.m_ExeFreeTimes)
{
m_File.m_ExeFreeTimes = 0;
}
#else
m_File.SetPosition(m_File.GetPosition() + GetSize());
#endif
FinishWrite(use64);
}
else
{
bool use64 = (GetSize() > (0xFFFFFFFF - 8));
BeginWrite(use64);
#if 1
for (uint64_t ix = 0; ix < GetSize(); ix++)
{
m_File.WriteUInt8(0);
}
#else
m_File.SetPosition(m_File.GetPosition() + GetSize());
#endif
FinishWrite(use64);
}
}
