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();
}
}
ScanDataContainer(Binary::Container::Ptr delegate, std::size_t offset)
: Delegate(delegate)
, OriginalSize(delegate->Size())
, OriginalData(static_cast<const uint8_t*>(delegate->Start()))
, Offset(offset)
{
}
DataLocation::Ptr Open(const Parameters::Accessor& /*params*/, DataLocation::Ptr location, const Analysis::Path& inPath) const override
{
const String& pathComp = inPath.GetIterator()->Get();
std::size_t offset = 0;
if (RawPath.GetIndex(pathComp, offset))
{
const Binary::Container::Ptr inData = location->GetData();
const Binary::Container::Ptr subData = inData->GetSubcontainer(offset, inData->Size() - offset);
return CreateNestedLocation(location, subData, Description->Id(), pathComp);
}
return DataLocation::Ptr();
}
Analysis::Result::Ptr Detect(const Parameters::Accessor& params, DataLocation::Ptr input, const Module::DetectCallback& callback) const override
{
const Binary::Container::Ptr rawData = input->GetData();
const std::size_t size = rawData->Size();
Statistic::Self().Enqueue(size);
if (size < MIN_MINIMAL_RAW_SIZE)
{
Dbg("Size is too small (%1%)", size);
return Analysis::CreateUnmatchedResult(size);
}
const RawPluginParameters scanParams(params);
const std::size_t minRawSize = scanParams.GetMinimalSize();
const String currentPath = input->GetPath()->AsString();
Dbg("Detecting modules in raw data at '%1%'", currentPath);
const Log::ProgressCallback::Ptr progress = MakePtr<RawProgressCallback>(callback, static_cast<uint_t>(size), currentPath);
const Module::DetectCallback& noProgressCallback = Module::CustomProgressDetectCallbackAdapter(callback);
const ArchivePlugin::Iterator::Ptr availableArchives = ArchivePluginsEnumerator::Create()->Enumerate();
const ArchivePlugin::Iterator::Ptr usedArchives = scanParams.GetDoubleAnalysis()
? MakePtr<DoubleAnalysisArchivePlugins>(availableArchives)
: availableArchives;
RawDetectionPlugins usedPlugins(params, PlayerPluginsEnumerator::Create()->Enumerate(), usedArchives, *this);
ScanDataLocation::Ptr subLocation = MakePtr<ScanDataLocation>(input, Description->Id(), 0);
while (subLocation->HasToScan(minRawSize))
{
const std::size_t offset = subLocation->GetOffset();
progress->OnProgress(static_cast<uint_t>(offset));
usedPlugins.SetOffset(offset);
const Module::DetectCallback& curCallback = offset ? noProgressCallback : callback;
const std::size_t bytesToSkip = usedPlugins.Detect(subLocation, curCallback);
if (!subLocation.unique())
{
Dbg("Sublocation is captured. Duplicate.");
subLocation = MakePtr<ScanDataLocation>(input, Description->Id(), offset);
}
subLocation->Move(std::max(bytesToSkip, SCAN_STEP));
}
return Analysis::CreateMatchedResult(size);
}
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();
}
}