Esempio n. 1
0
bool Mp3PspStream::initStreamME() {
	// The following will eventually go into the thread

	memset(_codecParams, 0, sizeof(_codecParams));

	// Init the MP3 hardware
	int ret = 0;
	ret = sceAudiocodecCheckNeedMem(_codecParams, 0x1002);
	if (ret < 0) {
		PSP_ERROR("failed to init MP3 ME module. sceAudiocodecCheckNeedMem returned 0x%x.\n", ret);
		return false;
	}
	PSP_DEBUG_PRINT("sceAudiocodecCheckNeedMem returned %d\n", ret);
	ret = sceAudiocodecGetEDRAM(_codecParams, 0x1002);
	if (ret < 0) {
		PSP_ERROR("failed to init MP3 ME module. sceAudiocodecGetEDRAM returned 0x%x.\n", ret);
		return false;
	}
	PSP_DEBUG_PRINT("sceAudioCodecGetEDRAM returned %d\n", ret);

	PSP_DEBUG_PRINT("samplerate[%d]\n", _sampleRate);
	_codecParams[10] = _sampleRate;

	ret = sceAudiocodecInit(_codecParams, 0x1002);
	if (ret < 0) {
		PSP_ERROR("failed to init MP3 ME module. sceAudiocodecInit returned 0x%x.\n", ret);
		return false;
	}

	return true;
}
Esempio n. 2
0
void MP3PlayInit(play_ops* ops){
	
	ops->load  =  MP3_Load;
	ops->play  =  MP3_Play;
	ops->pause =  MP3_Pause;
	ops->stop  =  MP3_Stop;
	ops->resume=  MP3_Resume;
	ops->time  =  MP3_Time;
	ops->seek  =  MP3_Seek;
	ops->eos   =  MP3_Eos;
	ops->volume = MP3_Volume;
	strncpy(ops->extension,"mp3",4);
	
	memset(mp3_codec_buffer, 0, sizeof(mp3_codec_buffer) );
	if ( sceAudiocodecCheckNeedMem(mp3_codec_buffer, 0x1002) < 0 ) {
		CleanUp();
		return;
	}
	if ( sceAudiocodecGetEDRAM(mp3_codec_buffer, 0x1002) < 0 ) {
		CleanUp();
		return;
	}
	if ( sceAudiocodecInit(mp3_codec_buffer, 0x1002) < 0 ) {
		CleanUp();
		return;
	}
	mp3_codec_flag = 1;
}
Esempio n. 3
0
File: libmpeg.c Progetto: yne/js-psp
int initAudioCodec (int arg1){
	pAudioCodecStruct = audioCodecStruct;
	memset (audioCodecStruct, 0, 0x6C);
	int ret,tmp;
	if((ret=audiocodecCheckNeedMem (&tmp, arg1, &AudioNeededMem)))return ret;
	if((ret=sceAudiocodecGetEDRAM (pAudioCodecStruct, 0x00001000)))return ret;
	pAudioCodecStruct[3] = 0;
	return 0;
}
Esempio n. 4
0
char* Mp3Codec::initialize(AudioCodecInitData* init_data) {
	audio_samplerate = init_data->samplerate;
	audio_samples_per_frame = init_data->samples_per_frame;
	audio_type = 0x1002;

	memset(me_audio_codec_buffer, 0, 65*sizeof(uint32_t));
	if ( sceAudiocodecCheckNeedMem((long unsigned int*) me_audio_codec_buffer, audio_type) < 0 )
		return "Mp3Codec : sceAudiocodecCheckNeedMem fail";
	if ( sceAudiocodecGetEDRAM((long unsigned int*)me_audio_codec_buffer, audio_type) < 0 )
		return "Mp3Codec : sceAudiocodecGetEDRAM fail";
	if ( sceAudiocodecInit((long unsigned int*)me_audio_codec_buffer, audio_type) < 0 ) {
		sceAudiocodecReleaseEDRAM((long unsigned int*)me_audio_codec_buffer);
		return "Mp3Codec : sceAudiocodecInit fail";
	}
	init_flag = true;
	return 0;
};
Esempio n. 5
0
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Private functions:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Decode thread:
int decodeThread(SceSize args, void *argp){
    int res;
    unsigned char MP3ME_header_buf[4];
    int MP3ME_header;
    int version;
    int bitrate;
    int padding;
    int frame_size;
    int size;
	int offset = 0;

	sceAudiocodecReleaseEDRAM(MP3ME_codec_buffer); //Fix: ReleaseEDRAM at the end is not enough to play another mp3.
	MP3ME_threadActive = 1;
    MP3ME_threadExited = 0;
    OutputBuffer_flip = 0;
    OutputPtrME = OutputBuffer[0];

    MP3ME_handle = sceIoOpen(MP3ME_Name, PSP_O_RDONLY, 0777);
    if (MP3ME_handle < 0)
        MP3ME_threadActive = 0;

	//now search for the first sync byte, tells us where the mp3 stream starts
	size = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_END);
	sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_SET);
	data_start = ID3v2TagSize(MP3ME_Name);
	sceIoLseek32(MP3ME_handle, data_start, PSP_SEEK_SET);
    data_start = MP3ME_SeekNextFrameMP3(MP3ME_handle);

	if (data_start < 0)
		MP3ME_threadActive = 0;

    size -= data_start;

    memset(MP3ME_codec_buffer, 0, sizeof(MP3ME_codec_buffer));

    if ( sceAudiocodecCheckNeedMem(MP3ME_codec_buffer, 0x1002) < 0 )
        MP3ME_threadActive = 0;

    if ( sceAudiocodecGetEDRAM(MP3ME_codec_buffer, 0x1002) < 0 )
        MP3ME_threadActive = 0;

    getEDRAM = 1;

    if ( sceAudiocodecInit(MP3ME_codec_buffer, 0x1002) < 0 )
        MP3ME_threadActive = 0;

    MP3ME_eof = 0;

	while (MP3ME_threadActive){
		while( !MP3ME_eof && MP3ME_isPlaying )
		{
            MP3ME_filePos = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_CUR);
			if ( sceIoRead( MP3ME_handle, MP3ME_header_buf, 4 ) != 4 ){
				MP3ME_isPlaying = 0;
				MP3ME_threadActive = 0;
				continue;
			}

			MP3ME_header = MP3ME_header_buf[0];
			MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[1];
			MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[2];
			MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[3];

			bitrate = (MP3ME_header & 0xf000) >> 12;
			padding = (MP3ME_header & 0x200) >> 9;
			version = (MP3ME_header & 0x180000) >> 19;
			samplerate = samplerates[version][ (MP3ME_header & 0xC00) >> 10 ];

			if ((bitrate > 14) || (version == 1) || (samplerate == 0) || (bitrate == 0))//invalid frame, look for the next one
			{
				data_start = MP3ME_SeekNextFrameMP3(MP3ME_handle);
				if(data_start < 0)
				{
					MP3ME_eof = 1;
					continue;
				}
				size -= (data_start - offset);
				offset = data_start;
				continue;
			}

			if (version == 3) //mpeg-1
			{
				sample_per_frame = 1152;
				frame_size = 144000*bitrates[bitrate]/samplerate + padding;
			}else{
				sample_per_frame = 576;
				frame_size = 72000*bitrates_v2[bitrate]/samplerate + padding;
			}

			sceIoLseek32(MP3ME_handle, data_start, PSP_SEEK_SET); //seek back

			size -= frame_size;
			if ( size <= 0)
			{
			   MP3ME_eof = 1;
			   continue;
			}

			//since we check for eof above, this can only happen when the file
			// handle has been invalidated by syspend/resume/usb
			if ( sceIoRead( MP3ME_handle, MP3ME_input_buffer, frame_size ) != frame_size ){
                //Resume from suspend:
                if ( MP3ME_handle >= 0 ){
                   sceIoClose(MP3ME_handle);
                   MP3ME_handle = -1;
                }
                MP3ME_handle = sceIoOpen(MP3ME_Name, PSP_O_RDONLY, 0777);
                if (MP3ME_handle < 0){
                    MP3ME_isPlaying = 0;
                    MP3ME_threadActive = 0;
                    continue;
                }
                size = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_END);
                sceIoLseek32(MP3ME_handle, offset, PSP_SEEK_SET);
                data_start = offset;
				continue;
			}
			data_start += frame_size;
			offset = data_start;

			MP3ME_codec_buffer[6] = (unsigned long)MP3ME_input_buffer;
			MP3ME_codec_buffer[8] = (unsigned long)MP3ME_output_buffer;

			MP3ME_codec_buffer[7] = MP3ME_codec_buffer[10] = frame_size;
			MP3ME_codec_buffer[9] = sample_per_frame * 4;

			res = sceAudiocodecDecode(MP3ME_codec_buffer, 0x1002);

			if ( res < 0 )
			{
				//instead of quitting see if the next frame can be decoded
				//helps play files with an invalid frame
				//we must look for a valid frame, the offset above may be wrong
				data_start = MP3ME_SeekNextFrameMP3(MP3ME_handle);
				if(data_start < 0)
				{
					MP3ME_eof = 1;
					continue;
				}
				size -= (data_start - offset);
				offset = data_start;
				continue;
			}
            MP3ME_playingTime += (float)sample_per_frame/(float)samplerate;

            //Output:
			memcpy( OutputPtrME, MP3ME_output_buffer, sample_per_frame*4);
			OutputPtrME += (sample_per_frame * 4);
			if( OutputPtrME + (sample_per_frame * 4) > &OutputBuffer[OutputBuffer_flip][OUTPUT_BUFFER_SIZE])
			{

                audioOutput(PSP_AUDIO_VOLUME_MAX, OutputBuffer[OutputBuffer_flip]);

				OutputBuffer_flip ^= 1;
				OutputPtrME = OutputBuffer[OutputBuffer_flip];

			}
		}
		sceKernelDelayThread(10000); // Not sure if necessary or purpose
	}
    if (getEDRAM)
        sceAudiocodecReleaseEDRAM(MP3ME_codec_buffer);

    if ( MP3ME_handle >= 0){
      sceIoClose(MP3ME_handle);
      MP3ME_handle = -1;
    }
    MP3ME_threadExited = 1;
    return 0;
}
Esempio n. 6
0
int main(void)
{
	SetupCallbacks();
	
	int result = pspSdkLoadStartModule("flash0:/kd/audiocodec.prx", PSP_MEMORY_PARTITION_KERNEL);
	pspSdkFixupImports(result);
	
	SceUID at3_handle = sceIoOpen("ms0:/Test.AT3", PSP_O_RDONLY, 0777);
	if (  ! at3_handle )
		goto wait;
	
	u32 riff_header[2];
	if ( sceIoRead( at3_handle, riff_header, 8 ) != 8 ) 
		goto wait;
	if ( riff_header[0] != 0x46464952 )
		goto wait;
	u32 wavefmt_header[3];
	if ( sceIoRead( at3_handle, wavefmt_header, 12 ) != 12 ) 
		goto wait;
	if ( wavefmt_header[0] != 0x45564157 || wavefmt_header[1] != 0x20746D66 )
		goto wait;
	u8* wavefmt_data = (u8*)malloc(wavefmt_header[2]);
	if ( wavefmt_data == NULL )
		goto wait;
	if ( sceIoRead( at3_handle, wavefmt_data, wavefmt_header[2] ) != wavefmt_header[2] ) {
		free(wavefmt_data);
		goto wait;
	}
	at3_type = *((u16*)wavefmt_data);
	at3_channels = *((u16*)(wavefmt_data+2));
	at3_samplerate = *((u32*)(wavefmt_data+4));
	at3_data_align = *((u16*)(wavefmt_data+12));
	
	if ( at3_type == TYPE_ATRAC3PLUS) {
		at3_at3plus_flagdata[0] = wavefmt_data[42];
		at3_at3plus_flagdata[1] = wavefmt_data[43];
	}
	
	free(wavefmt_data);
	
	u32 data_header[2];
	if ( sceIoRead( at3_handle, data_header, 8 ) != 8 ) 
		goto wait;
	while(data_header[0] != 0x61746164 ) {
		sceIoLseek32(at3_handle, data_header[1], PSP_SEEK_CUR);
		if ( sceIoRead( at3_handle, data_header, 8 ) != 8 ) 
			goto wait;
	}
	
	at3_data_start = sceIoLseek32(at3_handle, 0, PSP_SEEK_CUR);
	at3_data_size = data_header[1];
	
	if ( at3_data_size % at3_data_align != 0 )
		goto wait;
	
	memset(at3_codec_buffer, 0, sizeof(at3_codec_buffer));
	
	if ( at3_type == TYPE_ATRAC3 ) {
		at3_channel_mode = 0x0;
		if ( at3_data_align == 0xC0 ) // atract3 have 3 bitrate, 132k,105k,66k, 132k align=0x180, 105k align = 0x130, 66k align = 0xc0
			at3_channel_mode = 0x1;
		at3_sample_per_frame = 1024; 
		at3_data_buffer = (u8*)memalign(64, 0x180);
		if ( at3_data_buffer == NULL)
			goto wait;
		at3_codec_buffer[26] = 0x20;
		if ( sceAudiocodecCheckNeedMem(at3_codec_buffer, 0x1001) < 0 ) 
			goto wait;
		if ( sceAudiocodecGetEDRAM(at3_codec_buffer, 0x1001) < 0 )
			goto wait;
		at3_getEDRAM = 1;
		at3_codec_buffer[10] = 4;
		at3_codec_buffer[44] = 2;
		if ( at3_data_align == 0x130 )
			at3_codec_buffer[10] = 6;
		if ( sceAudiocodecInit(at3_codec_buffer, 0x1001) < 0 ) {
			goto wait;
		}
	}
	else if ( at3_type == TYPE_ATRAC3PLUS ) {
		at3_sample_per_frame = 2048;
		int temp_size = at3_data_align+8;
		int mod_64 = temp_size & 0x3f;
		if (mod_64 != 0) temp_size += 64 - mod_64;
		at3_data_buffer = (u8*)memalign(64, temp_size);
		if ( at3_data_buffer == NULL)
			goto wait;
		at3_codec_buffer[5] = 0x1;
		at3_codec_buffer[10] = at3_at3plus_flagdata[1];
		at3_codec_buffer[10] = (at3_codec_buffer[10] << 8 ) | at3_at3plus_flagdata[0];
		at3_codec_buffer[12] = 0x1;
		at3_codec_buffer[14] = 0x1;
		if ( sceAudiocodecCheckNeedMem(at3_codec_buffer, 0x1000) < 0 ) 
			goto wait;
		if ( sceAudiocodecGetEDRAM(at3_codec_buffer, 0x1000) < 0 )
			goto wait;
		at3_getEDRAM = 1;
		if ( sceAudiocodecInit(at3_codec_buffer, 0x1000) < 0 ) {
			goto wait;
		}
	}
	else
		goto wait;
	
	int eof = 0;	
	while( !eof ) {
		int samplesdecoded;
		memset(at3_mix_buffer, 0, 2048*2*2);
		unsigned long decode_type = 0x1001;
		if ( at3_type == TYPE_ATRAC3 ) {
			memset( at3_data_buffer, 0, 0x180);
			if (sceIoRead( at3_handle, at3_data_buffer, at3_data_align ) != at3_data_align) {
				eof = 1;
				continue;
			}
			if ( at3_channel_mode ) {
				memcpy(at3_data_buffer+at3_data_align, at3_data_buffer, at3_data_align);
			}
			decode_type = 0x1001;
		}
		else {
			memset( at3_data_buffer, 0, at3_data_align+8);
			at3_data_buffer[0] = 0x0F;
			at3_data_buffer[1] = 0xD0;
			at3_data_buffer[2] = at3_at3plus_flagdata[0];
			at3_data_buffer[3] = at3_at3plus_flagdata[1];
			if (sceIoRead( at3_handle, at3_data_buffer+8, at3_data_align ) != at3_data_align) {
				eof = 1;
				continue;
			}
			decode_type = 0x1000;
		}
	
		at3_codec_buffer[6] = (unsigned long)at3_data_buffer;
		at3_codec_buffer[8] = (unsigned long)at3_mix_buffer;
	
		int res = sceAudiocodecDecode(at3_codec_buffer, decode_type);
		if ( res < 0 ) {
			eof = 1;
			continue;
		}
		samplesdecoded = at3_sample_per_frame;
	}

wait:
	
	if ( at3_handle ) {
		sceIoClose(at3_handle);
	}
	if ( at3_data_buffer) {
		free(at3_data_buffer);
	}
	if ( at3_getEDRAM ) {
		sceAudiocodecReleaseEDRAM(at3_codec_buffer);
	}
	
	sceCtrlReadBufferPositive(&input, 1);
	while(!(input.Buttons & PSP_CTRL_TRIANGLE))
	{
		sceKernelDelayThread(10000);	// wait 10 milliseconds
		sceCtrlReadBufferPositive(&input, 1);
	}
	
	sceKernelExitGame();
	return 0;
}
Esempio n. 7
0
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Private functions:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Decode thread:
int decodeThread(SceSize args, void *argp){
    int res;
    unsigned char MP3ME_header_buf[4];
    int MP3ME_header;
    int version;
    int bitrate;
    int padding;
    int frame_size;
    int size;
    int total_size;
	int offset = 0;

	sceAudiocodecReleaseEDRAM(MP3ME_codec_buffer); //Fix: ReleaseEDRAM at the end is not enough to play another mp3.
	MP3ME_threadActive = 1;
    OutputBuffer_flip = 0;
    OutputPtrME = OutputBuffer[0];

    sceIoChdir(audioCurrentDir);
    MP3ME_handle = sceIoOpen(MP3ME_fileName, PSP_O_RDONLY, 0777);
    if (MP3ME_handle < 0)
        MP3ME_threadActive = 0;

	//now search for the first sync byte, tells us where the mp3 stream starts
	total_size = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_END);
	size = total_size;
	sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_SET);
	data_start = ID3v2TagSize(MP3ME_fileName);
	sceIoLseek32(MP3ME_handle, data_start, PSP_SEEK_SET);
    data_start = SeekNextFrameMP3(MP3ME_handle);

	if (data_start < 0)
		MP3ME_threadActive = 0;

    size -= data_start;

    memset(MP3ME_codec_buffer, 0, sizeof(MP3ME_codec_buffer));
    memset(MP3ME_input_buffer, 0, sizeof(MP3ME_input_buffer));
    memset(MP3ME_output_buffer, 0, sizeof(MP3ME_output_buffer));

    if ( sceAudiocodecCheckNeedMem(MP3ME_codec_buffer, 0x1002) < 0 )
        MP3ME_threadActive = 0;

    if ( sceAudiocodecGetEDRAM(MP3ME_codec_buffer, 0x1002) < 0 )
        MP3ME_threadActive = 0;

    getEDRAM = 1;

    if ( sceAudiocodecInit(MP3ME_codec_buffer, 0x1002) < 0 )
        MP3ME_threadActive = 0;

    MP3ME_eof = 0;
	MP3ME_info.framesDecoded = 0;

	while (MP3ME_threadActive){
		while( !MP3ME_eof && MP3ME_isPlaying )
		{
            MP3ME_filePos = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_CUR);
			if ( sceIoRead( MP3ME_handle, MP3ME_header_buf, 4 ) != 4 ){
				MP3ME_isPlaying = 0;
				MP3ME_threadActive = 0;
				continue;
			}

			MP3ME_header = MP3ME_header_buf[0];
			MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[1];
			MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[2];
			MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[3];

			bitrate = (MP3ME_header & 0xf000) >> 12;
			padding = (MP3ME_header & 0x200) >> 9;
			version = (MP3ME_header & 0x180000) >> 19;
			samplerate = samplerates[version][ (MP3ME_header & 0xC00) >> 10 ];

			if ((bitrate > 14) || (version == 1) || (samplerate == 0) || (bitrate == 0))//invalid frame, look for the next one
			{
				data_start = SeekNextFrameMP3(MP3ME_handle);
				if(data_start < 0)
				{
					MP3ME_eof = 1;
					continue;
				}
				size -= (data_start - offset);
				offset = data_start;
				continue;
			}

			if (version == 3) //mpeg-1
			{
				sample_per_frame = 1152;
				frame_size = 144000*bitrates[bitrate]/samplerate + padding;
				MP3ME_info.instantBitrate = bitrates[bitrate] * 1000;
			}else{
				sample_per_frame = 576;
				frame_size = 72000*bitrates_v2[bitrate]/samplerate + padding;
				MP3ME_info.instantBitrate = bitrates_v2[bitrate] * 1000;
			}

			sceIoLseek32(MP3ME_handle, data_start, PSP_SEEK_SET); //seek back

            if (MP3ME_newFilePos >= 0)
            {
                if (!MP3ME_newFilePos)
                    MP3ME_newFilePos = ID3v2TagSize(MP3ME_fileName);

                long old_start = data_start;
                if (sceIoLseek32(MP3ME_handle, MP3ME_newFilePos, PSP_SEEK_SET) != old_start){
                    data_start = SeekNextFrameMP3(MP3ME_handle);
                    if(data_start < 0){
                        MP3ME_eof = 1;
                    }
                    MP3ME_playingTime = (float)data_start / (float)frame_size /  (float)samplerate / 1000.0f;
                    offset = data_start;
                    size = total_size - data_start;
                }
                MP3ME_newFilePos = -1;
                continue;
            }

			size -= frame_size;
			if ( size <= 0)
			{
			   MP3ME_eof = 1;
			   continue;
			}

			//since we check for eof above, this can only happen when the file
			// handle has been invalidated by syspend/resume/usb
			if ( sceIoRead( MP3ME_handle, MP3ME_input_buffer, frame_size ) != frame_size ){
                //Resume from suspend:
                if ( MP3ME_handle >= 0 ){
                   sceIoClose(MP3ME_handle);
                   MP3ME_handle = -1;
                }
                MP3ME_handle = sceIoOpen(MP3ME_fileName, PSP_O_RDONLY, 0777);
                if (MP3ME_handle < 0){
                    MP3ME_isPlaying = 0;
                    MP3ME_threadActive = 0;
                    continue;
                }
                size = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_END);
                sceIoLseek32(MP3ME_handle, offset, PSP_SEEK_SET);
                data_start = offset;
				continue;
			}
			data_start += frame_size;
			offset = data_start;

			MP3ME_codec_buffer[6] = (unsigned long)MP3ME_input_buffer;
			MP3ME_codec_buffer[8] = (unsigned long)MP3ME_output_buffer;

			MP3ME_codec_buffer[7] = MP3ME_codec_buffer[10] = frame_size;
			MP3ME_codec_buffer[9] = sample_per_frame * 4;

			res = sceAudiocodecDecode(MP3ME_codec_buffer, 0x1002);

			if ( res < 0 )
			{
				//instead of quitting see if the next frame can be decoded
				//helps play files with an invalid frame
				//we must look for a valid frame, the offset above may be wrong
				data_start = SeekNextFrameMP3(MP3ME_handle);
				if(data_start < 0)
				{
					MP3ME_eof = 1;
					continue;
				}
				size -= (data_start - offset);
				offset = data_start;
				continue;
			}
            MP3ME_playingTime += (float)sample_per_frame/(float)samplerate;
		    MP3ME_info.framesDecoded++;

            //Output:
			memcpy( OutputPtrME, MP3ME_output_buffer, sample_per_frame*4);
			OutputPtrME += (sample_per_frame * 4);
			if( OutputPtrME + (sample_per_frame * 4) > &OutputBuffer[OutputBuffer_flip][OUTPUT_BUFFER_SIZE])
			{
				//Volume Boost:
				if (MP3ME_volume_boost){
                    int i;
                    for (i=0; i<OUTPUT_BUFFER_SIZE; i++){
    					OutputBuffer[OutputBuffer_flip][i] = volume_boost(&OutputBuffer[OutputBuffer_flip][i], &MP3ME_volume_boost);
                    }
                }

                audioOutput(MP3ME_volume, OutputBuffer[OutputBuffer_flip]);

				OutputBuffer_flip ^= 1;
				OutputPtrME = OutputBuffer[OutputBuffer_flip];
		        //Check for playing speed:
                if (MP3ME_playingSpeed){
                    long old_start = data_start;
                    if (sceIoLseek32(MP3ME_handle, frame_size * MP3ME_playingSpeed, PSP_SEEK_CUR) != old_start){
                        data_start = SeekNextFrameMP3(MP3ME_handle);
                        if(data_start < 0){
                            MP3ME_eof = 1;
                            continue;
                        }
                        float framesSkipped = (float)abs(old_start - data_start) / (float)frame_size;
                        if (MP3ME_playingSpeed > 0)
                            MP3ME_playingTime += framesSkipped * (float)sample_per_frame/(float)samplerate;
                        else
                            MP3ME_playingTime -= framesSkipped * (float)sample_per_frame/(float)samplerate;

                        offset = data_start;
                        size = total_size - data_start;
                    }else
                        MP3ME_setPlayingSpeed(0);
                }
			}
		}
		sceKernelDelayThread(10000);
	}
    if (getEDRAM)
        sceAudiocodecReleaseEDRAM(MP3ME_codec_buffer);

    if ( MP3ME_handle >= 0){
      sceIoClose(MP3ME_handle);
      MP3ME_handle = -1;
    }
	sceKernelExitThread(0);
    return 0;
}
Esempio n. 8
0
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Private functions:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Decode thread:
int AACdecodeThread(SceSize args, void *argp){
   u8* aac_data_buffer = NULL;
   u32 aac_data_start;
   u8 aac_getEDRAM;
   u32 aac_channels;
   u32 aac_samplerate;

   sceAudiocodecReleaseEDRAM(aac_codec_buffer);
   sceIoChdir(audioCurrentDir);

   AAC_threadActive = 1;
   AAC_handle = sceIoOpen(AAC_fileName, PSP_O_RDONLY, 0777);
   if (  ! AAC_handle ){
      AAC_threadActive = 0;
      goto end;
   }

   aac_output_index = 0;
   aac_channels = 2;
   aac_samplerate = AAC_info.hz;

   aac_data_start = 0;
   if (AAC_tagsize > 0)
       aac_data_start = AAC_tagsize + 10;

   sceIoLseek32(AAC_handle, aac_data_start, PSP_SEEK_SET);
   aac_data_start = SeekNextFrameMP3(AAC_handle);

   memset(aac_codec_buffer, 0, sizeof(aac_codec_buffer));

   if ( sceAudiocodecCheckNeedMem(aac_codec_buffer, 0x1003) < 0 ){
      AAC_threadActive = 0;
      goto end;
   }

   if ( sceAudiocodecGetEDRAM(aac_codec_buffer, 0x1003) < 0 ){
         AAC_threadActive = 0;
         goto end;
   }
   aac_getEDRAM = 1;

   aac_codec_buffer[10] = aac_samplerate;
   if ( sceAudiocodecInit(aac_codec_buffer, 0x1003) < 0 ){
      AAC_threadActive = 0;
      goto end;
   }

    int samplesdecoded;
    AAC_eof = 0;
    unsigned char aac_header_buf[7];
    int skip = 0;

	while (AAC_threadActive){
		while( !AAC_eof && AAC_isPlaying ){
              memset(aac_mix_buffer, 0, aac_sample_per_frame*2*2);
              if ( sceIoRead( AAC_handle, aac_header_buf, 7 ) != 7 ) {
                 AAC_eof = 1;
                 continue;
              }
              int aac_header = aac_header_buf[3];
              aac_header = (aac_header<<8) | aac_header_buf[4];
              aac_header = (aac_header<<8) | aac_header_buf[5];
              aac_header = (aac_header<<8) | aac_header_buf[6];

              int frame_size = aac_header & 67100672;
              frame_size = frame_size >> 13;
              frame_size = frame_size - 7;

              if ( aac_data_buffer ){
                 free(aac_data_buffer);
                 aac_data_buffer = NULL;
              }
              aac_data_buffer = (u8*)memalign(64, frame_size);

              if (AAC_newFilePos >= 0)
              {
                  if (!AAC_newFilePos)
                      AAC_newFilePos = AAC_tagsize + 10;

                  u32 old_start = aac_data_start;
                  if (sceIoLseek32(AAC_handle, AAC_newFilePos, PSP_SEEK_SET) != old_start){
                      aac_data_start = SeekNextFrameMP3(AAC_handle);
                      if(aac_data_start < 0){
                          AAC_eof = 1;
                      }
                      AAC_playingTime = (float)aac_data_start / (float)frame_size /  (float)aac_samplerate / 1000.0f;
                  }
                  AAC_newFilePos = -1;
                  continue;
              }

		      //Check for playing speed:
              if (AAC_playingSpeed){
                  if (skip){
                      u32 old_start = aac_data_start;
                      if (sceIoLseek32(AAC_handle, frame_size / 4 * AAC_playingSpeed, PSP_SEEK_CUR) != old_start){
                          aac_data_start = SeekNextFrameMP3(AAC_handle);
                          if(aac_data_start < 0){
                              AAC_eof = 1;
                              continue;
                          }
                          AAC_filePos = aac_data_start;
                          float framesSkipped = (float)aac_data_start / (float)frame_size;
                          AAC_playingTime = framesSkipped * (float)aac_sample_per_frame/(float)aac_samplerate;
                      }else
                          AAC_setPlayingSpeed(0);
                      skip = !skip;
                      continue;
                  }
                  skip = !skip;
              }

              if ( sceIoRead( AAC_handle, aac_data_buffer, frame_size ) != frame_size ) {
                 AAC_eof = 1;
                 continue;
              }

              aac_data_start += (frame_size+7);
              AAC_filePos = aac_data_start;

              aac_codec_buffer[6] = (unsigned long)aac_data_buffer;
              aac_codec_buffer[8] = (unsigned long)aac_mix_buffer;

              aac_codec_buffer[7] = frame_size;
              aac_codec_buffer[9] = aac_sample_per_frame * 4;


              int res = sceAudiocodecDecode(aac_codec_buffer, 0x1003);
              if ( res < 0 ) {
                 AAC_eof = 1;
                 continue;
              }
              memcpy(aac_output_buffer[aac_output_index], aac_mix_buffer, aac_sample_per_frame*4);

              //Volume Boost:
              if (AAC_volume_boost){
                  int i;
                  for (i=0; i<aac_sample_per_frame * 2; i++){
                    aac_output_buffer[aac_output_index][i] = volume_boost(&aac_output_buffer[aac_output_index][i], &AAC_volume_boost);
                  }
              }

              audioOutput(AAC_volume, aac_output_buffer[aac_output_index]);
              aac_output_index = (aac_output_index+1)%4;

              samplesdecoded = aac_sample_per_frame;

              AAC_playingTime += (float)aac_sample_per_frame/(float)aac_samplerate;
              AAC_info.framesDecoded++;
            }
            sceKernelDelayThread(10000);
    }
end:
   if ( AAC_handle )
      sceIoClose(AAC_handle);

   if ( aac_data_buffer)
   {
      free(aac_data_buffer);
      aac_data_buffer = NULL;
   }

   if ( aac_getEDRAM )
      sceAudiocodecReleaseEDRAM(aac_codec_buffer);

    sceKernelExitThread(0);
    return 0;
}
Esempio n. 9
0
int main(void)
{
	SetupCallbacks();
	
	int result = pspSdkLoadStartModule("flash0:/kd/audiocodec.prx", PSP_MEMORY_PARTITION_KERNEL);
	pspSdkFixupImports(result);
	
	SceUID aa3_handle = sceIoOpen("ms0:/Test.AA3", PSP_O_RDONLY, 0777); // or ms0:/Test.OMA
	if (  ! aa3_handle )
		goto wait;
	
	sceIoLseek32(aa3_handle, 0x0C00, PSP_SEEK_SET);
	
	u8 ea3_header[0x60];
	if ( sceIoRead( aa3_handle, ea3_header, 0x60 ) != 0x60 ) 
		goto wait;
	if ( ea3_header[0] != 0x45 || ea3_header[1] != 0x41 || ea3_header[2] != 0x33 || ea3_header[3] != 0x01 )
		goto wait;
	
	aa3_at3plus_flagdata[0] = ea3_header[0x22];
	aa3_at3plus_flagdata[1] = ea3_header[0x23];
	
	aa3_type = (ea3_header[0x22] == 0x20) ? TYPE_ATRAC3 : ((ea3_header[0x22] == 0x28) ? TYPE_ATRAC3PLUS : 0x0);
	
	if ( aa3_type != TYPE_ATRAC3 && aa3_type != TYPE_ATRAC3PLUS )
		goto wait;
	
	aa3_channels = 2;
	aa3_samplerate = 44100;
	if ( aa3_type == TYPE_ATRAC3 ) 
		aa3_data_align = ea3_header[0x23]*8;
	else
		aa3_data_align = (ea3_header[0x23]+1)*8;
	
	aa3_data_start = 0x0C60;
	aa3_data_size = sceIoLseek32(aa3_handle, 0, PSP_SEEK_END) - aa3_data_start;
	
	if ( aa3_data_size % aa3_data_align != 0 )
		goto wait;
	
	sceIoLseek32(aa3_handle, aa3_data_start, PSP_SEEK_SET);
	
	memset(aa3_codec_buffer, 0, sizeof(aa3_codec_buffer));
	
	if ( aa3_type == TYPE_ATRAC3 ) {
		aa3_channel_mode = 0x0;
		if ( aa3_data_align == 0xC0 ) // atract3 have 3 bitrate, 132k,105k,66k, 132k align=0x180, 105k align = 0x130, 66k align = 0xc0
			aa3_channel_mode = 0x1;
		aa3_sample_per_frame = 1024; 
		aa3_data_buffer = (u8*)memalign(64, 0x180);
		if ( aa3_data_buffer == NULL)
			goto wait;
		aa3_codec_buffer[26] = 0x20;
		if ( sceAudiocodecCheckNeedMem(aa3_codec_buffer, 0x1001) < 0 ) 
			goto wait;
		if ( sceAudiocodecGetEDRAM(aa3_codec_buffer, 0x1001) < 0 )
			goto wait;
		aa3_getEDRAM = 1;
		aa3_codec_buffer[10] = 4;
		aa3_codec_buffer[44] = 2;
		if ( aa3_data_align == 0x130 )
			aa3_codec_buffer[10] = 6;
		if ( sceAudiocodecInit(aa3_codec_buffer, 0x1001) < 0 ) {
			goto wait;
		}
	}
	else if ( aa3_type == TYPE_ATRAC3PLUS ) {
		aa3_sample_per_frame = 2048;
		int temp_size = aa3_data_align+8;
		int mod_64 = temp_size & 0x3f;
		if (mod_64 != 0) temp_size += 64 - mod_64;
		aa3_data_buffer = (u8*)memalign(64, temp_size);
		if ( aa3_data_buffer == NULL)
			goto wait;
		aa3_codec_buffer[5] = 0x1;
		aa3_codec_buffer[10] = aa3_at3plus_flagdata[1];
		aa3_codec_buffer[10] = (aa3_codec_buffer[10] << 8 ) | aa3_at3plus_flagdata[0];
		aa3_codec_buffer[12] = 0x1;
		aa3_codec_buffer[14] = 0x1;
		if ( sceAudiocodecCheckNeedMem(aa3_codec_buffer, 0x1000) < 0 ) 
			goto wait;
		if ( sceAudiocodecGetEDRAM(aa3_codec_buffer, 0x1000) < 0 )
			goto wait;
		aa3_getEDRAM = 1;
		if ( sceAudiocodecInit(aa3_codec_buffer, 0x1000) < 0 ) {
			goto wait;
		}
	}
	else
		goto wait;
	
	int eof = 0;	
	while( !eof ) {
		int samplesdecoded;
		memset(aa3_mix_buffer, 0, 2048*2*2);
		unsigned long decode_type = 0x1001;
		if ( aa3_type == TYPE_ATRAC3 ) {
			memset( aa3_data_buffer, 0, 0x180);
			if (sceIoRead( aa3_handle, aa3_data_buffer, aa3_data_align ) != aa3_data_align) {
				eof = 1;
				continue;
			}
			if ( aa3_channel_mode ) {
				memcpy(aa3_data_buffer+aa3_data_align, aa3_data_buffer, aa3_data_align);
			}
			decode_type = 0x1001;
		}
		else {
			memset( aa3_data_buffer, 0, aa3_data_align+8);
			aa3_data_buffer[0] = 0x0F;
			aa3_data_buffer[1] = 0xD0;
			aa3_data_buffer[2] = aa3_at3plus_flagdata[0];
			aa3_data_buffer[3] = aa3_at3plus_flagdata[1];
			if (sceIoRead( aa3_handle, aa3_data_buffer+8, aa3_data_align ) != aa3_data_align) {
				eof = 1;
				continue;
			}
			decode_type = 0x1000;
		}
	
		aa3_codec_buffer[6] = (unsigned long)aa3_data_buffer;
		aa3_codec_buffer[8] = (unsigned long)aa3_mix_buffer;
	
		int res = sceAudiocodecDecode(aa3_codec_buffer, decode_type);
		if ( res < 0 ) {
			eof = 1;
			continue;
		}
		samplesdecoded = aa3_sample_per_frame;
	}

wait:
	
	if ( aa3_handle ) {
		sceIoClose(aa3_handle);
	}
	if ( aa3_data_buffer) {
		free(aa3_data_buffer);
	}
	if ( aa3_getEDRAM ) {
		sceAudiocodecReleaseEDRAM(aa3_codec_buffer);
	}
	
	sceCtrlReadBufferPositive(&input, 1);
	while(!(input.Buttons & PSP_CTRL_TRIANGLE))
	{
		sceKernelDelayThread(10000);	// wait 10 milliseconds
		sceCtrlReadBufferPositive(&input, 1);
	}
	
	sceKernelExitGame();
	return 0;
}
Esempio n. 10
0
// -------------------------------------------------------
// Initialize the AT3 replay
static triSInt AT3_FileInit(triVoid *File_Mem, triSInt File_Length, triVoid (*Mixing_CallBack)(triS16 *AT3_Audio_Buffer, triSInt AT3_Buffer_Size))
{
	triUInt *dwFile_Mem;
	triUChar *tmpFile_Mem;
	typedef struct
	{
		unsigned short		wFormatTag;         // Format category
		unsigned short		wChannels;          // Number of channels
		unsigned long		dwSamplesPerSec;    // Sampling rate
		unsigned long		dwAvgBytesPerSec;   // For buffer estimation
		unsigned short		wBlockAlign;        // Data block size
		unsigned short		wBitsPerSample;		// Sample size
	} WAVFMTCHUNK;
	WAVFMTCHUNK fmt;
	memset( &fmt, 0, sizeof(WAVFMTCHUNK) );
					
	AT3_Playing = 0;
	AT3_CallBack = Mixing_CallBack;
	
	dwFile_Mem = (triUInt *) File_Mem;
	
	if(*dwFile_Mem++ == 'FFIR')
	{
		dwFile_Mem++;

		if(*dwFile_Mem++ == 'EVAW')
		{
			tmpFile_Mem = (triUChar *) (dwFile_Mem + 2);
			AT3_align = 384;
			while(*dwFile_Mem != 'atad')
			{
				if (*dwFile_Mem++ == ' tmf')
				{
					memcpy( &fmt, (dwFile_Mem+1), sizeof(WAVFMTCHUNK) );
					AT3_align = fmt.wBlockAlign;
					//printf("Fmt:\nFormat: %x\nChannels: %i\nRate: %i\nBPS: %i\nAlign: %i\nBits: %i\n", fmt.wFormatTag, fmt.wChannels, fmt.dwSamplesPerSec, fmt.dwAvgBytesPerSec, fmt.wBlockAlign, fmt.wBitsPerSample );
				}
				
				dwFile_Mem = (triUInt *) (tmpFile_Mem + *dwFile_Mem);
				tmpFile_Mem = (triUChar *) (dwFile_Mem + 2);
			}
			dwFile_Mem++;
			
			AT3_Datas_Start = (triSInt) tmpFile_Mem - (triSInt) File_Mem;
			memset(AT3_Codec_Buffer, 0, sizeof(AT3_Codec_Buffer));
			memset(AT3_Mix_Buffer, 0, AT3_SAMPLES * 2 * 2);
			
			AT3_Codec_Buffer[26] = 0x20;
			AT3_Codec_Buffer[43] = 0x1001;
			memcpy( (void*)AT3_Buffer, (void*)(File_Mem + AT3_Datas_Start), AT3_align );
			if (AT3_align==192)
			{
				memcpy( (void*)(AT3_Buffer+192), (void*)AT3_Buffer, 192 );
			}
			AT3_pos = (triUInt)(File_Mem + AT3_Datas_Start);
			AT3_Codec_Buffer[AT3_CURRENT_BUFFER] = (triSInt)AT3_Buffer; //(File_Mem + AT3_Datas_Start);
			AT3_Codec_Buffer[AT3_TEMPORARY_BUFFER] = (triSInt) AT3_Mix_Buffer;
			
			if (AT3_align==304)
				AT3_Codec_Buffer[10] = 6;
			else
				AT3_Codec_Buffer[10] = 4;
			AT3_Codec_Buffer[44] = 2;
			AT3_length = File_Length;
			AT3_Codec_Buffer[AT3_INITIAL_BUFFER] = (triSInt) File_Mem;
			AT3_Codec_Buffer[AT3_LENGTH_BUFFER] = 384;

			if(sceAudiocodecCheckNeedMem(AT3_Codec_Buffer, AT3_TYPE_ATRAC3) < 0) return(0);
			if(sceAudiocodecGetEDRAM(AT3_Codec_Buffer, AT3_TYPE_ATRAC3) < 0) return(0);
			if(sceAudiocodecInit(AT3_Codec_Buffer, AT3_TYPE_ATRAC3) < 0) return(0);

			AT3_Channel = sceAudioChReserve(0, AT3_SAMPLES, PSP_AUDIO_FORMAT_STEREO);
		
			if(AT3_Channel < 0) return(0);
		
			AT3_ThreadID = sceKernelCreateThread("TriAtrac3", (triVoid *) AT3_Thread, AT3_THREAD_PRIORITY, (1024 * 4), PSP_THREAD_ATTR_USER, NULL);
		
			if(AT3_ThreadID < 0) return(0);
		
			sceKernelStartThread(AT3_ThreadID, 0, NULL);
		
			return(1);
		}
	}
	return(0);
}