Ejemplo n.º 1
0
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    connector = new Server(this);



    myself.setName(QString("user ") + QString::number(qrand()));

    // connect(connector,SIGNAL(massageReceived(QByteArray)),this,SLOT(audioOutput(QByteArray))); \\

    connect(connector,SIGNAL(massageReceived(QByteArray)),this,SLOT(audioOutput(QByteArray))); \

    decoder = new AudioDecoder(this);
    recorder = new AudioRecorder(this);
    connect(recorder,SIGNAL(audioBufferder(QByteArray)), connector, SLOT(sendMessage(QByteArray)));

    ui->message_output->setReadOnly(true);
    ui->text_log->setReadOnly(true);


    QString host_rand = QString::number(rand() * 255) + QString(".") +
            QString::number(rand() * 255) + QString(".") +
            QString::number(rand() * 255) + QString(".") +
            QString::number(rand() * 255);
    // QHostAddress host = QHostAddress(host_rand);
    // QHostAddress host =  QHostAddress::LocalHost ;;
    QHostAddress host =  QHostAddress::Broadcast;
    connector->setPort(qrand());
    connector->setHostAdress(host);
    connector->bindHostPort();

    // connector->joinMulticastGroup(host);

    client_tcp = new ClientTcp(this);
    server_tcp = new ServerTCP(this);
    connect(client_tcp,SIGNAL(sendedMessage(QByteArray)),this,SLOT(messageOutput(QByteArray)));
    connect(client_tcp,SIGNAL(receivedMessage(QByteArray)),this,SLOT(messageOutput(QByteArray)));
    connect(client_tcp,SIGNAL(connected()),this,SLOT(serverFounded()));

    //connect(server_tcp,SIGNAL(),this,SLOT());
    connect(server_tcp,SIGNAL(sendedMessage(QByteArray)),this,SLOT(messageOutput(QByteArray)));
    connect(server_tcp,SIGNAL(receivedMessage(QByteArray)),this,SLOT(messageOutput(QByteArray)));
    connect(server_tcp,SIGNAL(newConnection()),this,SLOT(clientConnected()));

    QHostAddress hosta("127.15.10.12");

    quint16 port = 135665;
    client_tcp->setHostAdress(hosta);
    client_tcp->setPort(port);

    server_tcp->setHostAdress(hosta);
    server_tcp->setPort(port);
    //    connecor->ho



}
Ejemplo n.º 2
0
void	audioBase::audioOut_48000	(int16_t *V, int32_t amount) {
float *buffer = (float *)alloca (2 * amount * sizeof (float));
int32_t	i, n;

	for (i = 0; i < amount; i ++) {
	   buffer [2 * i]	= V [2 * i] / 32767.0;
	   buffer [2 * i + 1]	= V [2 * i + 1] / 32767.0;
	}

	audioOutput (buffer, amount);
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
0
int main(int argc, char *argv[])
{
    SceCtrlData pad;
    int oldButtons = 0;
    int i;
#define SECOND       1000000
#define REPEAT_START (1 * SECOND)
#define REPEAT_DELAY (SECOND / 5)
    struct timeval repeatStart;
    struct timeval repeatDelay;

    repeatStart.tv_sec = 0;
    repeatStart.tv_usec = 0;
    repeatDelay.tv_sec = 0;
    repeatDelay.tv_usec = 0;

    for (i = 0; i < SAMPLE_SIZE; i += 2)
    {
	buffer1[i+0] = 0x00;
	buffer1[i+1] = 0x70;
	buffer2[i+0] = 0x00;
	buffer2[i+1] = 0x10;
    }

    pspDebugScreenInit();

    printf("Triangle - Exit\n");
    printf("Cross - Test Blocking Audio\n");
    printf("Square - Test non-Blocking Audio\n");
    printf("Circle - Test Audio2\n");

    channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, SAMPLE_SIZE, PSP_AUDIO_FORMAT_STEREO);
    if (channel < 0)
    {
        sceKernelExitGame();
    }

    while(!done)
    {
        sceCtrlReadBufferPositive(&pad, 1);
        int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;

	if (pad.Buttons == oldButtons)
	{
		struct timeval now;
		gettimeofday(&now, NULL);
		if (repeatStart.tv_sec == 0)
		{
			repeatStart.tv_sec = now.tv_sec;
			repeatStart.tv_usec = now.tv_usec;
			repeatDelay.tv_sec = 0;
			repeatDelay.tv_usec = 0;
		}
		else
		{
			long usec = (now.tv_sec - repeatStart.tv_sec) * SECOND;
			usec += (now.tv_usec - repeatStart.tv_usec);
			if (usec >= REPEAT_START)
			{
				if (repeatDelay.tv_sec != 0)
				{
					usec = (now.tv_sec - repeatDelay.tv_sec) * SECOND;
					usec += (now.tv_usec - repeatDelay.tv_usec);
					if (usec >= REPEAT_DELAY)
					{
						repeatDelay.tv_sec = 0;
					}
				}

				if (repeatDelay.tv_sec == 0)
				{
					buttonDown = pad.Buttons;
					repeatDelay.tv_sec = now.tv_sec;
					repeatDelay.tv_usec = now.tv_usec;
				}
			}
		}
	}
	else
	{
		repeatStart.tv_sec = 0;
	}

        if (buttonDown & PSP_CTRL_CROSS)
        {
		strcpy(text, "Start Test:\n");
		gettimeofday(&previousAudioOutput, NULL);
		for (i = 0; i < 10; i++)
		{
			audioOutput(buffer1, 1);
			audioOutput(buffer2, 1);
		}
		strcat(text, "\n");

		printf(text);
        }

        if (buttonDown & PSP_CTRL_SQUARE)
        {
		strcpy(text, "Start Test:\n");
		gettimeofday(&previousAudioOutput, NULL);
		for (i = 0; i < 10; i++)
		{
			audioOutput(buffer1, 0);
			audioOutput(buffer2, 0);
		}
		strcat(text, "\n");

		printf(text);
        }

        if (buttonDown & PSP_CTRL_CIRCLE)
        {
		sceAudioOutput2Reserve(SAMPLE_SIZE / 2);

		audioOutput2(buffer1, 0xFFFFF);
		sceKernelDelayThread(1 * 1000000);
		audioOutput2(buffer1, 0x20000);
		sceKernelDelayThread(1 * 1000000);
		audioOutput2(buffer1, 0x10000);
		sceKernelDelayThread(1 * 1000000);
		audioOutput2(buffer1, 0x08000);
		sceKernelDelayThread(1 * 1000000);
		audioOutput2(buffer1, 0x04000);
		sceKernelDelayThread(1 * 1000000);
		audioOutput2(buffer1, 0x02000);
		sceKernelDelayThread(1 * 1000000);
		audioOutput2(buffer1, 0x01000);
		sceKernelDelayThread(1 * 1000000);
		audioOutput2(buffer1, 0x00800);
        }

        if (buttonDown & PSP_CTRL_RIGHT)
        {
        }

        if (buttonDown & PSP_CTRL_UP)
        {
        }

        if (buttonDown & PSP_CTRL_DOWN)
        {
        }


        if (buttonDown & PSP_CTRL_TRIANGLE)
	{
        	done = 1;
	}

        oldButtons = pad.Buttons;
	sceDisplayWaitVblank();
    }

    sceKernelExitGame();
    return 0;
}
Ejemplo 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 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;
}
Ejemplo n.º 6
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;
}