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(FromStdString(stream.ReadCString(MAX_STRING_SIZE)));
target.SetAuthor(FromStdString(stream.ReadCString(MAX_STRING_SIZE)));
target.SetComment(FromStdString(stream.ReadCString(MAX_COMMENT_SIZE)));
const std::size_t fixedOffset = stream.GetPosition();
for (;;)
{
const uint8_t val = stream.ReadField<uint8_t>();
if (val == FINISH)
{
break;
}
switch (val)
{
case BEGIN_FRAME:
target.BeginFrames(1);
break;
case SKIP_FRAMES:
target.BeginFrames(3 + stream.ReadField<uint8_t>());
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;
}
}
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();
}
}
String GetBuildPlatform()
{
//some business-logic
if (PLATFORM == "linux" && ARCH == "mipsel")
{
return FromStdString("dingux");
}
else if (PLATFORM == "windows" && TOOLSET == "mingw")
{
return FromStdString(TOOLSET);
}
else
{
return FromStdString(PLATFORM);
}
}
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();
}
}
void CheckCall(bool ok, Error::LocationRef loc) const
{
if (!ok)
{
if (const char* txt = SdlApi->SDL_GetError())
{
throw MakeFormattedError(loc,
translate("Error in SDL backend: %1%."), FromStdString(txt));
}
throw Error(loc, translate("Unknown error in SDL backend."));
}
}
String GetBuildArchitectureVersion()
{
return FromStdString(ARCH_VERSION);
}
String GetBuildArchitecture()
{
return FromStdString(ARCH);
}
String GetBuildDate()
{
return FromStdString(DATE);
}
String GetProgramVersion()
{
return FromStdString(VERSION);
}
String* String::FromCharArray(const char* _str)
{
std::string str(_str);
return FromStdString(str);
}
