Archived::Container::Ptr ParseArchive(const Packed::Decoder& decoder, const Binary::Container& data) { const TRDos::CatalogueBuilder::Ptr builder = TRDos::CatalogueBuilder::CreateGeneric(); const std::size_t archSize = data.Size(); std::size_t rawOffset = 0; for (std::size_t flatOffset = 0; rawOffset < archSize;) { const Binary::Container::Ptr rawData = data.GetSubcontainer(rawOffset, archSize - rawOffset); const Formats::Packed::Container::Ptr fileData = decoder.Decode(*rawData); if (!fileData) { break; } const String fileName = ExtractFileName(rawData->Start()); const std::size_t fileSize = fileData->Size(); const std::size_t usedSize = fileData->PackedSize(); const TRDos::File::Ptr file = TRDos::File::Create(fileData, fileName, flatOffset, fileSize); builder->AddFile(file); rawOffset += usedSize; flatOffset += fileSize; } if (rawOffset) { builder->SetRawData(data.GetSubcontainer(0, rawOffset)); return builder->GetResult(); } else { return Archived::Container::Ptr(); } }
Formats::Chiptune::Container::Ptr Parse(const Binary::Container& rawData, Builder& target) { if (!FastCheck(rawData)) { return Formats::Chiptune::Container::Ptr(); } const Binary::TypedContainer& data(rawData); const Header& header = *data.GetField<Header>(0); //workaround for some emulators const std::size_t offset = (header.Version == INT_BEGIN) ? offsetof(Header, Version) : sizeof(header); std::size_t restSize = rawData.Size() - offset; const uint8_t* bdata = data.GetField<uint8_t>(offset); //detect as much chunks as possible, in despite of real format issues while (restSize) { const uint_t reg = *bdata; ++bdata; --restSize; if (INT_BEGIN == reg) { target.AddChunks(1); } else if (INT_SKIP == reg) { if (restSize < 1) { ++restSize;//put byte back break; } target.AddChunks(4 * *bdata); ++bdata; --restSize; } else if (MUS_END == reg) { break; } else if (reg <= 15) //register { if (restSize < 1) { ++restSize;//put byte back break; } target.SetRegister(reg, *bdata); ++bdata; --restSize; } else { ++restSize;//put byte back break; } } const std::size_t usedSize = rawData.Size() - restSize; const Binary::Container::Ptr subData = rawData.GetSubcontainer(0, usedSize); return CreateCalculatingCrcContainer(subData, offset, usedSize - offset); }
bool FastCheck(const Binary::Container& rawData) { if (rawData.Size() < MIN_SIZE) { return false; } const SignatureType& sign = *static_cast<const SignatureType*>(rawData.Start()); return sign == SIGNATURE; }
std::size_t Parse(const Binary::Container& rawData, ImageVisitor& visitor) { SourceStream stream(rawData); try { const RawHeader& header = stream.Get<RawHeader>(); const uint_t id = fromLE(header.ID); Require(id == ID_OLD || id == ID_NEW); Require(header.Sequence == 0); Require(Math::InRange<uint_t>(header.Sides, MIN_SIDES_COUNT, MAX_SIDES_COUNT)); if (header.HasComment()) { const RawComment& comment = stream.Get<RawComment>(); if (const std::size_t size = fromLE(comment.Size)) { stream.GetData(size); } } const bool compressedData = id == ID_NEW; const bool newCompression = header.Version > 20; if (compressedData) { if (!newCompression) { Dbg("Old compression is not supported."); return 0; } const std::size_t packedSize = rawData.Size() - sizeof(header); const Binary::Container::Ptr packed = rawData.GetSubcontainer(sizeof(header), packedSize); if (const Formats::Packed::Container::Ptr fullDecoded = Formats::Packed::Lha::DecodeRawDataAtLeast(*packed, COMPRESSION_ALGORITHM, MAX_IMAGE_SIZE)) { SourceStream subStream(*fullDecoded); ParseSectors(subStream, visitor); const std::size_t usedInPacked = subStream.GetOffset(); Dbg("Used %1% bytes in packed stream", usedInPacked); if (const Formats::Packed::Container::Ptr decoded = Formats::Packed::Lha::DecodeRawDataAtLeast(*packed, COMPRESSION_ALGORITHM, usedInPacked)) { const std::size_t usedSize = decoded->PackedSize(); return sizeof(header) + usedSize; } } Dbg("Failed to decode lha stream"); return 0; } else { ParseSectors(stream, visitor); } return stream.GetOffset(); } catch (const std::exception&) { return 0; } }
Formats::Chiptune::Container::Ptr Decode(const Binary::Container& rawData) const override { if (!Format->Match(rawData)) { return Formats::Chiptune::Container::Ptr(); } const std::size_t realSize = std::min(rawData.Size(), MAX_SIZE); const Binary::Container::Ptr data = rawData.GetSubcontainer(0, realSize); return CreateCalculatingCrcContainer(data, 0, realSize); }
bool FastCheck(const Binary::Container& rawData) { if (rawData.Size() <= sizeof(Header)) { return false; } const Header* const header = static_cast<const Header*>(rawData.Start()); return 0 == std::memcmp(header->Sign, SIGNATURE, sizeof(SIGNATURE)) && MARKER == header->Marker; }
virtual Container::Ptr Decode(const Binary::Container& rawData) const { const void* const data = rawData.Start(); const std::size_t availSize = rawData.Size(); const FullDiskImage::Container container(data, availSize); if (!container.FastCheck()) { return Container::Ptr(); } FullDiskImage::Decoder decoder(container); return CreatePackedContainer(decoder.GetResult(), decoder.GetUsedSize()); }
virtual Container::Ptr Decode(const Binary::Container& rawData) const { if (!Depacker->Match(rawData)) { return Container::Ptr(); } const MSPack::Container container(rawData.Start(), rawData.Size()); if (!container.FastCheck()) { return Container::Ptr(); } MSPack::DataDecoder decoder(container); return CreatePackedContainer(decoder.GetResult(), container.GetUsedSize()); }
virtual Container::Ptr Decode(const Binary::Container& rawData) const { if (!Player->Match(rawData)) { return Container::Ptr(); } const Binary::TypedContainer typedData(rawData); const std::size_t availSize = rawData.Size(); const std::size_t playerSize = CompiledPT24::PLAYER_SIZE; const CompiledPT24::Player& rawPlayer = *typedData.GetField<CompiledPT24::Player>(0); const uint_t dataAddr = fromLE(rawPlayer.DataAddr); if (dataAddr < playerSize) { Dbg("Invalid compile addr"); return Container::Ptr(); } const CompiledPT24::RawHeader& rawHeader = *typedData.GetField<CompiledPT24::RawHeader>(playerSize); const uint_t patternsCount = CompiledPT24::GetPatternsCount(rawHeader, availSize - playerSize); if (!patternsCount) { Dbg("Invalid patterns count"); return Container::Ptr(); } const uint_t compileAddr = dataAddr - playerSize; Dbg("Detected player compiled at %1% (#%1$04x) with %2% patterns", compileAddr, patternsCount); const std::size_t modDataSize = std::min(CompiledPT24::MAX_MODULE_SIZE, availSize - playerSize); const Binary::Container::Ptr modData = rawData.GetSubcontainer(playerSize, modDataSize); const Formats::Chiptune::PatchedDataBuilder::Ptr builder = Formats::Chiptune::PatchedDataBuilder::Create(*modData); //fix samples/ornaments offsets for (uint_t idx = offsetof(CompiledPT24::RawHeader, SamplesOffsets); idx != offsetof(CompiledPT24::RawHeader, PatternsOffset); idx += 2) { builder->FixLEWord(idx, -int_t(dataAddr)); } //fix patterns offsets for (uint_t idx = fromLE(rawHeader.PatternsOffset), lim = idx + 6 * patternsCount; idx != lim; idx += 2) { builder->FixLEWord(idx, -int_t(dataAddr)); } const Binary::Container::Ptr fixedModule = builder->GetResult(); if (Formats::Chiptune::Container::Ptr fixedParsed = Decoder->Decode(*fixedModule)) { return CreatePackedContainer(fixedParsed, playerSize + fixedParsed->Size()); } Dbg("Failed to parse fixed module"); return Container::Ptr(); }
Module::Holder::Ptr CreateModule(const Parameters::Accessor& params, const Binary::Container& rawData, Parameters::Container::Ptr properties) const override { try { const TunePtr tune = std::make_shared<SidTune>(static_cast<const uint_least8_t*>(rawData.Start()), static_cast<uint_least32_t>(rawData.Size())); CheckSidplayError(tune->getStatus()); const unsigned songIdx = tune->selectSong(0); const SidTuneInfo& tuneInfo = *tune->getInfo(); if (tuneInfo.songs() > 1) { Require(HasSidContainer(*properties)); } PropertiesHelper props(*properties); switch (tuneInfo.numberOfInfoStrings()) { default: case 3: //copyright/publisher really props.SetComment(FromStdString(tuneInfo.infoString(2))); case 2: props.SetAuthor(FromStdString(tuneInfo.infoString(1))); case 1: props.SetTitle(FromStdString(tuneInfo.infoString(0))); case 0: break; } const Binary::Container::Ptr data = rawData.GetSubcontainer(0, tuneInfo.dataFileLen()); const Formats::Chiptune::Container::Ptr source = Formats::Chiptune::CreateCalculatingCrcContainer(data, 0, data->Size()); props.SetSource(*source); const uint_t fps = tuneInfo.songSpeed() == SidTuneInfo::SPEED_CIA_1A || tuneInfo.clockSpeed() == SidTuneInfo::CLOCK_NTSC ? 60 : 50; props.SetFramesFrequency(fps); const Information::Ptr info = MakePtr<Information>(GetDuration(params), tune, fps, songIdx); return MakePtr<Holder>(tune, info, properties); } catch (const std::exception&) { return Holder::Ptr(); } }
Container::Ptr Decode(const Binary::Container& rawData) const override { using namespace CompiledSTP; if (!Player->Match(rawData)) { return Container::Ptr(); } const Binary::TypedContainer typedData(rawData); const std::size_t availSize = rawData.Size(); const typename Version::RawPlayer& rawPlayer = *typedData.GetField<typename Version::RawPlayer>(0); const std::size_t playerSize = rawPlayer.GetSize(); if (playerSize >= std::min(availSize, CompiledSTP::MAX_PLAYER_SIZE)) { Dbg("Invalid player"); return Container::Ptr(); } Dbg("Detected player in first %1% bytes", playerSize); const std::size_t modDataSize = std::min(CompiledSTP::MAX_MODULE_SIZE, availSize - playerSize); const Binary::Container::Ptr modData = rawData.GetSubcontainer(playerSize, modDataSize); const Dump metainfo = rawPlayer.GetInfo(); if (CompiledSTP::IsInfoEmpty(metainfo)) { Dbg("Player has empty metainfo"); if (const Binary::Container::Ptr originalModule = Formats::Chiptune::SoundTrackerPro::ParseCompiled(*modData, Formats::Chiptune::SoundTrackerPro::GetStubBuilder())) { const std::size_t originalSize = originalModule->Size(); return CreateContainer(originalModule, playerSize + originalSize); } } else if (const Binary::Container::Ptr fixedModule = Formats::Chiptune::SoundTrackerPro::InsertMetaInformation(*modData, metainfo)) { if (Formats::Chiptune::SoundTrackerPro::ParseCompiled(*fixedModule, Formats::Chiptune::SoundTrackerPro::GetStubBuilder())) { const std::size_t originalSize = fixedModule->Size() - metainfo.size(); return CreateContainer(fixedModule, playerSize + originalSize); } Dbg("Failed to parse fixed module"); } Dbg("Failed to find module after player"); return Container::Ptr(); }
bool FastCheck(const Binary::Container& rawData) { if (rawData.Size() <= sizeof(Header)) { return false; } const Header& header = *static_cast<const Header*>(rawData.Start()); std::size_t minDataStart = sizeof(header); for (uint_t reg = 0; reg != header.Buffers.size(); ++reg) { const BufferDescription& buf = header.Buffers[reg]; if (buf.SizeHi != 1 && buf.SizeHi != 4) { return false; } const std::size_t dataOffset = buf.GetAbsoluteOffset(reg); if (dataOffset < minDataStart) { return false; } minDataStart = dataOffset; } return true; }
Formats::Chiptune::Container::Ptr Parse(const Binary::Container& rawData, Builder& target) { if (!FastCheck(rawData)) { return Formats::Chiptune::Container::Ptr(); } try { const std::size_t size = rawData.Size(); const uint8_t* const begin = static_cast<const uint8_t*>(rawData.Start()); const uint8_t* const end = begin + size; const Header& header = *safe_ptr_cast<const Header*>(begin); const uint_t frames = fromLE(header.Duration); target.SetFrames(frames); std::size_t usedBegin = size; std::size_t usedEnd = 0; for (uint_t reg = 0; reg != header.Buffers.size(); ++reg) { target.StartChannel(reg); const BufferDescription& buf = header.Buffers[reg]; const std::size_t offset = buf.GetAbsoluteOffset(reg); Require(offset < size); Stream stream(buf.SizeHi, begin + offset, end); ParseBuffer(frames, stream, target); usedBegin = std::min(usedBegin, offset); usedEnd = std::max<std::size_t>(usedEnd, stream.GetCursor() - begin); } const Binary::Container::Ptr subData = rawData.GetSubcontainer(0, usedEnd); return CreateCalculatingCrcContainer(subData, usedBegin, usedEnd - usedBegin); } catch (const std::exception&) { return Formats::Chiptune::Container::Ptr(); } }
virtual Formats::Chiptune::Container::Ptr Parse(const Binary::Container& rawData, Builder& target) const { const ModuleTraits& traits = Format->GetTraits(rawData); if (!traits.Matched()) { return Formats::Chiptune::Container::Ptr(); } target.SetFirstSubmoduleLocation(0, traits.GetFirstModuleSize()); target.SetSecondSubmoduleLocation(traits.GetFirstModuleSize(), traits.GetSecondModuleSize()); const std::size_t usedSize = traits.GetTotalSize(); const Binary::Container::Ptr subData = rawData.GetSubcontainer(0, usedSize); //use whole container as a fixed data return CreateCalculatingCrcContainer(subData, 0, usedSize); }
Formats::Chiptune::Container::Ptr Parse(const Binary::Container& data, Builder& target) { if (data.Size() < sizeof(RawHeader)) { return Formats::Chiptune::Container::Ptr(); } try { Format format(data); format.ParseMainPart(target); format.ParseExtendedPart(target); const Binary::Container::Ptr subData = format.GetUsedData(); const std::size_t fixedStart = offsetof(RawHeader, RAM); const std::size_t fixedEnd = sizeof(RawHeader); return CreateCalculatingCrcContainer(subData, fixedStart, fixedEnd - fixedStart); } catch (const std::exception&) { return Formats::Chiptune::Container::Ptr(); } }
Formats::Chiptune::Container::Ptr Parse(const Binary::Container& rawData, Builder& target) { const Binary::TypedContainer data = CreateContainer(rawData); if (!FastCheck(data)) { return Formats::Chiptune::Container::Ptr(); } try { const Format format(data); StatisticCollectingBuilder statistic(target); format.ParseCommonProperties(statistic); format.ParsePositions(statistic); Indices usedPatterns = statistic.GetUsedPatterns(); const uint_t mode = statistic.GetMode(); if (mode != SINGLE_AY_MODE && !AddTSPatterns(mode, usedPatterns)) { target.SetMode(SINGLE_AY_MODE); } format.ParsePatterns(usedPatterns, statistic); const Indices& usedSamples = statistic.GetUsedSamples(); format.ParseSamples(usedSamples, target); const Indices& usedOrnaments = statistic.GetUsedOrnaments(); format.ParseOrnaments(usedOrnaments, target); Require(format.GetSize() >= MIN_SIZE); const Binary::Container::Ptr subData = rawData.GetSubcontainer(0, format.GetSize()); const RangeChecker::Range fixedRange = format.GetFixedArea(); return CreateCalculatingCrcContainer(subData, fixedRange.first, fixedRange.second - fixedRange.first); } catch (const std::exception&) { Dbg("Failed to create"); return Formats::Chiptune::Container::Ptr(); } }
Binary::TypedContainer CreateContainer(const Binary::Container& rawData) { return Binary::TypedContainer(rawData, std::min(rawData.Size(), MAX_SIZE)); }