1139 lines
30 KiB
Plaintext
1139 lines
30 KiB
Plaintext
//
|
|
// HCDecoder.m
|
|
// HighlyComplete
|
|
//
|
|
// Created by Christopher Snowhill on 9/30/13.
|
|
// Copyright 2013 __NoWork, Inc__. All rights reserved.
|
|
//
|
|
|
|
#import "HCDecoder.h"
|
|
|
|
#import "hebios.h"
|
|
|
|
#import <psflib/psflib.h>
|
|
#import <psflib/psf2fs.h>
|
|
|
|
#import <HighlyExperimental/psx.h>
|
|
#import <HighlyExperimental/bios.h>
|
|
#import <HighlyExperimental/iop.h>
|
|
#import <HighlyExperimental/r3000.h>
|
|
|
|
#import <HighlyTheoretical/sega.h>
|
|
|
|
#import <HighlyQuixotic/qsound.h>
|
|
|
|
#import <HighlyAdvanced/GBA.h>
|
|
|
|
#include <vector>
|
|
#import <SSEQPlayer/SDAT.h>
|
|
#import <SSEQPlayer/Player.h>
|
|
|
|
@interface psf_file_container : NSObject {
|
|
NSLock * lock;
|
|
NSMutableDictionary * list;
|
|
}
|
|
+ (psf_file_container *)instance;
|
|
- (void)add_hint:(NSString *)path source:(id)source;
|
|
- (void)remove_hint:(NSString *)path;
|
|
- (BOOL)try_hint:(NSString *)path source:(id*)source;
|
|
@end
|
|
|
|
@implementation psf_file_container
|
|
+ (psf_file_container *)instance {
|
|
static psf_file_container * instance;
|
|
|
|
@synchronized(self) {
|
|
if (!instance) {
|
|
instance = [[self alloc] init];
|
|
}
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
- (psf_file_container *)init
|
|
{
|
|
if ((self = [super init]))
|
|
{
|
|
lock = [[NSLock alloc] init];
|
|
list = [[NSMutableDictionary alloc] initWithCapacity:0];
|
|
}
|
|
return self;
|
|
}
|
|
- (void)dealloc
|
|
{
|
|
[list release];
|
|
[lock release];
|
|
[super dealloc];
|
|
}
|
|
- (void)add_hint:(NSString *)path source:(id)source
|
|
{
|
|
[lock lock];
|
|
[list setObject:source forKey:path];
|
|
[lock unlock];
|
|
}
|
|
- (void)remove_hint:(NSString *)path
|
|
{
|
|
[lock lock];
|
|
[list removeObjectForKey:path];
|
|
[lock unlock];
|
|
}
|
|
- (BOOL)try_hint:(NSString *)path source:(id *)source
|
|
{
|
|
[lock lock];
|
|
*source = [list objectForKey:path];
|
|
[lock unlock];
|
|
if ( *source )
|
|
{
|
|
[ *source seek:0 whence:0 ];
|
|
return YES;
|
|
}
|
|
else
|
|
{
|
|
return NO;
|
|
}
|
|
}
|
|
@end
|
|
|
|
|
|
void * source_fopen(const char * path)
|
|
{
|
|
id<CogSource> source;
|
|
if ( ![[psf_file_container instance] try_hint:[NSString stringWithUTF8String:path] source:&source] )
|
|
{
|
|
NSString * urlString = [NSString stringWithUTF8String:path];
|
|
NSURL * url = [NSURL URLWithString:[urlString stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]];
|
|
|
|
id audioSourceClass = NSClassFromString(@"AudioSource");
|
|
source = [audioSourceClass audioSourceForURL:url];
|
|
|
|
if (![source open:url])
|
|
return 0;
|
|
|
|
if (![source seekable])
|
|
return 0;
|
|
}
|
|
|
|
return [source retain];
|
|
}
|
|
|
|
size_t source_fread(void * buffer, size_t size, size_t count, void * handle)
|
|
{
|
|
id source = (id)handle;
|
|
|
|
return [source read:buffer amount:(size * count)] / size;
|
|
}
|
|
|
|
int source_fseek(void * handle, int64_t offset, int whence)
|
|
{
|
|
id source = (id)handle;
|
|
|
|
return [source seek:(long)offset whence:whence] ? 0 : -1;
|
|
}
|
|
|
|
int source_fclose(void * handle)
|
|
{
|
|
id source = (id)handle;
|
|
|
|
[source release];
|
|
|
|
return 0;
|
|
}
|
|
|
|
long source_ftell(void * handle)
|
|
{
|
|
id source = (id)handle;
|
|
|
|
return [source tell];
|
|
}
|
|
|
|
static psf_file_callbacks source_callbacks =
|
|
{
|
|
"/|\\",
|
|
source_fopen,
|
|
source_fread,
|
|
source_fseek,
|
|
source_fclose,
|
|
source_ftell
|
|
};
|
|
|
|
|
|
@implementation HCDecoder
|
|
|
|
+ (void)initialize
|
|
{
|
|
bios_set_image(hebios, HEBIOS_SIZE);
|
|
psx_init();
|
|
sega_init();
|
|
qsound_init();
|
|
}
|
|
|
|
- (NSDictionary *)metadata
|
|
{
|
|
return metadataList;
|
|
}
|
|
|
|
- (long)retrieveFrameCount:(long)ms
|
|
{
|
|
return ms * (sampleRate / 100) / 10;
|
|
}
|
|
|
|
struct psf_info_meta_state
|
|
{
|
|
NSMutableDictionary * info;
|
|
|
|
bool utf8;
|
|
|
|
int tag_length_ms;
|
|
int tag_fade_ms;
|
|
|
|
float albumGain;
|
|
float albumPeak;
|
|
float trackGain;
|
|
float trackPeak;
|
|
float volume;
|
|
};
|
|
|
|
static int parse_time_crap(NSString * value)
|
|
{
|
|
NSArray *components = [value componentsSeparatedByString:@":"];
|
|
|
|
float totalSeconds = 0;
|
|
float multiplier = 1000;
|
|
bool first = YES;
|
|
for (id component in [components reverseObjectEnumerator]) {
|
|
if (first) {
|
|
first = NO;
|
|
totalSeconds += [component floatValue] * multiplier;
|
|
} else {
|
|
totalSeconds += [component integerValue] * multiplier;
|
|
}
|
|
multiplier *= 60;
|
|
}
|
|
|
|
return totalSeconds;
|
|
}
|
|
|
|
static int psf_info_meta(void * context, const char * name, const char * value)
|
|
{
|
|
struct psf_info_meta_state * state = ( struct psf_info_meta_state * ) context;
|
|
|
|
NSString * tag = [NSString stringWithUTF8String:name];
|
|
NSString * taglc = [tag lowercaseString];
|
|
NSString * svalue = [NSString stringWithUTF8String:value];
|
|
|
|
if ( svalue == nil )
|
|
return 0;
|
|
|
|
if ([taglc isEqualToString:@"game"])
|
|
{
|
|
taglc = @"album";
|
|
}
|
|
else if ([taglc isEqualToString:@"date"])
|
|
{
|
|
taglc = @"year";
|
|
}
|
|
|
|
if ([taglc hasPrefix:@"replaygain_"])
|
|
{
|
|
if ([taglc hasPrefix:@"replaygain_album_"])
|
|
{
|
|
if ([taglc hasSuffix:@"gain"])
|
|
state->albumGain = [svalue floatValue];
|
|
else if ([taglc hasSuffix:@"peak"])
|
|
state->albumPeak = [svalue floatValue];
|
|
}
|
|
else if ([taglc hasPrefix:@"replaygain_track_"])
|
|
{
|
|
if ([taglc hasSuffix:@"gain"])
|
|
state->trackGain = [svalue floatValue];
|
|
else if ([taglc hasSuffix:@"peak"])
|
|
state->trackPeak = [svalue floatValue];
|
|
}
|
|
}
|
|
else if ([taglc isEqualToString:@"volume"])
|
|
{
|
|
state->volume = [svalue floatValue];
|
|
}
|
|
else if ([taglc isEqualToString:@"length"])
|
|
{
|
|
state->tag_length_ms = parse_time_crap(svalue);
|
|
}
|
|
else if ([taglc isEqualToString:@"fade"])
|
|
{
|
|
state->tag_fade_ms = parse_time_crap(svalue);
|
|
}
|
|
else if ([taglc isEqualToString:@"utf8"])
|
|
{
|
|
state->utf8 = true;
|
|
}
|
|
else if ([taglc hasPrefix:@"_lib"])
|
|
{
|
|
}
|
|
else if ([taglc isEqualToString:@"_refresh"])
|
|
{
|
|
}
|
|
else if ([taglc hasPrefix:@"_"])
|
|
{
|
|
return -1;
|
|
}
|
|
else if ([taglc isEqualToString:@"title"] ||
|
|
[taglc isEqualToString:@"artist"] ||
|
|
[taglc isEqualToString:@"album"] ||
|
|
[taglc isEqualToString:@"year"] ||
|
|
[taglc isEqualToString:@"genre"] ||
|
|
[taglc isEqualToString:@"track"])
|
|
{
|
|
[state->info setObject:svalue forKey:taglc];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct psf1_load_state
|
|
{
|
|
void * emu;
|
|
bool first;
|
|
unsigned refresh;
|
|
};
|
|
|
|
typedef struct {
|
|
uint32_t pc0;
|
|
uint32_t gp0;
|
|
uint32_t t_addr;
|
|
uint32_t t_size;
|
|
uint32_t d_addr;
|
|
uint32_t d_size;
|
|
uint32_t b_addr;
|
|
uint32_t b_size;
|
|
uint32_t s_ptr;
|
|
uint32_t s_size;
|
|
uint32_t sp,fp,gp,ret,base;
|
|
} exec_header_t;
|
|
|
|
typedef struct {
|
|
char key[8];
|
|
uint32_t text;
|
|
uint32_t data;
|
|
exec_header_t exec;
|
|
char title[60];
|
|
} psxexe_hdr_t;
|
|
|
|
static int psf1_info(void * context, const char * name, const char * value)
|
|
{
|
|
struct psf1_load_state * state = ( struct psf1_load_state * ) context;
|
|
|
|
NSString * sname = [[NSString stringWithUTF8String:name] lowercaseString];
|
|
NSString * svalue = [NSString stringWithUTF8String:value];
|
|
|
|
if ( !state->refresh && [sname isEqualToString:@"_refresh"] )
|
|
{
|
|
state->refresh = [svalue intValue];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned get_be16( void const* p )
|
|
{
|
|
return (unsigned) ((unsigned char const*) p) [0] << 8 |
|
|
(unsigned) ((unsigned char const*) p) [1];
|
|
}
|
|
|
|
unsigned get_le32( void const* p )
|
|
{
|
|
return (unsigned) ((unsigned char const*) p) [3] << 24 |
|
|
(unsigned) ((unsigned char const*) p) [2] << 16 |
|
|
(unsigned) ((unsigned char const*) p) [1] << 8 |
|
|
(unsigned) ((unsigned char const*) p) [0];
|
|
}
|
|
|
|
unsigned get_be32( void const* p )
|
|
{
|
|
return (unsigned) ((unsigned char const*) p) [0] << 24 |
|
|
(unsigned) ((unsigned char const*) p) [1] << 16 |
|
|
(unsigned) ((unsigned char const*) p) [2] << 8 |
|
|
(unsigned) ((unsigned char const*) p) [3];
|
|
}
|
|
|
|
void set_le32( void* p, unsigned n )
|
|
{
|
|
((unsigned char*) p) [0] = (unsigned char) n;
|
|
((unsigned char*) p) [1] = (unsigned char) (n >> 8);
|
|
((unsigned char*) p) [2] = (unsigned char) (n >> 16);
|
|
((unsigned char*) p) [3] = (unsigned char) (n >> 24);
|
|
}
|
|
|
|
int psf1_loader(void * context, const uint8_t * exe, size_t exe_size,
|
|
const uint8_t * reserved, size_t reserved_size)
|
|
{
|
|
struct psf1_load_state * state = ( struct psf1_load_state * ) context;
|
|
|
|
psxexe_hdr_t *psx = (psxexe_hdr_t *) exe;
|
|
|
|
if ( exe_size < 0x800 ) return -1;
|
|
if ( exe_size > UINT_MAX ) return -1;
|
|
|
|
uint32_t addr = get_le32( &psx->exec.t_addr );
|
|
uint32_t size = (uint32_t)exe_size - 0x800;
|
|
|
|
addr &= 0x1fffff;
|
|
if ( ( addr < 0x10000 ) || ( size > 0x1f0000 ) || ( addr + size > 0x200000 ) ) return -1;
|
|
|
|
void * pIOP = psx_get_iop_state( state->emu );
|
|
iop_upload_to_ram( pIOP, addr, exe + 0x800, size );
|
|
|
|
if ( !state->refresh )
|
|
{
|
|
if (!strncasecmp((const char *) exe + 113, "Japan", 5)) state->refresh = 60;
|
|
else if (!strncasecmp((const char *) exe + 113, "Europe", 6)) state->refresh = 50;
|
|
else if (!strncasecmp((const char *) exe + 113, "North America", 13)) state->refresh = 60;
|
|
}
|
|
|
|
if ( state->first )
|
|
{
|
|
void * pR3000 = iop_get_r3000_state( pIOP );
|
|
r3000_setreg(pR3000, R3000_REG_PC, get_le32( &psx->exec.pc0 ) );
|
|
r3000_setreg(pR3000, R3000_REG_GEN+29, get_le32( &psx->exec.s_ptr ) );
|
|
state->first = false;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int EMU_CALL virtual_readfile(void *context, const char *path, int offset, char *buffer, int length)
|
|
{
|
|
return psf2fs_virtual_readfile(context, path, offset, buffer, length);
|
|
}
|
|
|
|
struct sdsf_loader_state
|
|
{
|
|
uint8_t * data;
|
|
size_t data_size;
|
|
};
|
|
|
|
int sdsf_loader(void * context, const uint8_t * exe, size_t exe_size,
|
|
const uint8_t * reserved, size_t reserved_size)
|
|
{
|
|
if ( exe_size < 4 ) return -1;
|
|
|
|
struct sdsf_loader_state * state = ( struct sdsf_loader_state * ) context;
|
|
|
|
uint8_t * dst = state->data;
|
|
|
|
if ( state->data_size < 4 ) {
|
|
state->data = dst = ( uint8_t * ) malloc( exe_size );
|
|
state->data_size = exe_size;
|
|
memcpy( dst, exe, exe_size );
|
|
return 0;
|
|
}
|
|
|
|
uint32_t dst_start = get_le32( dst );
|
|
uint32_t src_start = get_le32( exe );
|
|
dst_start &= 0x7fffff;
|
|
src_start &= 0x7fffff;
|
|
size_t dst_len = state->data_size - 4;
|
|
size_t src_len = exe_size - 4;
|
|
if ( dst_len > 0x800000 ) dst_len = 0x800000;
|
|
if ( src_len > 0x800000 ) src_len = 0x800000;
|
|
|
|
if ( src_start < dst_start )
|
|
{
|
|
uint32_t diff = dst_start - src_start;
|
|
state->data_size = dst_len + 4 + diff;
|
|
state->data = dst = ( uint8_t * ) realloc( dst, state->data_size );
|
|
memmove( dst + 4 + diff, dst + 4, dst_len );
|
|
memset( dst + 4, 0, diff );
|
|
dst_len += diff;
|
|
dst_start = src_start;
|
|
set_le32( dst, dst_start );
|
|
}
|
|
if ( ( src_start + src_len ) > ( dst_start + dst_len ) )
|
|
{
|
|
size_t diff = ( src_start + src_len ) - ( dst_start + dst_len );
|
|
state->data_size = dst_len + 4 + diff;
|
|
state->data = dst = ( uint8_t * ) realloc( dst, state->data_size );
|
|
memset( dst + 4 + dst_len, 0, diff );
|
|
}
|
|
|
|
memcpy( dst + 4 + ( src_start - dst_start ), exe + 4, src_len );
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct qsf_loader_state
|
|
{
|
|
uint8_t * key;
|
|
uint32_t key_size;
|
|
|
|
uint8_t * z80_rom;
|
|
uint32_t z80_size;
|
|
|
|
uint8_t * sample_rom;
|
|
uint32_t sample_size;
|
|
};
|
|
|
|
static int upload_section( struct qsf_loader_state * state, const char * section, uint32_t start,
|
|
const uint8_t * data, uint32_t size )
|
|
{
|
|
uint8_t ** array = NULL;
|
|
uint32_t * array_size = NULL;
|
|
uint32_t max_size = 0x7fffffff;
|
|
|
|
if ( !strcmp( section, "KEY" ) ) { array = &state->key; array_size = &state->key_size; max_size = 11; }
|
|
else if ( !strcmp( section, "Z80" ) ) { array = &state->z80_rom; array_size = &state->z80_size; }
|
|
else if ( !strcmp( section, "SMP" ) ) { array = &state->sample_rom; array_size = &state->sample_size; }
|
|
else return -1;
|
|
|
|
if ( ( start + size ) < start ) return -1;
|
|
|
|
uint32_t new_size = start + size;
|
|
uint32_t old_size = *array_size;
|
|
if ( new_size > max_size ) return -1;
|
|
|
|
if ( new_size > old_size ) {
|
|
*array = ( uint8_t * ) realloc( *array, new_size );
|
|
*array_size = new_size;
|
|
memset( (*array) + old_size, 0, new_size - old_size );
|
|
}
|
|
|
|
memcpy( (*array) + start, data, size );
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qsf_loader(void * context, const uint8_t * exe, size_t exe_size,
|
|
const uint8_t * reserved, size_t reserved_size)
|
|
{
|
|
struct qsf_loader_state * state = ( struct qsf_loader_state * ) context;
|
|
|
|
for (;;) {
|
|
char s[4];
|
|
if ( exe_size < 11 ) break;
|
|
memcpy( s, exe, 3 ); exe += 3; exe_size -= 3;
|
|
s [3] = 0;
|
|
uint32_t dataofs = get_le32( exe ); exe += 4; exe_size -= 4;
|
|
uint32_t datasize = get_le32( exe ); exe += 4; exe_size -= 4;
|
|
if ( datasize > exe_size )
|
|
return -1;
|
|
|
|
if ( upload_section( state, s, dataofs, exe, datasize ) < 0 )
|
|
return -1;
|
|
|
|
exe += datasize;
|
|
exe_size -= datasize;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct gsf_loader_state
|
|
{
|
|
int entry_set;
|
|
uint32_t entry;
|
|
uint8_t * data;
|
|
size_t data_size;
|
|
};
|
|
|
|
int gsf_loader(void * context, const uint8_t * exe, size_t exe_size,
|
|
const uint8_t * reserved, size_t reserved_size)
|
|
{
|
|
if ( exe_size < 12 ) return -1;
|
|
|
|
struct gsf_loader_state * state = ( struct gsf_loader_state * ) context;
|
|
|
|
unsigned char *iptr;
|
|
size_t isize;
|
|
unsigned char *xptr;
|
|
unsigned xentry = get_le32(exe + 0);
|
|
unsigned xsize = get_le32(exe + 8);
|
|
unsigned xofs = get_le32(exe + 4) & 0x1ffffff;
|
|
if ( xsize < exe_size - 12 ) return -1;
|
|
if (!state->entry_set)
|
|
{
|
|
state->entry = xentry;
|
|
state->entry_set = 1;
|
|
}
|
|
{
|
|
iptr = state->data;
|
|
isize = state->data_size;
|
|
state->data = 0;
|
|
state->data_size = 0;
|
|
}
|
|
if (!iptr)
|
|
{
|
|
size_t rsize = xofs + xsize;
|
|
{
|
|
rsize -= 1;
|
|
rsize |= rsize >> 1;
|
|
rsize |= rsize >> 2;
|
|
rsize |= rsize >> 4;
|
|
rsize |= rsize >> 8;
|
|
rsize |= rsize >> 16;
|
|
rsize += 1;
|
|
}
|
|
iptr = (unsigned char *) malloc(rsize + 10);
|
|
if (!iptr)
|
|
return -1;
|
|
memset(iptr, 0, rsize + 10);
|
|
isize = rsize;
|
|
}
|
|
else if (isize < xofs + xsize)
|
|
{
|
|
size_t rsize = xofs + xsize;
|
|
{
|
|
rsize -= 1;
|
|
rsize |= rsize >> 1;
|
|
rsize |= rsize >> 2;
|
|
rsize |= rsize >> 4;
|
|
rsize |= rsize >> 8;
|
|
rsize |= rsize >> 16;
|
|
rsize += 1;
|
|
}
|
|
xptr = (unsigned char *) realloc(iptr, xofs + rsize + 10);
|
|
if (!xptr)
|
|
{
|
|
free(iptr);
|
|
return -1;
|
|
}
|
|
iptr = xptr;
|
|
isize = rsize;
|
|
}
|
|
memcpy(iptr + xofs, exe + 12, xsize);
|
|
{
|
|
state->data = iptr;
|
|
state->data_size = isize;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
struct gsf_sound_out : public GBASoundOut
|
|
{
|
|
uint8_t * buffer;
|
|
size_t samples_written;
|
|
size_t buffer_size;
|
|
gsf_sound_out() : buffer( nil ), samples_written( 0 ), buffer_size( 0 ) { }
|
|
virtual ~gsf_sound_out() { if ( buffer ) free( buffer ); }
|
|
// Receives signed 16-bit stereo audio and a byte count
|
|
virtual void write(const void * samples, unsigned long bytes)
|
|
{
|
|
if ( bytes + samples_written > buffer_size )
|
|
{
|
|
size_t new_buffer_size = ( buffer_size + bytes + 2047 ) & ~2047;
|
|
buffer = ( uint8_t * ) realloc( buffer, new_buffer_size );
|
|
buffer_size = new_buffer_size;
|
|
}
|
|
memcpy( buffer + samples_written, samples, bytes );
|
|
samples_written += bytes;
|
|
}
|
|
};
|
|
|
|
struct ncsf_loader_state
|
|
{
|
|
uint32_t sseq;
|
|
std::vector<uint8_t> sdatData;
|
|
std::unique_ptr<SDAT> sdat;
|
|
|
|
ncsf_loader_state() : sseq( 0 ) { }
|
|
};
|
|
|
|
int ncsf_loader(void * context, const uint8_t * exe, size_t exe_size,
|
|
const uint8_t * reserved, size_t reserved_size)
|
|
{
|
|
struct ncsf_loader_state * state = ( struct ncsf_loader_state * ) context;
|
|
|
|
if ( reserved_size >= 4 )
|
|
{
|
|
state->sseq = get_le32( reserved );
|
|
}
|
|
|
|
if ( exe_size >= 12 )
|
|
{
|
|
uint32_t sdat_size = get_le32( exe + 8 );
|
|
if ( sdat_size > exe_size ) return -1;
|
|
|
|
if ( state->sdatData.empty() )
|
|
state->sdatData.resize( sdat_size, 0 );
|
|
else if ( state->sdatData.size() < sdat_size )
|
|
state->sdatData.resize( sdat_size );
|
|
memcpy( &state->sdatData[0], exe, sdat_size );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
- (BOOL)initializeDecoder
|
|
{
|
|
if ( type == 1 )
|
|
{
|
|
emulatorCore = ( uint8_t * ) malloc( psx_get_state_size( 1 ) );
|
|
|
|
psx_clear_state( emulatorCore, 1 );
|
|
|
|
struct psf1_load_state state;
|
|
|
|
state.emu = emulatorCore;
|
|
state.first = true;
|
|
state.refresh = 0;
|
|
|
|
if ( psf_load( [currentUrl UTF8String], &source_callbacks, 1, psf1_loader, &state, psf1_info, &state ) <= 0 )
|
|
return NO;
|
|
|
|
if ( state.refresh )
|
|
psx_set_refresh( emulatorCore, state.refresh );
|
|
}
|
|
else if ( type == 2 )
|
|
{
|
|
emulatorExtra = psf2fs_create();
|
|
|
|
struct psf1_load_state state;
|
|
|
|
state.refresh = 0;
|
|
|
|
if ( psf_load( [currentUrl UTF8String], &source_callbacks, 2, psf2fs_load_callback, emulatorExtra, psf1_info, &state ) <= 0 )
|
|
return NO;
|
|
|
|
emulatorCore = ( uint8_t * ) malloc( psx_get_state_size( 2 ) );
|
|
|
|
psx_clear_state( emulatorCore, 2 );
|
|
|
|
if ( state.refresh )
|
|
psx_set_refresh( emulatorCore, state.refresh );
|
|
|
|
psx_set_readfile( emulatorCore, virtual_readfile, emulatorExtra );
|
|
}
|
|
else if ( type == 0x11 || type == 0x12 )
|
|
{
|
|
struct sdsf_loader_state state;
|
|
memset( &state, 0, sizeof(state) );
|
|
|
|
if ( psf_load( [currentUrl UTF8String], &source_callbacks, type, sdsf_loader, &state, 0, 0) <= 0 )
|
|
return NO;
|
|
|
|
emulatorCore = ( uint8_t * ) malloc( sega_get_state_size( type - 0x10 ) );
|
|
|
|
sega_clear_state( emulatorCore, type - 0x10 );
|
|
|
|
sega_enable_dry( emulatorCore, 1 );
|
|
sega_enable_dsp( emulatorCore, 1 );
|
|
|
|
sega_enable_dsp_dynarec( emulatorCore, 0 );
|
|
|
|
uint32_t start = *(uint32_t*) state.data;
|
|
size_t length = state.data_size;
|
|
const size_t max_length = ( type == 0x12 ) ? 0x800000 : 0x80000;
|
|
if ( ( start + ( length - 4 ) ) > max_length ) {
|
|
length = max_length - start + 4;
|
|
}
|
|
sega_upload_program( emulatorCore, state.data, (uint32_t)length );
|
|
|
|
free( state.data );
|
|
}
|
|
else if ( type == 0x22 )
|
|
{
|
|
struct gsf_loader_state state;
|
|
memset( &state, 0, sizeof(state) );
|
|
|
|
if ( psf_load( [currentUrl UTF8String], &source_callbacks, 0x22, gsf_loader, &state, 0, 0 ) <= 0 )
|
|
return NO;
|
|
|
|
if ( state.data_size > UINT_MAX )
|
|
return NO;
|
|
|
|
GBASystem * system = new GBASystem;
|
|
|
|
emulatorCore = ( uint8_t * ) system;
|
|
|
|
system->cpuIsMultiBoot = ((state.entry >> 24) == 2);
|
|
|
|
CPULoadRom( system, state.data, (uint32_t)state.data_size );
|
|
|
|
free( state.data );
|
|
|
|
struct gsf_sound_out * sound_out = new gsf_sound_out;
|
|
|
|
emulatorExtra = sound_out;
|
|
|
|
soundInit( system, sound_out );
|
|
soundReset( system );
|
|
|
|
CPUInit( system );
|
|
CPUReset( system );
|
|
}
|
|
else if ( type == 0x25 )
|
|
{
|
|
struct ncsf_loader_state * state = new struct ncsf_loader_state;
|
|
|
|
if ( psf_load( [currentUrl UTF8String], &source_callbacks, 0x25, ncsf_loader, state, 0, 0) <= 0 )
|
|
{
|
|
delete state;
|
|
return NO;
|
|
}
|
|
|
|
Player * player = new Player;
|
|
|
|
player->interpolation = INTERPOLATION_LANCZOS;
|
|
|
|
PseudoFile file;
|
|
file.data = &state->sdatData;
|
|
|
|
state->sdat.reset(new SDAT(file, state->sseq));
|
|
|
|
auto * sseqToPlay = state->sdat->sseq.get();
|
|
|
|
player->sampleRate = 44100;
|
|
player->Setup( sseqToPlay );
|
|
player->Timer();
|
|
|
|
emulatorCore = ( uint8_t * ) player;
|
|
emulatorExtra = state;
|
|
}
|
|
else if ( type == 0x41 )
|
|
{
|
|
struct qsf_loader_state * state = ( struct qsf_loader_state * ) calloc( 1, sizeof( *state ) );
|
|
|
|
emulatorExtra = state;
|
|
|
|
if ( psf_load( [currentUrl UTF8String], &source_callbacks, 0x41, qsf_loader, state, 0, 0) <= 0 )
|
|
return NO;
|
|
|
|
emulatorCore = ( uint8_t * ) malloc( qsound_get_state_size() );
|
|
|
|
qsound_clear_state( emulatorCore );
|
|
|
|
if(state->key_size == 11) {
|
|
uint8_t * ptr = state->key;
|
|
uint32_t swap_key1 = get_be32( ptr + 0 );
|
|
uint32_t swap_key2 = get_be32( ptr + 4 );
|
|
uint32_t addr_key = get_be16( ptr + 8 );
|
|
uint8_t xor_key = *( ptr + 10 );
|
|
qsound_set_kabuki_key( emulatorCore, swap_key1, swap_key2, addr_key, xor_key );
|
|
} else {
|
|
qsound_set_kabuki_key( emulatorCore, 0, 0, 0, 0 );
|
|
}
|
|
qsound_set_z80_rom( emulatorCore, state->z80_rom, state->z80_size );
|
|
qsound_set_sample_rom( emulatorCore, state->sample_rom, state->sample_size );
|
|
}
|
|
else return NO;
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)open:(id<CogSource>)source
|
|
{
|
|
if (![source seekable]) {
|
|
return NO;
|
|
}
|
|
|
|
currentSource = [source retain];
|
|
|
|
struct psf_info_meta_state info;
|
|
|
|
info.info = [NSMutableDictionary dictionary];
|
|
info.utf8 = false;
|
|
info.tag_length_ms = 0;
|
|
info.tag_fade_ms = 0;
|
|
|
|
info.albumGain = 0;
|
|
info.albumPeak = 0;
|
|
info.trackGain = 0;
|
|
info.trackPeak = 0;
|
|
info.volume = 1;
|
|
|
|
currentUrl = [[[[source url] absoluteString] stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding] retain];
|
|
|
|
[[psf_file_container instance] add_hint:currentUrl source:currentSource];
|
|
|
|
type = psf_load( [currentUrl UTF8String], &source_callbacks, 0, 0, 0, psf_info_meta, &info );
|
|
|
|
if (type <= 0)
|
|
return NO;
|
|
|
|
emulatorCore = nil;
|
|
emulatorExtra = nil;
|
|
|
|
sampleRate = 44100;
|
|
|
|
if ( type == 2 )
|
|
sampleRate = 48000;
|
|
|
|
tagLengthMs = info.tag_length_ms;
|
|
tagFadeMs = info.tag_fade_ms;
|
|
|
|
if (!tagLengthMs) {
|
|
tagLengthMs = ( 2 * 60 + 30 ) * 1000;
|
|
tagFadeMs = 8000;
|
|
}
|
|
|
|
replayGainAlbumGain = info.albumGain;
|
|
replayGainAlbumPeak = info.albumPeak;
|
|
replayGainTrackGain = info.trackGain;
|
|
replayGainTrackPeak = info.trackPeak;
|
|
volume = info.volume;
|
|
|
|
metadataList = info.info;
|
|
|
|
framesRead = 0;
|
|
framesLength = [self retrieveFrameCount:tagLengthMs];
|
|
totalFrames = [self retrieveFrameCount:tagLengthMs + tagFadeMs];
|
|
|
|
[self willChangeValueForKey:@"properties"];
|
|
[self didChangeValueForKey:@"properties"];
|
|
|
|
return YES;
|
|
}
|
|
|
|
|
|
- (int)readAudio:(void *)buf frames:(UInt32)frames
|
|
{
|
|
if ( !emulatorCore )
|
|
{
|
|
if (![self initializeDecoder])
|
|
return 0;
|
|
}
|
|
|
|
if ( type == 1 || type == 2 )
|
|
{
|
|
uint32_t howmany = frames;
|
|
psx_execute( emulatorCore, 0x7fffffff, ( int16_t * ) buf, &howmany, 0 );
|
|
frames = howmany;
|
|
}
|
|
else if ( type == 0x11 || type == 0x12 )
|
|
{
|
|
uint32_t howmany = frames;
|
|
sega_execute( emulatorCore, 0x7fffffff, ( int16_t * ) buf, &howmany );
|
|
frames = howmany;
|
|
}
|
|
else if ( type == 0x22 )
|
|
{
|
|
GBASystem * system = ( GBASystem * ) emulatorCore;
|
|
struct gsf_sound_out * sound_out = ( struct gsf_sound_out * ) emulatorExtra;
|
|
|
|
if ( frames * 4 > sound_out->samples_written )
|
|
CPULoop( system, 250000 );
|
|
|
|
unsigned long frames_rendered = sound_out->samples_written / 4;
|
|
|
|
if ( frames_rendered >= frames )
|
|
{
|
|
memcpy( buf, sound_out->buffer, frames * 4 );
|
|
frames_rendered -= frames;
|
|
memcpy( sound_out->buffer, sound_out->buffer + frames * 4, frames_rendered * 4 );
|
|
}
|
|
else
|
|
{
|
|
memcpy( buf, sound_out->buffer, frames_rendered * 4 );
|
|
frames = (UInt32)frames_rendered;
|
|
frames_rendered = 0;
|
|
}
|
|
sound_out->samples_written = frames_rendered;
|
|
}
|
|
else if ( type == 0x25 )
|
|
{
|
|
size_t buffer_size = frames * sizeof(int16_t) * 2;
|
|
std::vector<uint8_t> buffer;
|
|
buffer.resize( buffer_size );
|
|
Player * player = ( Player * ) emulatorCore;
|
|
player->GenerateSamples(buffer, 0, frames);
|
|
memcpy( buf, &buffer[0], buffer_size );
|
|
}
|
|
else if ( type == 0x41 )
|
|
{
|
|
uint32_t howmany = frames;
|
|
qsound_execute( emulatorCore, 0x7fffffff, ( int16_t * ) buf, &howmany);
|
|
frames = howmany;
|
|
}
|
|
|
|
if ( framesRead >= framesLength ) {
|
|
long fadeStart = framesRead;
|
|
long fadeEnd = framesRead + frames;
|
|
long fadeTotal = totalFrames - framesLength;
|
|
long fadePos;
|
|
|
|
int16_t * buf16 = ( int16_t * ) buf;
|
|
|
|
for (fadePos = fadeStart; fadePos < fadeEnd && fadePos < totalFrames; ++fadePos) {
|
|
long scale = totalFrames - fadePos;
|
|
buf16[ 0 ] = buf16[ 0 ] * scale / fadeTotal;
|
|
buf16[ 1 ] = buf16[ 1 ] * scale / fadeTotal;
|
|
buf16 += 2;
|
|
}
|
|
|
|
if (fadePos < fadeEnd)
|
|
frames = (int)(fadePos - fadeStart);
|
|
}
|
|
|
|
framesRead += frames;
|
|
|
|
return frames;
|
|
}
|
|
|
|
- (void)closeDecoder
|
|
{
|
|
if ( emulatorCore ) {
|
|
if ( type == 0x22 ) {
|
|
GBASystem * system = ( GBASystem * ) emulatorCore;
|
|
CPUCleanUp( system );
|
|
soundShutdown( system );
|
|
delete system;
|
|
} else if ( type == 0x25 ) {
|
|
Player * player = ( Player * ) emulatorCore;
|
|
delete player;
|
|
} else {
|
|
free( emulatorCore );
|
|
}
|
|
emulatorCore = nil;
|
|
}
|
|
|
|
if ( type == 2 && emulatorExtra ) {
|
|
psf2fs_delete( emulatorExtra );
|
|
emulatorExtra = nil;
|
|
} else if ( type == 0x22 && emulatorExtra ) {
|
|
delete ( gsf_sound_out * ) emulatorExtra;
|
|
emulatorExtra = nil;
|
|
} else if ( type == 0x25 && emulatorExtra ) {
|
|
struct ncsf_loader_state * state = ( struct ncsf_loader_state * ) emulatorExtra;
|
|
delete state;
|
|
emulatorExtra = nil;
|
|
} else if ( type == 0x41 && emulatorExtra ) {
|
|
struct qsf_loader_state * state = ( struct qsf_loader_state * ) emulatorExtra;
|
|
free( state->key );
|
|
free( state->z80_rom );
|
|
free( state->sample_rom );
|
|
free( state );
|
|
emulatorExtra = nil;
|
|
}
|
|
}
|
|
|
|
- (void)close
|
|
{
|
|
[self closeDecoder];
|
|
[currentSource release];
|
|
[[psf_file_container instance] remove_hint:currentUrl];
|
|
[currentUrl release];
|
|
}
|
|
|
|
- (long)seek:(long)frame
|
|
{
|
|
if (frame < framesRead) {
|
|
[self closeDecoder];
|
|
if (![self initializeDecoder])
|
|
return -1;
|
|
}
|
|
|
|
if ( type == 1 || type == 2 )
|
|
{
|
|
uint32_t howmany = (uint32_t)(frame - framesRead);
|
|
psx_execute( emulatorCore, 0x7fffffff, 0, &howmany, 0 );
|
|
frame = (long)(howmany + framesRead);
|
|
}
|
|
else if ( type == 0x11 || type == 0x12 )
|
|
{
|
|
uint32_t howmany = (uint32_t)(frame - framesRead);
|
|
sega_execute( emulatorCore, 0x7fffffff, 0, &howmany );
|
|
frame = (long)(howmany + framesRead);
|
|
}
|
|
else if ( type == 0x22 )
|
|
{
|
|
GBASystem * system = ( GBASystem * ) emulatorCore;
|
|
struct gsf_sound_out * sound_out = ( struct gsf_sound_out * ) emulatorExtra;
|
|
|
|
long frames_to_run = frame - framesRead;
|
|
|
|
do
|
|
{
|
|
if ( frames_to_run * 4 >= sound_out->samples_written )
|
|
{
|
|
frames_to_run -= sound_out->samples_written / 4;
|
|
sound_out->samples_written = 0;
|
|
}
|
|
else
|
|
{
|
|
sound_out->samples_written -= frames_to_run * 4;
|
|
memcpy( sound_out->buffer, sound_out->buffer + frames_to_run * 4, sound_out->samples_written );
|
|
frames_to_run = 0;
|
|
}
|
|
|
|
if ( frames_to_run )
|
|
CPULoop( system, 250000 );
|
|
} while ( frames_to_run );
|
|
}
|
|
else if ( type == 0x25 )
|
|
{
|
|
std::vector<uint8_t> buffer;
|
|
Player * player = ( Player * ) emulatorCore;
|
|
|
|
buffer.resize(1024 * sizeof(int16_t) * 2);
|
|
|
|
long frames_to_run = frame - framesRead;
|
|
|
|
while ( frames_to_run )
|
|
{
|
|
int frames_to_render = 1024;
|
|
if ( frames_to_render > frames_to_run ) frames_to_render = (int)frames_to_run;
|
|
|
|
player->GenerateSamples(buffer, 0, frames_to_render);
|
|
|
|
frames_to_run -= frames_to_render;
|
|
}
|
|
}
|
|
else if ( type == 0x41 )
|
|
{
|
|
uint32_t howmany = (uint32_t)(frame - framesRead);
|
|
qsound_execute( emulatorCore, 0x7fffffff, 0, &howmany );
|
|
frame = (long)(howmany + framesRead);
|
|
}
|
|
|
|
framesRead = frame;
|
|
|
|
return frame;
|
|
}
|
|
|
|
- (NSDictionary *)properties
|
|
{
|
|
return [NSDictionary dictionaryWithObjectsAndKeys:
|
|
[NSNumber numberWithInt:2], @"channels",
|
|
[NSNumber numberWithInt:16], @"bitsPerSample",
|
|
[NSNumber numberWithFloat:sampleRate], @"sampleRate",
|
|
[NSNumber numberWithInteger:totalFrames], @"totalFrames",
|
|
[NSNumber numberWithInt:0], @"bitrate",
|
|
[NSNumber numberWithBool:YES], @"seekable",
|
|
[NSNumber numberWithFloat:replayGainAlbumGain], @"replayGainAlbumGain",
|
|
[NSNumber numberWithFloat:replayGainAlbumPeak], @"replayGainAlbumPeak",
|
|
[NSNumber numberWithFloat:replayGainTrackGain], @"replayGainTrackGain",
|
|
[NSNumber numberWithFloat:replayGainTrackPeak], @"replayGainTrackPeak",
|
|
[NSNumber numberWithFloat:volume], @"volume",
|
|
@"host", @"endian",
|
|
nil];
|
|
}
|
|
|
|
+ (NSDictionary *)metadataForURL:(NSURL *)url
|
|
{
|
|
struct psf_info_meta_state info;
|
|
|
|
info.info = [NSMutableDictionary dictionary];
|
|
info.utf8 = false;
|
|
info.tag_length_ms = 0;
|
|
info.tag_fade_ms = 0;
|
|
|
|
NSString * decodedUrl = [[url absoluteString] stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
|
|
|
|
if ( psf_load( [decodedUrl UTF8String], &source_callbacks, 0, 0, 0, psf_info_meta, &info ) <= 0)
|
|
return NO;
|
|
|
|
return info.info;
|
|
}
|
|
|
|
+ (NSArray *)fileTypes
|
|
{
|
|
return [NSArray arrayWithObjects:@"psf",@"minipsf",@"psf2", @"minipsf2", @"ssf", @"minissf", @"dsf", @"minidsf", @"qsf", @"miniqsf", @"gsf", @"minigsf", @"ncsf", @"minincsf", nil];
|
|
}
|
|
|
|
+ (NSArray *)mimeTypes
|
|
{
|
|
return [NSArray arrayWithObjects:@"audio/x-psf", nil];
|
|
}
|
|
|
|
|
|
|
|
@end
|