static void load_id666(service_ptr_t<file> & p_file, LPID666TAG lpTag, abort_callback & p_abort)//must be seeked to correct spot before calling
{
t_uint8 szBuf[4];
p_file->read_object( &szBuf, 4, p_abort );
if( ! memcmp( szBuf, xid6_signature, 4 ) )
{
t_uint32 tag_size;
p_file->read_lendian_t( tag_size, p_abort );
t_filesize offset = p_file->get_position( p_abort );
service_ptr_t< reader_limited > m_file = new service_impl_t< reader_limited >;
m_file->init( p_file, offset, offset + tag_size, p_abort );
service_ptr_t<file> p_file = m_file.get_ptr();
try
{
parse_id666( p_file, lpTag, false, p_abort );
}
catch ( const exception_io_data & )
{
p_file->seek( 0, p_abort );
memset( lpTag, 0, sizeof( *lpTag ) );
parse_id666( p_file, lpTag, true, p_abort );
}
}
else throw exception_tag_not_found();
}
bool load_feature_list_from_json_file(pfc::list_base_t<feature_handle_ptr> &p_list, const service_ptr_t<file> &p_file, abort_callback &p_abort)
{
t_filesize size = p_file->get_size(p_abort);
pfc::string8 json;
{
pfc::string_buffer buffer(json, size);
p_file->read_object(buffer, size, p_abort);
}
return load_feature_list_from_json_string(p_list, json);
}
void open( service_ptr_t<file> m_file, const char * p_path, t_input_open_reason p_reason, abort_callback & p_abort )
{
if ( p_reason == input_open_info_write ) throw exception_io_data();
input_open_file_helper( m_file, p_path, p_reason, p_abort );
m_stats = m_file->get_stats( p_abort );
t_uint8 * ptr;
unsigned size;
t_filesize size64 = m_file->get_size_ex( p_abort );
if ( size64 > ( 1 << 24 ) )
throw exception_io_data();
size = (unsigned) size64;
file_buffer.set_size( size );
ptr = file_buffer.get_ptr();
m_file->read_object( ptr, size, p_abort );
m_player = ModPlug_Load(ptr, size);
if ( !m_player ) throw exception_io_data();
}
static void parse_id666( service_ptr_t< file > & p_file, LPID666TAG lpTag, bool aligned, abort_callback & p_abort )
{
while ( ! p_file->is_eof( p_abort ) )
{
t_uint8 id, type;
t_uint16 data;
p_file->read_object_t( id, p_abort );
p_file->read_object_t( type, p_abort );
p_file->read_lendian_t( data, p_abort );
switch ( type )
{
case XTYPE_STR:
{
if ( data < 1 || data > 256 ) throw exception_io_data();
switch ( id )
{
case XID_SONG:
p_file->read_object( lpTag->szTitle, data, p_abort );
break;
case XID_GAME:
p_file->read_object( lpTag->szGame, data, p_abort );
break;
case XID_ARTIST:
p_file->read_object( lpTag->szArtist, data, p_abort );
break;
case XID_PUB:
p_file->read_object( lpTag->szPublisher, data, p_abort );
break;
case XID_OST:
p_file->read_object( lpTag->szOST, data, p_abort );
break;
case XID_DUMPER:
p_file->read_object( lpTag->szDumper, data, p_abort );
break;
case XID_CMNTS:
p_file->read_object( lpTag->szComment, data, p_abort );
break;
default:
p_file->skip( data, p_abort );
break;
}
if ( aligned && ( data & 3 ) ) p_file->skip( 4 - ( data & 3 ), p_abort );
}
break;
case XTYPE_INT:
{
if ( data != 4 ) throw exception_io_data();
t_uint32 value;
p_file->read_lendian_t( value, p_abort );
switch ( id )
{
case XID_DATE:
SetDate( lpTag->szDate, ( value >> 16 ) & 255, ( value >> 8 ) & 255, value & 255 );
break;
case XID_INTRO:
if ( value > 383999999 ) value = 383999999;
lpTag->uSong_ms = value / 64;
break;
case XID_LOOP:
if ( value > 383999999 ) value = 383999999;
lpTag->uLoop_ms = value / 64;
break;
case XID_END:
if ( value > 383999999 ) value = 383999999;
lpTag->uEnd_ms = value / 64;
break;
case XID_FADE:
if ( value > 3839999 ) value = 3839999;
lpTag->uFade_ms = value / 64;
break;
case XID_AMP:
if ( value < 32768 ) value = 32768;
else if ( value > 524288 ) value = 524288;
lpTag->uAmplification = value;
break;
}
}
break;
case XTYPE_DATA:
{
switch ( id )
{
case XID_EMU:
lpTag->bEmulator = t_uint8( data );
break;
case XID_DISC:
lpTag->bDisc = t_uint8( data );
if ( lpTag->bDisc > 9 ) lpTag->bDisc = 9;
break;
case XID_TRACK:
if ( data > ( ( 100 << 8 ) - 1 ) ) data = 0;
lpTag->wTrack = data;
break;
case XID_COPY:
lpTag->wCopyright = data;
break;
case XID_MUTE:
lpTag->bMute = t_uint8( data );
break;
case XID_LOOPX:
if ( data < 1 ) data = 1;
else if ( data > 9 ) data = 9;
lpTag->uLoopCount = data;
break;
case XID_AMP:
lpTag->uAmplification = data;
lpTag->uAmplification <<= 12;
if ( lpTag->uAmplification < 32768 ) lpTag->uAmplification = 32768;
else if ( lpTag->uAmplification > 524288 ) lpTag->uAmplification = 524288;
break;
}
}
break;
}
}
}
void read_v2(const service_ptr_t<file> & p_file,abort_callback & p_abort,pfc::string_base & p_out,bool & is_utf8, bool forceUTF8) {
p_out.reset();
p_file->reopen( p_abort );
pfc::array_t<char> mem;
t_filesize size64;
size64 = p_file->get_size(p_abort);
if (size64 == filesize_invalid)//typically HTTP
{
pfc::string8 ansitemp;
t_size done;
enum { delta = 1024 * 64, max = 1024 * 512 };
if ( forceUTF8 ) {
is_utf8 = true;
} else {
is_utf8 = false;
char temp[3];
done = p_file->read(temp, 3, p_abort);
if (done != 3)
{
if (done > 0) p_out = pfc::stringcvt::string_utf8_from_ansi(temp, done);
return;
}
if (!memcmp(utf8_header, temp, 3)) is_utf8 = true;
else ansitemp.add_string(temp, 3);
}
mem.set_size(delta);
for(;;)
{
done = p_file->read(mem.get_ptr(),delta,p_abort);
if (done > 0)
{
if (is_utf8) p_out.add_string(mem.get_ptr(),done);
else ansitemp.add_string(mem.get_ptr(),done);
}
if (done < delta) break;
}
if (!is_utf8)
{
p_out = pfc::stringcvt::string_utf8_from_ansi(ansitemp);
}
return;
}
else
{
if (size64>1024*1024*128) throw exception_io_data();//hard limit
t_size size = pfc::downcast_guarded<t_size>(size64);
mem.set_size(size+1);
char * asdf = mem.get_ptr();
p_file->read_object(asdf,size,p_abort);
asdf[size]=0;
if ( forceUTF8 ) {
is_utf8 = true;
p_out = asdf;
} else if (size>3 && !memcmp(utf8_header,asdf,3)) {
is_utf8 = true;
p_out.add_string(asdf+3);
} else {
is_utf8 = false;
p_out = pfc::stringcvt::string_utf8_from_ansi(asdf);
}
return;
}
}
