Formats::Chiptune::Container::Ptr Parse(const Binary::Container& data, Builder& target) { if (!FastCheck(data)) { return Formats::Chiptune::Container::Ptr(); } try { Binary::InputStream stream(data); stream.ReadField<SignatureType>(); target.SetTitle(DecodeString(stream.ReadCString(MAX_STRING_SIZE))); target.SetAuthor(DecodeString(stream.ReadCString(MAX_STRING_SIZE))); target.SetComment(DecodeString(stream.ReadCString(MAX_COMMENT_SIZE))); const std::size_t fixedOffset = stream.GetPosition(); std::size_t totalFrames = 0; for (;;) { const uint8_t val = stream.ReadField<uint8_t>(); if (val == FINISH) { break; } switch (val) { case BEGIN_FRAME: ++totalFrames; target.BeginFrames(1); break; case SKIP_FRAMES: { const uint_t frames = 3 + stream.ReadField<uint8_t>(); totalFrames += frames; target.BeginFrames(frames); } break; case SELECT_SECOND_CHIP: target.SelectChip(1); break; case SELECT_FIRST_CHIP: target.SelectChip(0); break; case LOOP_MARKER: target.SetLoop(); break; default: target.SetRegister(val, stream.ReadField<uint8_t>()); break; } } Require(totalFrames >= MIN_FRAMES); const std::size_t usedSize = stream.GetPosition(); const auto subData = stream.GetReadData(); return CreateCalculatingCrcContainer(subData, fixedOffset, usedSize - fixedOffset); } catch (const std::exception&) { return Formats::Chiptune::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); }
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(); } }
void Phx::SearchForCollisions() { for(int i=0;i<Collisions.size();i++) // Usuwamy wszystkie pozosta³e kolizje delete Collisions[i]; Collisions.clear(); if(BodyList.size() == 0) return; for(int a=0 ; a < BodyList.size()-1 ; a++) // Dla ka¿dej pary cia³ A i B { for(int b=a+1 ; b<BodyList.size() ; b++) { if(BodyList[a]->dynamic == false && BodyList[b]->dynamic == false) continue; if(FastCheck(BodyList[a] , BodyList[b]) ) Check( BodyList[a]->shape , BodyList[b]->shape ); } } }
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(); } }
bool Check(const Binary::Container& rawData) const override { return FastCheck(rawData); }
bool Check(const Binary::Container& rawData) const override { return Format->Match(rawData) && FastCheck(rawData); }
bool FastCheck(const Binary::Container& rawData) { const Binary::TypedContainer data = CreateContainer(rawData); return FastCheck(data); }