netBool UDPStream::Pack(SerializerLess& _ser, const Peer& _peer)
{
Channel& channel = GetChannel(m_sendChannels, _peer);
_ser.ResetCursor();
// read upper layer size, compute crc
//_ser.Read(s_typeListener);
SerializerLess upper_ser(_ser, GetHeaderSize(), _ser.GetBufferSize());
netU32 crc = CRC32::Compute(_ser.GetBuffer() + GetHeaderSize(), upper_ser.GetSize() - GetHeaderSize());
_ser.Write(s_typeUDPStream);
_ser << crc;
_ser.SetCursor(GetHeaderSize() + upper_ser.GetSize());
_ser.Close();
if(m_opt_compression)
{
// TODO : add compression
}
if(m_opt_encryption)
{
// TODO : add encryption
}
channel.Push(_ser);
return true;
}
void CMpgSearch::Mount(CArcFile* archive)
{
// Corresponds to CVM
LPCTSTR file_extension = (lstrcmpi(archive->GetArcExten(), _T(".cvm")) == 0) ? _T(".sfd") : _T(".mpg");
SFileInfo file_info;
// Get start address
file_info.start = archive->GetArcPointer();
archive->Seek(GetHeaderSize(), FILE_CURRENT);
archive->GetProg()->UpdatePercent(GetHeaderSize());
// Get footer
if (!SearchFooter(archive))
return;
// Get exit address
file_info.end = archive->GetArcPointer();
// Get file size
file_info.sizeOrg = file_info.end - file_info.start;
file_info.sizeCmp = file_info.sizeOrg;
archive->AddFileInfo(file_info, GetNumFiles(), file_extension);
}
void CWmvSearch::Mount(CArcFile* archive)
{
SFileInfo file_info;
// Get start address
file_info.start = archive->GetArcPointer();
archive->Seek(GetHeaderSize(), FILE_CURRENT);
// Search the auxiliary header
if (!SearchFooter(archive))
return;
// Amount of progress advanced by the search bar
const u64 search_offset = archive->GetArcPointer() - file_info.start - GetHeaderSize();
// Get file size
archive->Seek(23, FILE_CURRENT);
archive->Read(&file_info.sizeOrg, 4);
file_info.sizeCmp = file_info.sizeOrg;
// Get exit address
file_info.end = file_info.start + file_info.sizeOrg;
// Go to the end of the WMV file
archive->Seek(file_info.end, FILE_BEGIN);
archive->GetProg()->UpdatePercent(file_info.sizeOrg - search_offset);
archive->AddFileInfo(file_info, GetNumFiles(), _T(".wmv"));
}
ALAC_Atom::ALAC_Atom(AP4_Size size, AP4_ByteStream &stream) :
AP4_Atom(AP4_ATOM_TYPE_ALAC, size, 0, 0),
_magic_cookie(NULL),
_magic_cookie_size(size - GetHeaderSize())
{
if(_magic_cookie_size > 0)
{
_magic_cookie = malloc(_magic_cookie_size);
// Here I'm moving the file pointer forward by a uint_32 (4 bytes).
// Not totally sure why I have to do this. I think it might be because
// this Atom "IsFull", which seems to mean that it has a 32-bit version/flags
// entry after the usual size and 'alac' entries, 4 bytes each. But for some reason
// the file marker isn't taking into account the version/flags bytes, which appear
// to be 0 anyway. So here I'm moving it over to where the ALAC "magic cookie" really starts.
AP4_Position pos = 0;
stream.Tell(pos);
stream.Seek(pos + 4);
if(_magic_cookie)
{
stream.Read(_magic_cookie, _magic_cookie_size);
}
}
}
/*----------------------------------------------------------------------
| AP4_UnknownUuidAtom::AP4_UnknownUuidAtom
+---------------------------------------------------------------------*/
AP4_UnknownUuidAtom::AP4_UnknownUuidAtom(AP4_UI64 size, const AP4_UI08* uuid, AP4_ByteStream& stream) :
AP4_UuidAtom(size, uuid)
{
// store the data
m_Data.SetDataSize((AP4_Size)size-GetHeaderSize());
stream.Read(m_Data.UseData(), m_Data.GetDataSize());
}
/*----------------------------------------------------------------------
| AP4_SaizAtom::AP4_SaizAtom
+---------------------------------------------------------------------*/
AP4_SaizAtom::AP4_SaizAtom(AP4_UI32 size,
AP4_UI08 version,
AP4_UI32 flags,
AP4_ByteStream& stream) :
AP4_Atom(AP4_ATOM_TYPE_SAIZ, size, version, flags),
m_AuxInfoType(0),
m_AuxInfoTypeParameter(0)
{
AP4_UI32 remains = size-GetHeaderSize();
if (flags & 1) {
stream.ReadUI32(m_AuxInfoType);
stream.ReadUI32(m_AuxInfoTypeParameter);
remains -= 8;
}
stream.ReadUI08(m_DefaultSampleInfoSize);
stream.ReadUI32(m_SampleCount);
remains -= 5;
if (m_DefaultSampleInfoSize == 0) {
// means that the sample info entries have different sizes
if (m_SampleCount > remains) m_SampleCount = remains; // sanity check
AP4_Cardinal sample_count = m_SampleCount;
m_Entries.SetItemCount(sample_count);
unsigned char* buffer = new AP4_UI08[sample_count];
AP4_Result result = stream.Read(buffer, sample_count);
if (AP4_FAILED(result)) {
delete[] buffer;
return;
}
for (unsigned int i=0; i<sample_count; i++) {
m_Entries[i] = buffer[i];
}
delete[] buffer;
}
}
void CAhxSearch::Mount(CArcFile* archive)
{
SFileInfo file_info;
// Get start address
file_info.start = archive->GetArcPointer();
// Get file ssize
archive->Seek(GetHeaderSize() + 2, FILE_CURRENT);
archive->Read(&file_info.sizeOrg, 4);
file_info.sizeOrg = BitUtils::Swap32(file_info.sizeOrg) << 1;
archive->GetProg()->UpdatePercent(4);
// Search footer
if (!SearchFooter(archive))
return;
// Get exit address
file_info.end = archive->GetArcPointer();
// Get compressedfile size
file_info.sizeCmp = file_info.end - file_info.start;
archive->AddFileInfo(file_info, GetNumFiles(), _T(".ahx"));
}
void LASHeader::AddVLR(LASVariableRecord const& v)
{
m_vlrs.push_back(v);
uint32_t end_size = 0;
std::vector<LASVariableRecord>::const_iterator i;
// Calculate a new data offset size
for (i = m_vlrs.begin(); i != m_vlrs.end(); ++i)
{
end_size += (*i).GetTotalSize();
}
uint32_t size = 0;
uint32_t const dataSignatureSize = 2;
// Add the signature if we're a 1.0 file
if (eVersionMinorMin == m_versionMinor) {
size = end_size + dataSignatureSize;
} else {
size = end_size;
}
SetDataOffset(GetHeaderSize()+size);
// We're assuming that the reader or writer has reset
// the VLR count to 0 before adding them back with AddVLR
// FIXME I think this is still broken - hobu
m_recordsCount += 1;
}
/*----------------------------------------------------------------------
| AP4_IpmpDescriptor::Inspect
+---------------------------------------------------------------------*/
AP4_Result
AP4_IpmpDescriptor::Inspect(AP4_AtomInspector& inspector)
{
char info[64];
AP4_FormatString(info, sizeof(info), "size=%ld+%ld",
GetHeaderSize(),m_PayloadSize);
inspector.StartElement("[IPMP_Descriptor]", info);
inspector.AddField("IPMP_DescriptorID", m_DescriptorId);
inspector.AddField("IPMPS_Type", m_IpmpsType, AP4_AtomInspector::HINT_HEX);
if (m_DescriptorId == 0xFF && m_IpmpsType == 0xFFFF) {
inspector.AddField("IPMP_DescriptorIDEx", m_DescriptorIdEx);
inspector.AddField("IPMP_ToolID", (const unsigned char*)(&m_ToolId[0]), 16, AP4_AtomInspector::HINT_HEX);
inspector.AddField("controlPointCode", m_ControlPointCode);
if (m_ControlPointCode > 0) {
inspector.AddField("sequenceCode", m_SequenceCode);
}
} else if (m_IpmpsType == 0) {
inspector.AddField("URL", m_Url.GetChars());
} else {
inspector.AddField("data size", m_Data.GetDataSize());
}
inspector.EndElement();
return AP4_SUCCESS;
}
/*----------------------------------------------------------------------
| AP4_ContainerAtom::AP4_ContainerAtom
+---------------------------------------------------------------------*/
AP4_ContainerAtom::AP4_ContainerAtom(Type type,
AP4_Size size,
bool is_full,
AP4_ByteStream& stream,
AP4_AtomFactory& atom_factory) :
AP4_Atom(type, size, is_full, stream)
{
ReadChildren(atom_factory, stream, size-GetHeaderSize());
}
/*----------------------------------------------------------------------
| AP4_Expandable::Inspect
+---------------------------------------------------------------------*/
AP4_Result
AP4_Expandable::Inspect(AP4_AtomInspector& inspector)
{
char name[64];
AP4_FormatString(name, sizeof(name), "#:%02x", m_ClassId);
inspector.StartDescriptor(name, GetHeaderSize(), GetSize());
inspector.EndDescriptor();
return AP4_SUCCESS;
}
/*----------------------------------------------------------------------
| AP4_ContainerAtom::OnChildChanged
+---------------------------------------------------------------------*/
void
AP4_ContainerAtom::OnChildChanged(AP4_Atom*)
{
// remcompute our size
m_Size = GetHeaderSize();
m_Children.Apply(AP4_AtomSizeAdder(m_Size));
// update our parent
if (m_Parent) m_Parent->OnChildChanged(this);
}
Status RTP_Packet::SetPayloadData(Ipp8u *ptr, size_t bytes)
{
Ipp32s headerlen;
headerlen = GetHeaderSize();
//memcpy((Ipp8s*)m_pDataPointer+headerlen,ptr,bytes);
ippsCopy_8u((const Ipp8u*)ptr,(Ipp8u*)(m_pDataPointer+headerlen),(Ipp32s)bytes);
m_Len = headerlen+(Ipp32s)bytes;
SetDataSize(m_Len);
return UMC_OK;
}
/*----------------------------------------------------------------------
| AP4_OdheAtom::OnChildChanged
+---------------------------------------------------------------------*/
void
AP4_OdheAtom::OnChildChanged(AP4_Atom*)
{
// remcompute our size
AP4_UI64 size = GetHeaderSize()+1+m_ContentType.GetLength();
m_Children.Apply(AP4_AtomSizeAdder(size));
SetSize(size);
// update our parent
if (m_Parent) m_Parent->OnChildChanged(this);
}
/*----------------------------------------------------------------------
| AP4_StsdAtom::OnChildChanged
+---------------------------------------------------------------------*/
void
AP4_StsdAtom::OnChildChanged(AP4_Atom*)
{
// remcompute our size
AP4_UI64 size = GetHeaderSize()+4;
m_Children.Apply(AP4_AtomSizeAdder(size));
m_Size32 = (AP4_UI32)size;
// update our parent
if (m_Parent) m_Parent->OnChildChanged(this);
}
/*----------------------------------------------------------------------
| AP4_SampleEntry::OnChildChanged
+---------------------------------------------------------------------*/
void
AP4_SampleEntry::OnChildChanged(AP4_Atom*)
{
// recompute our size
AP4_UI64 size = GetHeaderSize()+GetFieldsSize();
m_Children.Apply(AP4_AtomSizeAdder(size));
m_Size32 = (AP4_UI32)size;
// update our parent
if (m_Parent) m_Parent->OnChildChanged(this);
}
bool Connections::IsValidPacket(void* PacketHeader, WORD PacketLength)
{
if (GetHeaderSize() > PacketLength)
{
return false;
}
Packet packet;
packet.AttachData((BYTE*)PacketHeader, PacketLength);
return packet.IsValidPacket();
}
//-----------------------------------------------------------------------------------
// Purpose :
// Return :
//-----------------------------------------------------------------------------------
bool CNtlConnection::IsValidPacket(void * pvPacketHeader, WORD wPacketLength)
{
if (GetHeaderSize() > wPacketLength)
{
return false;
}
CNtlPacket packet;
packet.AttachData((BYTE*)pvPacketHeader, wPacketLength);
return packet.IsValidPacket();
}
uint16 PacketBuffer::GetPacketNo() const
{
if (writePos < GetHeaderSize())
{
LOG_ERROR("Not enough data.");
return 0;
}
uint16 packetNo = 0;
CopyMemory(&packetNo, buffer.data() + readPos + sizeof(uint16), sizeof(uint16));
return packetNo;
}
netBool UDPStream::UnPack(SerializerLess& _ser, const Peer& _peer)
{
if(_ser.Read(s_typeUDPStream))
{
// check frame consistency (even if the type is correct)
if(_ser.GetSize() <= _ser.GetBufferSize() && _ser.GetSize() > GetHeaderSize())
{
// Packet seems well formed, check data crc for consitency now
netU32 crc_ser;
static_cast<Serializer&>(_ser) >> crc_ser;
SerializerLess upper_ser(_ser, GetHeaderSize(), _ser.GetBufferSize());
if(upper_ser.GetSize() <= upper_ser.GetBufferSize() && upper_ser.GetSize() > GetHeaderSize())
{
netU32 crc_cmp = CRC32::Compute(_ser.GetBuffer() + GetHeaderSize(), upper_ser.GetSize() - GetHeaderSize());
if(crc_cmp == crc_ser)
{
PushToStream(upper_ser, _peer);
}
else
{
//assert(false);
// packet malformed drop
}
}
else
{
//assert(false);
// packet malformed drop
}
}
else
{
//assert(false);
// packet malformed drop
}
void LASHeader::SetDataOffset(uint32_t v)
{
uint32_t const dataSignatureSize = 2;
uint16_t const hsize = GetHeaderSize();
if ( (m_versionMinor == 0 && v < hsize + dataSignatureSize) ||
(m_versionMinor == 1 && v < hsize) ||
(m_versionMinor == 2 && v < hsize) )
{
throw std::out_of_range("data offset out of range");
}
m_dataOffset = v;
}
/*----------------------------------------------------------------------
| AP4_Expandable::Inspect
+---------------------------------------------------------------------*/
AP4_Result
AP4_Expandable::Inspect(AP4_AtomInspector& inspector)
{
char name[6];
AP4_FormatString(name, sizeof(name), "[#:%02x]", m_ClassId);
char info[64];
AP4_FormatString(info, sizeof(info), "size=%ld+%ld",
GetHeaderSize(),
m_PayloadSize);
inspector.StartElement(name, info);
inspector.EndElement();
return AP4_SUCCESS;
}
/*----------------------------------------------------------------------
| AP4_SampleEntry::Read
+---------------------------------------------------------------------*/
void
AP4_SampleEntry::Read(AP4_ByteStream& stream, AP4_AtomFactory& atom_factory)
{
// read the fields before the children atoms
ReadFields(stream);
// read children atoms (ex: esds and maybe others)
// NOTE: not all sample entries have children atoms
AP4_Size payload_size = (AP4_Size)(GetSize()-GetHeaderSize());
AP4_Size fields_size = GetFieldsSize();
if (payload_size > fields_size) {
ReadChildren(atom_factory, stream, payload_size-fields_size);
}
}
/*----------------------------------------------------------------------
| AP4_IpmpDescriptorPointer::Inspect
+---------------------------------------------------------------------*/
AP4_Result
AP4_IpmpDescriptorPointer::Inspect(AP4_AtomInspector& inspector)
{
inspector.StartDescriptor("IPMP_DescriptorPointer", GetHeaderSize(), GetSize());
inspector.AddField("IPMP_DescriptorID", m_DescriptorId);
if (m_DescriptorId == 0xFF) {
inspector.AddField("IPMP_DescriptorIDEx", m_DescriptorIdEx);
inspector.AddField("IPMP_ES_ID", m_EsId);
}
inspector.EndDescriptor();
return AP4_SUCCESS;
}
IO::MemoryStream* MacDescription::ToStream()
{
IO::StreamWriter writer(GetHeaderSize());
writer.Write(static_cast<byte>(m_macType));
writer.Write(static_cast<short>(m_keySize));
writer.Write(static_cast<byte>(m_ivSize));
writer.Write(static_cast<byte>(m_hmacEngine));
writer.Write(static_cast<byte>(m_engineType));
writer.Write(static_cast<byte>(m_blockSize));
writer.Write(static_cast<byte>(m_roundCount));
writer.Write(static_cast<byte>(m_kdfEngine));
return writer.GetStream();
}
void CMidSearch::Mount(CArcFile* archive)
{
SFileInfo file_info;
// Get the head position
file_info.start = archive->GetArcPointer();
// Get the number of tracks
u16 tracks;
archive->SeekCur(GetHeaderSize() + 2);
archive->ReadU16(&tracks);
tracks = BitUtils::Swap16(tracks);
archive->SeekCur(2);
// Get end positions
for (unsigned short cnt = 0; cnt < tracks; cnt++)
{
std::array<u8, 4> marker;
archive->Read(marker.data(), marker.size());
// Invalid MIDI
if (std::memcmp(marker.data(), "MTrk", marker.size()) != 0)
{
return;
}
// Get track size
u32 track_size;
archive->ReadU32(&track_size);
track_size = BitUtils::Swap32(track_size);
// Advance to next track
archive->SeekCur(track_size);
}
file_info.end = archive->GetArcPointer();
// Get file size
file_info.size_org = file_info.end - file_info.start;
file_info.size_cmp = file_info.size_org;
// Update progress bar
archive->GetProg()->UpdatePercent(file_info.size_org);
archive->AddFileInfo(file_info, GetNumFiles(), _T(".mid"));
}
/*----------------------------------------------------------------------
| AP4_IpmpDescriptorPointer::Inspect
+---------------------------------------------------------------------*/
AP4_Result
AP4_IpmpDescriptorPointer::Inspect(AP4_AtomInspector& inspector)
{
char info[64];
AP4_FormatString(info, sizeof(info), "size=%ld+%ld",
GetHeaderSize(),m_PayloadSize);
inspector.StartElement("[IPMP_DescriptorPointer]", info);
inspector.AddField("IPMP_DescriptorID", m_DescriptorId);
if (m_DescriptorId == 0xFF) {
inspector.AddField("IPMP_DescriptorIDEx", m_DescriptorIdEx);
inspector.AddField("IPMP_ES_ID", m_EsId);
}
inspector.EndElement();
return AP4_SUCCESS;
}
//-----------------------------------------------------------------------------------
// Purpose :
// Return :
//-----------------------------------------------------------------------------------
// Called by Worker TH ( CompleteRecv )
//-----------------------------------------------------------------------------------
bool CNtlConnection::PopPacket(CNtlPacket * pPacket)
{
FUNCTION_BEGIN();
if( NULL == pPacket )
{
NTL_LOG_ASSERT("NULL == pPacket");
return false;
}
#if 0
WORD wPacketLength = 0;
if( false == MakeSureCompletedPacket( &m_recvBuffer, &wPacketLength ) )
{
return false;
}
pPacket->Attach( m_recvBuffer.GetQueueWorkPtr(), wPacketLength );
if( false == pPacket->IsValidPacket() )
{
return false;
}
m_recvBuffer.IncreaseWorkPos( pPacket->GetUsedSize() );
#else
int nPacketLen = GetPacketLen( m_recvBuffer.GetQueuePopPtr() );
pPacket->AttachData( m_recvBuffer.GetQueuePopPtr(), (WORD) (GetHeaderSize() + nPacketLen) );
if( false == pPacket->IsValidPacket() )
{
return false;
}
#endif
return true;
}
void LASHeader::SetVersionMinor(uint8_t v)
{
if (v > eVersionMinorMax)
throw std::out_of_range("version minor out of range");
m_versionMinor = v;
uint32_t size = 0;
uint32_t const dataSignatureSize = 2;
// Add the signature if we're a 1.0 file
if (eVersionMinorMin == m_versionMinor) {
size = dataSignatureSize;
}
SetDataOffset(GetHeaderSize()+size);
}
void wxPaneBase::OnPaint( wxPaintEvent& WXUNUSED(event) ) {
wxPaintDC dc(this);
int headerSize = GetHeaderSize();
// draw header
wxRect hr = GetClientRect();
if( m_orientation == wxVERTICAL ) {
hr.SetRight( hr.x + headerSize );
} else {
hr.SetBottom( hr.y + headerSize );
}
// create a clipping region to exclude the close button
if( m_pCloseButton && m_showClosebutton ) {
dc.DestroyClippingRegion();
wxRegion region( hr );
wxRect sr = m_pCloseButton->GetRect();
region.Subtract( sr );
dc.SetClippingRegion( region );
}
g_gdi.DrawHeader( dc, hr, m_orientation, GetName(), GetTitleFont() );
// draw contents
wxRect cr = GetClientRect();
if( m_orientation == wxVERTICAL ) {
cr.x += headerSize;
}
else {
cr.y += headerSize;
}
// create a clipping region to exclude the child window
dc.DestroyClippingRegion();
wxRegion region( cr );
if( m_pClient ) {
wxRect sr = m_pClient->GetRect();
region.Subtract( sr );
}
dc.SetClippingRegion( region );
g_gdi.DrawEmptyWorkspace( dc, cr, true );
}
