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