buffered_reader_t *buffered_reader_open(const char *path, int32_t buffer_size, int32_t seek_mode)
{
buffered_reader_t *reader = malloc(sizeof(buffered_reader_t));
long long result;
if (reader == 0)
return 0;
memset(reader, 0, sizeof(buffered_reader_t));
reader->cache_enabled = 1;
reader->handle = -1;
reader->buffer_size = buffer_size;
reader->seek_mode = seek_mode;
reader->buffer_0 = malloc_64(reader->buffer_size);
if (reader->buffer_0 == 0) {
buffered_reader_close(reader);
return 0;
}
reader->buffer_1 = malloc_64(reader->buffer_size);
if (reader->buffer_1 == 0) {
buffered_reader_close(reader);
return 0;
}
reader->buffer_2 = malloc_64(reader->buffer_size);
if (reader->buffer_2 == 0) {
buffered_reader_close(reader);
return 0;
}
reader->handle = sceIoOpen(path, PSP_O_RDONLY, 0777);
if (reader->handle < 0) {
buffered_reader_close(reader);
return 0;
}
if (sceIoChangeAsyncPriority(reader->handle, 0x10) < 0) {
buffered_reader_close(reader);
return 0;
}
reader->length = sceIoLseek32(reader->handle, 0, PSP_SEEK_END);
reader->first_buffer = reader->buffer_0;
reader->second_buffer = reader->buffer_1;
reader->third_buffer = reader->buffer_2;
sceIoLseek32(reader->handle, reader->position_0, PSP_SEEK_SET);
sceIoReadAsync(reader->handle, reader->first_buffer, reader->position_1 - reader->position_0);
sceIoWaitAsync(reader->handle, &result);
sceIoLseek32(reader->handle, reader->position_1, PSP_SEEK_SET);
sceIoReadAsync(reader->handle, reader->second_buffer, reader->position_2 - reader->position_1);
sceIoWaitAsync(reader->handle, &result);
sceIoLseek32(reader->handle, reader->position_2, PSP_SEEK_SET);
sceIoReadAsync(reader->handle, reader->third_buffer, reader->position_3 - reader->position_2);
return reader;
}
struct subtitle_frame_struct* subtitle_parse_microdvd( FILE *f, char* charset, unsigned int rate, unsigned int scale )
{
if (!f) return(0);
struct subtitle_frame_struct *p = (struct subtitle_frame_struct*)malloc_64( sizeof(struct subtitle_frame_struct) );
if (p==0) return(0);
subtitle_frame_safe_constructor(p);
int result = fscanf( f, "{%i}{%i}", &p->p_start_frame, &p->p_end_frame );
if (result==EOF)
{
free_64(p);
return(0);
}
char c;
int i = 0;
p->p_num_lines = 1;
while (i<max_subtitle_string-1)
{
c = fgetc(f);
if (c=='\n' || c==EOF) break;
if (c=='|')
{
p->p_string[i++]='\n';
p->p_num_lines++;
}
else
{
p->p_string[i++]=c;
}
}
p->p_string[i] = '\0';
if ( miniConvHaveSubtitleConv(charset) ) {
char* temp_str = miniConvSubtitleConv(p->p_string, charset);
if( temp_str != NULL ) {
strncpy(p->p_string, temp_str, max_subtitle_string-1);
}
}
else if ( stricmp(charset, "DEFAULT") == 0 && miniConvHaveDefaultSubtitleConv() ){
char* temp_str = miniConvDefaultSubtitleConv(p->p_string);
if( temp_str != NULL ) {
strncpy(p->p_string, temp_str, max_subtitle_string-1);
}
}
return(p);
}
char *mp4_file_open(struct mp4_file_struct *p, char *s) {
mp4_file_safe_constructor(p);
p->info = mp4info_open(s);
if (p->info == 0){
mp4_file_close(p);
return("mp4_file_open: can't open file");
}
int i;
for(i = 0; i < p->info->total_tracks; i++) {
mp4info_track_t* track = p->info->tracks[i];
if (track->type != MP4_TRACK_VIDEO)
continue;
if ( track->width < 1 || track->height < 1 )
continue;
if ( track->width > 720 || track->height > 480 )
continue;
if ( track->video_type == 0x61766331 /*avc1*/) {
if ( track->avc_profile==0x42 && (track->width > 480 || track->height > 272) )
continue;
}
else {
if ( track->width > 480 || track->height > 272 )
continue;
}
p->video_track_id = i;
p->video_type = track->video_type;
if ( p->video_type == 0x61766331 ) {
p->avc_profile = track->avc_profile;
p->avc_sps_size = track->avc_sps_size;
p->avc_pps_size = track->avc_pps_size;
p->avc_nal_prefix_size = track->avc_nal_prefix_size;
p->avc_sps = malloc_64(p->avc_sps_size);
if ( ! p->avc_sps ) {
mp4_file_close(p);
return("mp4_file_open: can't malloc avc_sps buffer");
}
memcpy(p->avc_sps, track->avc_sps, p->avc_sps_size);
p->avc_pps = malloc_64(p->avc_pps_size);
if ( ! p->avc_pps ) {
mp4_file_close(p);
return("mp4_file_open: can't malloc avc_pps buffer");
}
memcpy(p->avc_pps, track->avc_pps, p->avc_pps_size);
}
else {
p->mp4v_decinfo_size = track->mp4v_decinfo_size;
p->mp4v_decinfo = malloc_64(p->mp4v_decinfo_size);
if ( ! p->mp4v_decinfo ) {
mp4_file_close(p);
return("mp4_file_open: can't malloc mp4v_decinfo buffer");
}
memcpy(p->mp4v_decinfo, track->mp4v_decinfo, p->mp4v_decinfo_size);
}
break;
}
if ( p->video_track_id < 0 ) {
mp4_file_close(p);
return("mp4_file_open: can't found video track in mp4 file");
}
for(i = 0; i < p->info->total_tracks; i++) {
mp4info_track_t* track = p->info->tracks[i];
if (track->type != MP4_TRACK_AUDIO)
continue;
if ( p->audio_tracks == 0 ) {
if ( track->audio_type != 0x6D703461 && track->audio_type != 0x73616D72 )
continue;
// if ( track->channels != 2 )
// continue;
if ( track->samplerate != 8000 && track->samplerate != 22050 && track->samplerate != 24000 && track->samplerate != 44100 && track->samplerate != 48000 )
continue;
// if ( track->samplebits != 16 )
// continue;
p->audio_tracks++;
p->audio_track_ids[p->audio_tracks-1] = i;
p->audio_type = track->audio_type;
if ( track->samplerate == 22050 || track->samplerate == 24000 )
p->audio_up_sample = 1;
else if ( track->samplerate == 8000 )
p->audio_up_sample = 5;
}
else {
mp4info_track_t* old_track = p->info->tracks[p->audio_track_ids[p->audio_tracks-1]];
if ( old_track->audio_type != track->audio_type )
continue;
// if ( old_track->channels != track->channels )
// continue;
if ( old_track->samplerate != track->samplerate )
continue;
// if ( old_track->samplebits != track->samplebits )
// continue;
p->audio_tracks++;
p->audio_track_ids[p->audio_tracks-1] = i;
}
if ( p->audio_tracks == 6 )
break;
}
if ( p->audio_tracks == 0 ) {
mp4_file_close(p);
return("mp4_file_open: can't found audio track in mp4 file");
}
// int sample_id = 0;
// unsigned int trunk_size = 0;
// int j, k;
//
// mp4info_track_t* video_track = p->info->tracks[p->video_track_id];
// for( i = 0; i < video_track->stsc_entry_count-1; i++ ) {
// int trunk_num = video_track->stsc_first_chunk[i+1] - video_track->stsc_first_chunk[i];
// for( j = 0; j < trunk_num; j++ ) {
// trunk_size = 0;
// for( k = 0; k < video_track->stsc_samples_per_chunk[i]; k++, sample_id++) {
// unsigned int sample_size = (video_track->stsz_sample_size ? video_track->stsz_sample_size : video_track->stsz_sample_size_table[sample_id]);
// if ( sample_size > p->maximum_video_sample_size )
// p->maximum_video_sample_size = sample_size;
// trunk_size += sample_size;
// }
// if ( trunk_size > p->maximum_video_trunk_size )
// p->maximum_video_trunk_size = trunk_size;
// }
// }
// trunk_size = 0;
// for( k = 0; k < video_track->stsc_samples_per_chunk[i]; k++, sample_id++)
// trunk_size += (video_track->stsz_sample_size ? video_track->stsz_sample_size : video_track->stsz_sample_size_table[sample_id]);
// if ( trunk_size > p->maximum_video_trunk_size )
// p->maximum_video_trunk_size = trunk_size;
//
// int l;
// for( l = 0; l < p->audio_tracks; l++ ) {
// sample_id = 0;
// mp4info_track_t* audio_track = p->info->tracks[p->audio_track_ids[l]];
// for( i = 0; i < audio_track->stsc_entry_count-1; i++ ) {
// int trunk_num = audio_track->stsc_first_chunk[i+1] - audio_track->stsc_first_chunk[i];
// for( j = 0; j < trunk_num; j++ ) {
// trunk_size = 0;
// for( k = 0; k < audio_track->stsc_samples_per_chunk[i]; k++, sample_id++) {
// unsigned int sample_size = (audio_track->stsz_sample_size ? audio_track->stsz_sample_size : audio_track->stsz_sample_size_table[sample_id]);
// if ( sample_size > p->maximum_audio_sample_size )
// p->maximum_audio_sample_size = sample_size;
// trunk_size += sample_size;
// }
// if ( trunk_size > p->maximum_audio_trunk_size )
// p->maximum_audio_trunk_size = trunk_size;
// }
// }
// trunk_size = 0;
// for( k = 0; k < audio_track->stsc_samples_per_chunk[i]; k++, sample_id++) {
// unsigned int sample_size = (audio_track->stsz_sample_size ? audio_track->stsz_sample_size : audio_track->stsz_sample_size_table[sample_id]);
// if ( sample_size > p->maximum_audio_sample_size )
// p->maximum_audio_sample_size = sample_size;
// trunk_size += sample_size;
// }
// if ( trunk_size > p->maximum_audio_trunk_size )
// p->maximum_audio_trunk_size = trunk_size;
// }
p->video_width = p->info->tracks[p->video_track_id]->width;
p->video_height = p->info->tracks[p->video_track_id]->height;
p->number_of_video_frames = 0;
for( i = 0; i < p->info->tracks[p->video_track_id]->stts_entry_count; i++)
p->number_of_video_frames += p->info->tracks[p->video_track_id]->stts_sample_count[i];
//p->number_of_video_frames = p->info->tracks[p->video_track_id]->stts_sample_count[0];
p->video_rate = p->info->tracks[p->video_track_id]->time_scale;
p->video_scale = p->info->tracks[p->video_track_id]->duration / p->number_of_video_frames;
//p->video_scale = p->info->tracks[p->video_track_id]->stts_sample_duration[0];
p->audio_actual_rate = p->info->tracks[p->audio_track_ids[0]]->samplerate;
p->audio_rate = p->audio_actual_rate * (p->audio_up_sample+1) ;
p->audio_scale = (p->audio_type == 0x6D703461 ? 1024 : 160);
p->audio_resample_scale = p->audio_scale * (p->audio_up_sample+1);
p->audio_stereo = 1;
int64_t v0 = p->video_rate * p->audio_resample_scale;
int64_t v1 = p->audio_rate * p->video_scale;
if (v0 >= v1)
p->video_audio_interval = (int)(v0 / v1);
else
p->video_audio_interval = (int)(-(v1/v0));
return(mp4_file_build_index(p));
}
char *mp4_file_build_index(struct mp4_file_struct *p) {
int i,j;
unsigned int ui;
unsigned int trunk[MP4_MAX_TRACKS];
unsigned int current_sample = 0;
unsigned int current_index = 0;
mp4info_track_t* v_track = p->info->tracks[p->video_track_id];
mp4info_track_t* a_track = p->info->tracks[p->audio_track_ids[0]];
if ( (v_track->stco_chunk_offset[v_track->stco_entry_count-1] < a_track->stco_chunk_offset[0])
|| (v_track->stco_chunk_offset[0] > a_track->stco_chunk_offset[a_track->stco_entry_count-1]) ) {
if ( p->info->total_tracks > 2 ) {
mp4_file_close(p);
return("mp4_file_open: can't support this file");
}
else
p->is_not_interlace = 1;
}
for(i=0; i<p->info->total_tracks; i++) {
p->sample_count += mp4_get_sample_count(p->info->tracks[i]);
}
p->index_count = p->info->tracks[p->video_track_id]->stss_entry_count;
p->samples = malloc_64(p->sample_count * sizeof(struct mp4_sample_struct));
if ( !p->samples ) {
mp4_file_close(p);
return("mp4_file_open: can't malloc samples buffer");
}
p->indexes = malloc_64(p->index_count * sizeof(struct mp4_index_struct));
if ( !p->indexes ) {
mp4_file_close(p);
return("mp4_file_open: can't malloc indexes buffer");
}
for(i=0; i<MP4_MAX_TRACKS; i++)
trunk[i] = 0;
while(1) {
int current_track = 0;
unsigned int min_offset = 0xFFFFFFFF;
unsigned int current_offset = 0xFFFFFFFF;
unsigned int first_sample = 0;
unsigned int last_sample = 0;
for(i=0; i<p->info->total_tracks; i++) {
current_offset = mp4_get_trunk_offset(p->info->tracks[i], trunk[i]);
if ( current_offset < min_offset ) {
min_offset = current_offset;
current_track = i;
}
}
if ( 0xFFFFFFFF == min_offset )
break;
mp4info_track_t* track = p->info->tracks[current_track];
for( i = 0; i < track->stsc_entry_count-1; i++ ) {
if ( (trunk[current_track]+1) >= track->stsc_first_chunk[i] && (trunk[current_track]+1) < track->stsc_first_chunk[i+1] )
break;
}
for( j = 0; j < i; j++ ) {
first_sample += ( ( track->stsc_first_chunk[j+1] - track->stsc_first_chunk[j] ) * track->stsc_samples_per_chunk[j] );
}
first_sample += ( ( (trunk[current_track]+1) - track->stsc_first_chunk[i] ) * track->stsc_samples_per_chunk[i] );
last_sample = first_sample + track->stsc_samples_per_chunk[i] - 1;
for(ui = first_sample; ui <= last_sample; ui++) {
p->samples[current_sample].sample_index = (current_track << 24) | (ui & 0x00FFFFFF);
p->samples[current_sample].sample_size = mp4_get_sample_size(track, ui);
if ( current_track == p->video_track_id ) {
if ( 0xFFFFFFFF == p->first_video_offset) {
p->first_video_offset = min_offset;
p->first_video_sample = current_sample;
}
if ( p->samples[current_sample].sample_size > p->maximum_video_sample_size) {
p->maximum_video_sample_size = p->samples[current_sample].sample_size;
}
if ( mp4_is_keyframe(track, ui) ) {
uint64_t timestamp = 1000LL;
timestamp *= ui;
timestamp *= p->video_scale;
timestamp /= p->video_rate;
p->indexes[current_index].timestamp = timestamp;
p->indexes[current_index].sample_index = current_sample;
p->indexes[current_index].offset = min_offset;
current_index++;
}
}
else if ( current_track == p->audio_track_ids[0] ) {
if ( 0xFFFFFFFF == p->first_audio_offset) {
p->first_audio_offset = min_offset;
p->first_audio_sample = current_sample;
}
}
min_offset += p->samples[current_sample].sample_size;
current_sample++;
}
trunk[current_track] += 1;
}
if ( !p->is_not_interlace ) {
for(i = 0; i < p->info->total_tracks; i++) {
mp4info_track_t* track = p->info->tracks[i];
if (track->type != MP4_TRACK_SUBTITLE)
continue;
p->subtitle_tracks++;
p->subtitle_track_ids[p->subtitle_tracks-1] = i;
p->subtitle_track_time_count[p->subtitle_tracks-1] = track->stts_entry_count;
p->subtitle_track_time[p->subtitle_tracks-1] = malloc_64(track->stts_entry_count*2*sizeof(unsigned int));
if ( !p->subtitle_track_time[p->subtitle_tracks-1] ) {
p->subtitle_tracks--;
break;
}
else {
for(j=0; j<track->stts_entry_count;j++) {
p->subtitle_track_time[p->subtitle_tracks-1][2*j] = track->stts_sample_count[j];
p->subtitle_track_time[p->subtitle_tracks-1][2*j+1] = track->stts_sample_duration[j];
}
}
if ( p->subtitle_tracks == 4 )
break;
}
}
mp4info_close(p->info);
p->info = 0;
return(0);
}
LPP_Mp4* LPP_Mp4Load(const char *filename)
{
LPP_Mp4 *tmp = (LPP_Mp4*)malloc(sizeof(LPP_Mp4));
if(!tmp) {
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot allocate 'tmp' to memory.\n", __FUNCTION__, __LINE__);
#endif
return 0;
}
tmp->avc = (Mp4AvcDecoderStruct*)malloc(sizeof(Mp4AvcDecoderStruct));
if(!tmp->avc) {
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot allocate 'tmp'->avc to memory.\n", __FUNCTION__, __LINE__);
#endif
free(tmp);
return 0;
}
tmp->csc = (Mp4AvcCscStruct*)malloc(sizeof(Mp4AvcCscStruct));
if(!tmp->csc) {
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot allocate 'tmp' to memory.\n", __FUNCTION__, __LINE__);
#endif
free(tmp->avc);
free(tmp);
return 0;
}
mp4_read_safe_constructor(&(tmp->reader));
memset(tmp->avc, 0, sizeof(Mp4AvcDecoderStruct));
if(mp4_read_open(&(tmp->reader), (char*)filename))
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : mp4_read_open error.\n", __FUNCTION__, __LINE__);
#endif
free(tmp->csc);
free(tmp->avc);
free(tmp);
return 0;
}
if(tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_profile == 0x4D && (tmp->reader.file.video_width > 480 || tmp->reader.file.video_height > 272))
{
cooleyesMeBootStart(devkitVersion, 1);
tmp->avc->mpeg_mode = 5;
} else if(tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_profile == 0x4D)
{
cooleyesMeBootStart(devkitVersion, 3);
tmp->avc->mpeg_mode = 4;
} else if(tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_profile == 0x42)
{
cooleyesMeBootStart(devkitVersion, 4);
tmp->avc->mpeg_mode = 4;
}
tmp->avc->mpeg_ddrtop = memalign(0x400000, 0x400000);
if(!tmp->avc->mpeg_ddrtop)
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot allocate 'tmp->avc->mpeg_ddrtop' to memory.\n", __FUNCTION__, __LINE__);
#endif
free(tmp->csc);
free(tmp->avc);
free(tmp);
return 0;
}
tmp->avc->mpeg_au_buffer = tmp->avc->mpeg_ddrtop + 0x10000;
int res = sceMpegQueryMemSize(tmp->avc->mpeg_mode);
if(res < 0)
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : res < 0.\n", __FUNCTION__, __LINE__);
#endif
free(tmp->csc);
free(tmp->avc->mpeg_ddrtop);
free(tmp->avc);
free(tmp);
return 0;
}
tmp->avc->mpeg_buffer_size = res;
if(!(res & 0xF)) res = (res & 0xFFFFFFF0) + 16;
tmp->avc->mpeg_buffer = malloc_64(res);
if(!tmp->avc->mpeg_buffer)
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot allocate 'tmp->avc->mpeg_buffer' to memory.\n", __FUNCTION__, __LINE__);
#endif
free(tmp->csc);
free(tmp->avc->mpeg_ddrtop);
free(tmp->avc);
free(tmp);
return 0;
}
if(sceMpegCreate(&(tmp->avc->mpeg), tmp->avc->mpeg_buffer, tmp->avc->mpeg_buffer_size, &(tmp->avc->mpeg_ringbuffer), 512, tmp->avc->mpeg_mode, (SceInt32)tmp->avc->mpeg_ddrtop))
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : Error in sceMpegCreate.\n", __FUNCTION__, __LINE__);
#endif
LPP_Mp4Close(tmp);
return 0;
}
tmp->avc->mpeg_au = (SceMpegAu*)malloc_64(64);
memset(tmp->avc->mpeg_au, 0xFF, 64);
if(sceMpegInitAu(&(tmp->avc->mpeg), tmp->avc->mpeg_au_buffer, tmp->avc->mpeg_au))
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : Error in sceMpegInitAu.\n", __FUNCTION__, __LINE__);
#endif
LPP_Mp4Close(tmp);
return 0;
}
tmp->avc->mpeg_sps_size = tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_sps_size;
tmp->avc->mpeg_pps_size = tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_pps_size;
tmp->avc->mpeg_nal_prefix_size = tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_nal_prefix_size;
tmp->avc->mpeg_sps_pps_buffer = malloc_64(tmp->avc->mpeg_sps_size + tmp->avc->mpeg_pps_size);
if(!tmp->avc->mpeg_sps_pps_buffer)
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot allocate 'tmp->avc->mpeg_sps_pps_buffer' to memory.\n", __FUNCTION__, __LINE__);
#endif
LPP_Mp4Close(tmp);
return 0;
}
memcpy(tmp->avc->mpeg_sps_pps_buffer, tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_sps, tmp->avc->mpeg_sps_size);
memcpy(tmp->avc->mpeg_sps_pps_buffer + tmp->avc->mpeg_sps_size, tmp->reader.file.info->tracks[tmp->reader.file.video_track_id]->avc_pps, tmp->avc->mpeg_pps_size);
return (tmp);
}
char *mp4_read_open(struct mp4_read_struct *p, char *s) {
mp4_read_safe_constructor(p);
char *result = mp4_file_open(&p->file, s);
if (result != 0) {
mp4_read_close(p);
return(result);
}
p->video_handle = sceIoOpen(s, PSP_O_RDONLY, 0777);
if (p->video_handle < 0) {
mp4_read_close(p);
return("mp4_read_open: can't open file");
}
if (sceIoChangeAsyncPriority(p->video_handle, 0x10) < 0) {
mp4_read_close(p);
return("mp4_read_open: sceIoChangeAsyncPriority failed");
}
p->audio_handle = sceIoOpen(s, PSP_O_RDONLY, 0777);
if (p->audio_handle < 0) {
mp4_read_close(p);
return("mp4_read_open: can't open file");
}
if (sceIoChangeAsyncPriority(p->audio_handle, 0x10) < 0) {
mp4_read_close(p);
return("mp4_read_open: sceIoChangeAsyncPriority failed");
}
p->video_buffer_0 = malloc_64(p->file.maximum_video_trunk_size);
if (p->video_buffer_0 == 0) {
mp4_read_close(p);
return("mp4_read_open: malloc_64 failed on buffer_0");
}
memset(p->video_buffer_0, 0, p->file.maximum_video_trunk_size);
p->video_buffer_1 = malloc_64(p->file.maximum_video_trunk_size);
if (p->video_buffer_1 == 0) {
mp4_read_close(p);
return("mp4_read_open: malloc_64 failed on buffer_1");
}
memset(p->video_buffer_1, 0, p->file.maximum_video_trunk_size);
p->audio_buffer_0 = malloc_64(p->file.maximum_audio_trunk_size);
if (p->audio_buffer_0== 0) {
mp4_read_close(p);
return("mp4_read_open: malloc_64 failed on buffer_0");
}
memset(p->audio_buffer_0, 0, p->file.maximum_audio_trunk_size);
p->audio_buffer_1 = malloc_64(p->file.maximum_audio_trunk_size);
if (p->audio_buffer_1== 0) {
mp4_read_close(p);
return("mp4_read_open: malloc_64 failed on buffer_0");
}
memset(p->audio_buffer_1, 0, p->file.maximum_audio_trunk_size);
p->audio_cache_buffer = malloc_64((sizeof(unsigned int)+p->file.maximum_audio_sample_size) * p->file.maximun_audio_sample_number);
if (p->audio_cache_buffer== 0) {
mp4_read_close(p);
}
memset(p->audio_cache_buffer, 0, (sizeof(unsigned int)+p->file.maximum_audio_sample_size) * p->file.maximun_audio_sample_number);
p->audio_output_length = (unsigned int*)p->audio_cache_buffer;
p->audio_output_buffer = p->audio_cache_buffer + sizeof(unsigned int)*p->file.maximun_audio_sample_number;
p->video_asynchronous_buffer_0.buffer = p->video_buffer_0;
p->video_asynchronous_buffer_1.buffer = p->video_buffer_1;
p->video_current_asynchronous_buffer = &p->video_asynchronous_buffer_0;
p->video_next_asynchronous_buffer = &p->video_asynchronous_buffer_1;
p->audio_asynchronous_buffer_0.buffer = p->audio_buffer_0;
p->audio_asynchronous_buffer_1.buffer = p->audio_buffer_1;
p->audio_current_asynchronous_buffer = &p->audio_asynchronous_buffer_0;
p->audio_next_asynchronous_buffer = &p->audio_asynchronous_buffer_1;
time_math_interleaving_constructor(&p->interleaving,
p->file.video_rate,
p->file.video_scale,
p->file.audio_rate,
p->file.audio_resample_scale);
time_math_interleaving_get(&p->interleaving);
result = video_fill_current_and_next_asynchronous_buffer(p, 0);
if (result != 0) {
mp4_read_close(p);
return(result);
}
result = audio_fill_current_and_next_asynchronous_buffer(p, 0);
if (result != 0) {
mp4_read_close(p);
return(result);
}
return(0);
}
void OSPC_Play(char *fname,int release,int vol) {
u16 *menu_bg;
u16 *dst,*src;
int i,j,pollcpt;
char str[256];
char *emulator[3]={"Unknown","Zsnes","Snes9x"};
uint8 *scr;
OSPC_Init();
if (i=OSPC_Load(fname))
{
sprintf(str,"Error at SPC loading, code : %d",i);
msgBoxLines(str,60);
//gp32_pause();
//GpAppExit();
return;
}
OSPC_id=OSPC_GetID666(spc_data);
OSPC_sound_fd = sceAudioChReserve( -1, 1024, 0 );
OSPC_exit=0;
OSPC_volume=vol;
OSPC_thread = sceKernelCreateThread( "OSPC Thread", (SceKernelThreadEntry)OSPC_PlayThread, 0x8, 256*1024, 0, 0 );
if (OSPC_thread<0) {
msgBoxLines("Cannot create OSPC playback thread",60);
} else {
//init start time
scePowerSetClockFrequency(266,266,133);
sceKernelLibcGettimeofday( &OSPC_start_time, 0 );
sceKernelStartThread( OSPC_thread, 0, 0 );
if (release) return;
//init bg
menu_bg=(u16*)malloc_64(480*272*2);
dst=menu_bg;
show_background(bg_img_mul,(os9x_lowbat?0x600000:0));
for (i=0;i<272;i++) {
src = (u16*)pgGetVramAddr(0,i);
memcpy(dst,src,480*2);
dst+=480;
}
//init fx
fx_init();
for (;;) {
//show bg
OSPC_show_bg(menu_bg);
//show bg fx
fx_main(pgGetVramAddr(0,0));
//batt infos
show_batteryinfo();
//music info
//draw frame
pgDrawFrame(14,14,20+230+5+1,75+1,12|(12<<5)|(12<<10));
pgDrawFrame(13,13,20+230+5+2,75+2,30|(30<<5)|(30<<10));
pgDrawFrame(12,12,20+230+5+3,75+3,12|(12<<5)|(12<<10));
pgFillBoxHalfer(15,15,20+230+5,75);
//
if (strlen(OSPC_id->gametitle)) sprintf(str,"Game : %s",OSPC_id->gametitle);
else sprintf(str,"Game : unknown");
mh_print(20,20,(char*)str,30|(30<<5)|(30<<10));
if (strlen(OSPC_id->songname)) sprintf(str,"Song : %s",OSPC_id->songname);
else sprintf(str,"Song : unknown");
mh_print(20,30,(char*)str,30|(30<<5)|(30<<10));
if (strlen(OSPC_id->dumper)) sprintf(str,"Dumper : %s",OSPC_id->dumper);
else sprintf(str,"Dumper : unknown");
mh_print(20,40,(char*)str,30|(30<<5)|(30<<10));
if (strlen(OSPC_id->comments)) sprintf(str,"Comments : %s",OSPC_id->comments);
else sprintf(str,"Comments : unknown");
mh_print(20,50,(char*)str,30|(30<<5)|(30<<10));
if (strlen(OSPC_id->author)) sprintf(str,"Author : %s",OSPC_id->author);
else sprintf(str,"Author : unknown");
mh_print(20,60,(char*)str,30|(30<<5)|(30<<10));
//time infos
//draw frame
//draw frame
pgDrawFrame(14,94,20+65+5+1,116,8|(8<<5)|(16<<10));
pgDrawFrame(13,93,20+65+5+2,117,28|(28<<5)|(31<<10));
pgDrawFrame(12,92,20+65+5+3,118,8|(8<<5)|(16<<10));
pgFillBoxHalfer(15,95,20+65+5,115);
sceKernelLibcGettimeofday( &OSPC_cur_time, 0 );
i=(OSPC_cur_time.tv_sec-OSPC_start_time.tv_sec)+(OSPC_cur_time.tv_usec-OSPC_start_time.tv_usec)/1000000;
sprintf(str,"%2d%c%.2d / %2d:%.2d",i/60,((i&1)?':':' '),i%60,OSPC_id->playtime/60,OSPC_id->playtime%60);
mh_print(20,100,(char*)str,(20)|(31<<5)|(18<<10));
if (get_pad()) break;
pgScreenFlip();
}
OSPC_exit=1;
sceKernelWaitThreadEnd( OSPC_thread, NULL );
sceKernelDeleteThread( OSPC_thread );
OSPC_thread=-1;
free(menu_bg);
fx_close();
}
sceAudioChRelease( OSPC_sound_fd );
OSPC_Stop();
OSPC_Close();
if (OSPC_id) free(OSPC_id);
}
