[picodrive.git] / Pico / cd / cd_file.c

/*
#include <stdio.h>
#include <string.h>
#if defined(__WIN__)
#include <windows.h>
#else
#include "port.h"
#endif
#include "cd_sys.h"
#include "cd_file.h"
#include "lc89510.h"
#include "cdda_mp3.h"
#include "star_68k.h"
#include "rom.h"
#include "mem_s68k.h"
*/

#include <sys/stat.h>
#include "cd_file.h"

#include "../PicoInt.h"

#define cdprintf dprintf
//#define cdprintf(x...)
#define DEBUG_CD

struct _file_track Tracks[100];
char Track_Played;


int FILE_Init(void)
{
//	MP3_Init(); // TODO
	Unload_ISO();

	return 0;
}


void FILE_End(void)
{
	Unload_ISO();
}


int Load_ISO(const char *iso_name, int is_bin)
{
	struct stat file_stat;
	int i, j, num_track, Cur_LBA, index, ret;
	_scd_track *SCD_TOC_Tracks = Pico_mcd->scd.TOC.Tracks;
	FILE *tmp_file;
	char tmp_name[1024], tmp_ext[10];
	static char *exts[] = {
		"%02d.mp3", " %02d.mp3", "-%02d.mp3", "_%02d.mp3", " - %02d.mp3",
		"%d.mp3", " %d.mp3", "-%d.mp3", "_%d.mp3", " - %d.mp3",
		/* "%02d.wav", " %02d.wav", "-%02d.wav", "_%02d.wav", " - %02d.wav",
		"%d.wav", " %d.wav", "-%d.wav", "_%d.wav", " - %2d.wav" */
	};

	Unload_ISO();

	Tracks[0].Type = is_bin ? TYPE_BIN : TYPE_ISO;

	ret = stat(iso_name, &file_stat);
	if (ret != 0) return -1;

	Tracks[0].Lenght = file_stat.st_size;

	if (Tracks[0].Type == TYPE_ISO) Tracks[0].Lenght >>= 11;	// size in sectors
	else Tracks[0].Lenght /= 2352;					// size in sectors


	Tracks[0].F = fopen(iso_name, "rb");
	if (Tracks[0].F == NULL)
	{
		Tracks[0].Type = 0;
		Tracks[0].Lenght = 0;
		return -1;
	}

	if (Tracks[0].Type == TYPE_ISO) fseek(Tracks[0].F, 0x100, SEEK_SET);
	else fseek(Tracks[0].F, 0x110, SEEK_SET);

	// fread(buf, 1, 0x200, Tracks[0].F);
	fseek(Tracks[0].F, 0, SEEK_SET);

	Pico_mcd->scd.TOC.First_Track = 1;

	SCD_TOC_Tracks[0].Num = 1;
	SCD_TOC_Tracks[0].Type = 1;				// DATA

	SCD_TOC_Tracks[0].MSF.M = 0;
	SCD_TOC_Tracks[0].MSF.S = 2;
	SCD_TOC_Tracks[0].MSF.F = 0;

	cdprintf("Track 0 - %02d:%02d:%02d %s", SCD_TOC_Tracks[0].MSF.M, SCD_TOC_Tracks[0].MSF.S, SCD_TOC_Tracks[0].MSF.F,
		SCD_TOC_Tracks[0].Type ? "DATA" : "AUDIO");

	Cur_LBA = Tracks[0].Lenght;				// Size in sectors

	strcpy(tmp_name, iso_name);

	for(num_track = 2, i = 0; i < 100; i++)
	{
		if (sizeof(exts)/sizeof(char *) != 10) { printf("eee"); exit(1); }

		for(j = 0; j < sizeof(exts)/sizeof(char *); j++)
		{
			tmp_name[strlen(iso_name) - 4] = 0;
			sprintf(tmp_ext, exts[j], i);
			strcat(tmp_name, tmp_ext);

			tmp_file = fopen(tmp_name, "rb");

			if (tmp_file)
			{
				float fs;
				index = num_track - Pico_mcd->scd.TOC.First_Track;

				stat(tmp_name, &file_stat);

				fs = (float) file_stat.st_size;				// used to calculate lenght

				Tracks[index].F = tmp_file;

				SCD_TOC_Tracks[index].Num = num_track;
				SCD_TOC_Tracks[index].Type = 0;				// AUDIO

				LBA_to_MSF(Cur_LBA, &(SCD_TOC_Tracks[index].MSF));

				cdprintf("Track %i - %02d:%02d:%02d %s", index, SCD_TOC_Tracks[index].MSF.M,
					SCD_TOC_Tracks[index].MSF.S, SCD_TOC_Tracks[index].MSF.F,
					SCD_TOC_Tracks[index].Type ? "DATA" : "AUDIO");

				// MP3 File
				Tracks[index].Type = TYPE_MP3;
				fs /= (128>>3); // (float) (MP3_Get_Bitrate(Tracks[num_track - 1].F) >> 3);
				fs *= 75;
				Tracks[index].Lenght = (int) fs;
				Cur_LBA += Tracks[index].Lenght;

				num_track++;
				break;
			}
		}
	}

	Pico_mcd->scd.TOC.Last_Track = num_track - 1;

	index = num_track - Pico_mcd->scd.TOC.First_Track;
	SCD_TOC_Tracks[index].Num = num_track;
	SCD_TOC_Tracks[index].Type = 0;

	LBA_to_MSF(Cur_LBA, &(SCD_TOC_Tracks[index].MSF));

	cdprintf("End CD - %02d:%02d:%02d\n\n", SCD_TOC_Tracks[index].MSF.M,
		SCD_TOC_Tracks[index].MSF.S, SCD_TOC_Tracks[index].MSF.F);

	return 0;
}


void Unload_ISO(void)
{
	int i;

	Track_Played = 99;

	for(i = 0; i < 100; i++)
	{
		if (Tracks[i].F) fclose(Tracks[i].F);
		Tracks[i].F = NULL;
		Tracks[i].Lenght = 0;
		Tracks[i].Type = 0;
	}
}


int FILE_Read_One_LBA_CDC(void)
{
	int where_read;
	static char cp_buf[2560];

	if (Pico_mcd->s68k_regs[0x36] & 1)					// DATA
	{
		if (Tracks[0].F == NULL) return -1;

		if (Pico_mcd->scd.Cur_LBA < 0) where_read = 0;
		else if (Pico_mcd->scd.Cur_LBA >= Tracks[0].Lenght) where_read = Tracks[0].Lenght - 1;
		else where_read = Pico_mcd->scd.Cur_LBA;

		if (Tracks[0].Type == TYPE_ISO) where_read <<= 11;
		else where_read = (where_read * 2352 + 16);

		fseek(Tracks[0].F, where_read, SEEK_SET);
		fread(cp_buf, 1, 2048, Tracks[0].F);

		cdprintf("Read file CDC 1 data sector :\n");
	}
	else									// AUDIO
	{
		// int rate, channel;

		if (Tracks[Pico_mcd->scd.Cur_Track - Pico_mcd->scd.TOC.First_Track].Type == TYPE_MP3)
		{
			// TODO
			// MP3_Update(cp_buf, &rate, &channel, 0);
			// Write_CD_Audio((short *) cp_buf, rate, channel, 588);
		}

		cdprintf("Read file CDC 1 audio sector :\n");
	}

	// Update CDC stuff

	CDC_Update_Header();

	if (Pico_mcd->s68k_regs[0x36] & 1)		// DATA track
	{
		if (Pico_mcd->cdc.CTRL.B.B0 & 0x80)		// DECEN = decoding enable
		{
			if (Pico_mcd->cdc.CTRL.B.B0 & 0x04)	// WRRQ : this bit enable write to buffer
			{
				// CAUTION : lookahead bit not implemented

				Pico_mcd->scd.Cur_LBA++;

				Pico_mcd->cdc.WA.N = (Pico_mcd->cdc.WA.N + 2352) & 0x7FFF;		// add one sector to WA
				Pico_mcd->cdc.PT.N = (Pico_mcd->cdc.PT.N + 2352) & 0x7FFF;

				memcpy(&Pico_mcd->cdc.Buffer[Pico_mcd->cdc.PT.N + 4], cp_buf, 2048);
				memcpy(&Pico_mcd->cdc.Buffer[Pico_mcd->cdc.PT.N], &Pico_mcd->cdc.HEAD, 4);

#ifdef DEBUG_CD
				cdprintf("Read -> WA = %d  Buffer[%d] =", Pico_mcd->cdc.WA.N, Pico_mcd->cdc.PT.N & 0x3FFF);
				cdprintf("Header 1 = %.2X %.2X %.2X %.2X", Pico_mcd->cdc.HEAD.B.B0,
					Pico_mcd->cdc.HEAD.B.B1, Pico_mcd->cdc.HEAD.B.B2, Pico_mcd->cdc.HEAD.B.B3);
				cdprintf("Header 2 = %.2X %.2X %.2X %.2X --- %.2X %.2X\n\n",
					Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 0) & 0x3FFF],
					Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 1) & 0x3FFF],
					Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 2) & 0x3FFF],
					Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 3) & 0x3FFF],
					Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 4) & 0x3FFF],
					Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 5) & 0x3FFF]);
#endif
			}

		}
	}
	else		// music track
	{
		Pico_mcd->scd.Cur_LBA++;

		Pico_mcd->cdc.WA.N = (Pico_mcd->cdc.WA.N + 2352) & 0x7FFF;		// add one sector to WA
		Pico_mcd->cdc.PT.N = (Pico_mcd->cdc.PT.N + 2352) & 0x7FFF;

		if (Pico_mcd->cdc.CTRL.B.B0 & 0x80)		// DECEN = decoding enable
		{
			if (Pico_mcd->cdc.CTRL.B.B0 & 0x04)	// WRRQ : this bit enable write to buffer
			{
				// CAUTION : lookahead bit not implemented

				memcpy(&Pico_mcd->cdc.Buffer[Pico_mcd->cdc.PT.N], cp_buf, 2352);
			}
		}
	}

	if (Pico_mcd->cdc.CTRL.B.B0 & 0x80)		// DECEN = decoding enable
	{
		Pico_mcd->cdc.STAT.B.B0 = 0x80;

		if (Pico_mcd->cdc.CTRL.B.B0 & 0x10)	// determine form bit form sub header ?
		{
			Pico_mcd->cdc.STAT.B.B2 = Pico_mcd->cdc.CTRL.B.B1 & 0x08;
		}
		else
		{
			Pico_mcd->cdc.STAT.B.B2 = Pico_mcd->cdc.CTRL.B.B1 & 0x0C;
		}

		if (Pico_mcd->cdc.CTRL.B.B0 & 0x02) Pico_mcd->cdc.STAT.B.B3 = 0x20;	// ECC done
		else Pico_mcd->cdc.STAT.B.B3 = 0x00;	// ECC not done

		if (Pico_mcd->cdc.IFCTRL & 0x20)
		{
			if (Pico_mcd->s68k_regs[0x33] & (1<<5))
			{
				dprintf("cdc dec irq 5");
				SekInterruptS68k(5);
			}

			Pico_mcd->cdc.IFSTAT &= ~0x20;	// DEC interrupt happen
			CDC_Decode_Reg_Read = 0;	// Reset read after DEC int
		}
	}


	return 0;
}


int FILE_Play_CD_LBA(void)
{
	int index = Pico_mcd->scd.Cur_Track - Pico_mcd->scd.TOC.First_Track;

	cdprintf("Play FILE Comp");

	if (Tracks[index].F == NULL)
	{
		return 1;
	}

	if (Tracks[index].Type == TYPE_MP3)
	{
		int Track_LBA_Pos = Pico_mcd->scd.Cur_LBA - Track_to_LBA(Pico_mcd->scd.Cur_Track);
		if (Track_LBA_Pos < 0) Track_LBA_Pos = 0;

		// MP3_Play(index, Track_LBA_Pos); // TODO
	}
	else
	{
		return 3;
	}

	return 0;
}
Commit	Line	Data
bf098bc5	1	/*
	2	#include <stdio.h>
	3	#include <string.h>
	4	#if defined(__WIN__)
	5	#include <windows.h>
	6	#else
	7	#include "port.h"
	8	#endif
	9	#include "cd_sys.h"
	10	#include "cd_file.h"
	11	#include "lc89510.h"
	12	#include "cdda_mp3.h"
	13	#include "star_68k.h"
	14	#include "rom.h"
	15	#include "mem_s68k.h"
	16	*/
	17
	18	#include <sys/stat.h>
	19	#include "cd_file.h"
	20
	21	#include "../PicoInt.h"
	22
c459aefd	23	#define cdprintf dprintf
bf098bc5	24	//#define cdprintf(x...)
c459aefd	25	#define DEBUG_CD
bf098bc5	26
	27	struct _file_track Tracks[100];
	28	char Track_Played;
	29
	30
	31	int FILE_Init(void)
	32	{
	33	// MP3_Init(); // TODO
	34	Unload_ISO();
	35
	36	return 0;
	37	}
	38
	39
	40	void FILE_End(void)
	41	{
	42	Unload_ISO();
	43	}
	44
	45
	46	int Load_ISO(const char *iso_name, int is_bin)
	47	{
	48	struct stat file_stat;
	49	int i, j, num_track, Cur_LBA, index, ret;
	50	_scd_track *SCD_TOC_Tracks = Pico_mcd->scd.TOC.Tracks;
	51	FILE *tmp_file;
	52	char tmp_name[1024], tmp_ext[10];
	53	static char *exts[] = {
	54	"%02d.mp3", " %02d.mp3", "-%02d.mp3", "_%02d.mp3", " - %02d.mp3",
	55	"%d.mp3", " %d.mp3", "-%d.mp3", "_%d.mp3", " - %d.mp3",
	56	/* "%02d.wav", " %02d.wav", "-%02d.wav", "_%02d.wav", " - %02d.wav",
	57	"%d.wav", " %d.wav", "-%d.wav", "_%d.wav", " - %2d.wav" */
	58	};
	59
	60	Unload_ISO();
	61
	62	Tracks[0].Type = is_bin ? TYPE_BIN : TYPE_ISO;
	63
	64	ret = stat(iso_name, &file_stat);
	65	if (ret != 0) return -1;
	66
	67	Tracks[0].Lenght = file_stat.st_size;
	68
	69	if (Tracks[0].Type == TYPE_ISO) Tracks[0].Lenght >>= 11; // size in sectors
	70	else Tracks[0].Lenght /= 2352; // size in sectors
	71
	72
	73	Tracks[0].F = fopen(iso_name, "rb");
	74	if (Tracks[0].F == NULL)
	75	{
	76	Tracks[0].Type = 0;
	77	Tracks[0].Lenght = 0;
	78	return -1;
	79	}
	80
	81	if (Tracks[0].Type == TYPE_ISO) fseek(Tracks[0].F, 0x100, SEEK_SET);
	82	else fseek(Tracks[0].F, 0x110, SEEK_SET);
	83
	84	// fread(buf, 1, 0x200, Tracks[0].F);
	85	fseek(Tracks[0].F, 0, SEEK_SET);
	86
	87	Pico_mcd->scd.TOC.First_Track = 1;
	88
	89	SCD_TOC_Tracks[0].Num = 1;
90	SCD_TOC_Tracks[0].Type = 1; // DATA
91
92	SCD_TOC_Tracks[0].MSF.M = 0;
93	SCD_TOC_Tracks[0].MSF.S = 2;
94	SCD_TOC_Tracks[0].MSF.F = 0;
95
c459aefd	96	cdprintf("Track 0 - %02d:%02d:%02d %s", SCD_TOC_Tracks[0].MSF.M, SCD_TOC_Tracks[0].MSF.S, SCD_TOC_Tracks[0].MSF.F,
bf098bc5	97	SCD_TOC_Tracks[0].Type ? "DATA" : "AUDIO");
	98
	99	Cur_LBA = Tracks[0].Lenght; // Size in sectors
	100
	101	strcpy(tmp_name, iso_name);
	102
	103	for(num_track = 2, i = 0; i < 100; i++)
	104	{
	105	if (sizeof(exts)/sizeof(char *) != 10) { printf("eee"); exit(1); }
	106
	107	for(j = 0; j < sizeof(exts)/sizeof(char *); j++)
	108	{
	109	tmp_name[strlen(iso_name) - 4] = 0;
	110	sprintf(tmp_ext, exts[j], i);
	111	strcat(tmp_name, tmp_ext);
	112
	113	tmp_file = fopen(tmp_name, "rb");
	114
	115	if (tmp_file)
	116	{
	117	float fs;
	118	index = num_track - Pico_mcd->scd.TOC.First_Track;
	119
	120	stat(tmp_name, &file_stat);
	121
	122	fs = (float) file_stat.st_size; // used to calculate lenght
	123
	124	Tracks[index].F = tmp_file;
	125
	126	SCD_TOC_Tracks[index].Num = num_track;
	127	SCD_TOC_Tracks[index].Type = 0; // AUDIO
	128
	129	LBA_to_MSF(Cur_LBA, &(SCD_TOC_Tracks[index].MSF));
	130
c459aefd	131	cdprintf("Track %i - %02d:%02d:%02d %s", index, SCD_TOC_Tracks[index].MSF.M,
bf098bc5	132	SCD_TOC_Tracks[index].MSF.S, SCD_TOC_Tracks[index].MSF.F,
	133	SCD_TOC_Tracks[index].Type ? "DATA" : "AUDIO");
	134
	135	// MP3 File
	136	Tracks[index].Type = TYPE_MP3;
	137	fs /= (128>>3); // (float) (MP3_Get_Bitrate(Tracks[num_track - 1].F) >> 3);
	138	fs *= 75;
	139	Tracks[index].Lenght = (int) fs;
	140	Cur_LBA += Tracks[index].Lenght;
	141
	142	num_track++;
	143	break;
	144	}
	145	}
	146	}
	147
	148	Pico_mcd->scd.TOC.Last_Track = num_track - 1;
	149
	150	index = num_track - Pico_mcd->scd.TOC.First_Track;
	151	SCD_TOC_Tracks[index].Num = num_track;
	152	SCD_TOC_Tracks[index].Type = 0;
	153
	154	LBA_to_MSF(Cur_LBA, &(SCD_TOC_Tracks[index].MSF));
	155
	156	cdprintf("End CD - %02d:%02d:%02d\n\n", SCD_TOC_Tracks[index].MSF.M,
	157	SCD_TOC_Tracks[index].MSF.S, SCD_TOC_Tracks[index].MSF.F);
	158
	159	return 0;
	160	}
	161
	162
	163	void Unload_ISO(void)
	164	{
	165	int i;
	166
	167	Track_Played = 99;
	168
	169	for(i = 0; i < 100; i++)
	170	{
	171	if (Tracks[i].F) fclose(Tracks[i].F);
	172	Tracks[i].F = NULL;
	173	Tracks[i].Lenght = 0;
	174	Tracks[i].Type = 0;
	175	}
	176	}
	177
	178
	179	int FILE_Read_One_LBA_CDC(void)
	180	{
	181	int where_read;
	182	static char cp_buf[2560];
	183
	184	if (Pico_mcd->s68k_regs[0x36] & 1) // DATA
	185	{
	186	if (Tracks[0].F == NULL) return -1;
	187
	188	if (Pico_mcd->scd.Cur_LBA < 0) where_read = 0;
	189	else if (Pico_mcd->scd.Cur_LBA >= Tracks[0].Lenght) where_read = Tracks[0].Lenght - 1;
	190	else where_read = Pico_mcd->scd.Cur_LBA;
	191
	192	if (Tracks[0].Type == TYPE_ISO) where_read <<= 11;
	193	else where_read = (where_read * 2352 + 16);
	194
	195	fseek(Tracks[0].F, where_read, SEEK_SET);
196	fread(cp_buf, 1, 2048, Tracks[0].F);
197
c459aefd	198	cdprintf("Read file CDC 1 data sector :\n");
bf098bc5	199	}
	200	else // AUDIO
	201	{
	202	// int rate, channel;
	203
	204	if (Tracks[Pico_mcd->scd.Cur_Track - Pico_mcd->scd.TOC.First_Track].Type == TYPE_MP3)
	205	{
	206	// TODO
	207	// MP3_Update(cp_buf, &rate, &channel, 0);
	208	// Write_CD_Audio((short *) cp_buf, rate, channel, 588);
	209	}
	210
c459aefd	211	cdprintf("Read file CDC 1 audio sector :\n");
bf098bc5	212	}
	213
	214	// Update CDC stuff
	215
	216	CDC_Update_Header();
	217
	218	if (Pico_mcd->s68k_regs[0x36] & 1) // DATA track
	219	{
	220	if (Pico_mcd->cdc.CTRL.B.B0 & 0x80) // DECEN = decoding enable
	221	{
	222	if (Pico_mcd->cdc.CTRL.B.B0 & 0x04) // WRRQ : this bit enable write to buffer
	223	{
	224	// CAUTION : lookahead bit not implemented
	225
	226	Pico_mcd->scd.Cur_LBA++;
	227
	228	Pico_mcd->cdc.WA.N = (Pico_mcd->cdc.WA.N + 2352) & 0x7FFF; // add one sector to WA
	229	Pico_mcd->cdc.PT.N = (Pico_mcd->cdc.PT.N + 2352) & 0x7FFF;
	230
	231	memcpy(&Pico_mcd->cdc.Buffer[Pico_mcd->cdc.PT.N + 4], cp_buf, 2048);
	232	memcpy(&Pico_mcd->cdc.Buffer[Pico_mcd->cdc.PT.N], &Pico_mcd->cdc.HEAD, 4);
	233
	234	#ifdef DEBUG_CD
c459aefd	235	cdprintf("Read -> WA = %d Buffer[%d] =", Pico_mcd->cdc.WA.N, Pico_mcd->cdc.PT.N & 0x3FFF);
c459aefd	236	cdprintf("Header 1 = %.2X %.2X %.2X %.2X", Pico_mcd->cdc.HEAD.B.B0,
bf098bc5	237	Pico_mcd->cdc.HEAD.B.B1, Pico_mcd->cdc.HEAD.B.B2, Pico_mcd->cdc.HEAD.B.B3);
	238	cdprintf("Header 2 = %.2X %.2X %.2X %.2X --- %.2X %.2X\n\n",
	239	Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 0) & 0x3FFF],
	240	Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 1) & 0x3FFF],
	241	Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 2) & 0x3FFF],
	242	Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 3) & 0x3FFF],
	243	Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 4) & 0x3FFF],
	244	Pico_mcd->cdc.Buffer[(Pico_mcd->cdc.PT.N + 5) & 0x3FFF]);
	245	#endif
	246	}
	247
	248	}
	249	}
	250	else // music track
	251	{
	252	Pico_mcd->scd.Cur_LBA++;
	253
	254	Pico_mcd->cdc.WA.N = (Pico_mcd->cdc.WA.N + 2352) & 0x7FFF; // add one sector to WA
	255	Pico_mcd->cdc.PT.N = (Pico_mcd->cdc.PT.N + 2352) & 0x7FFF;
	256
	257	if (Pico_mcd->cdc.CTRL.B.B0 & 0x80) // DECEN = decoding enable
	258	{
	259	if (Pico_mcd->cdc.CTRL.B.B0 & 0x04) // WRRQ : this bit enable write to buffer
	260	{
	261	// CAUTION : lookahead bit not implemented
	262
	263	memcpy(&Pico_mcd->cdc.Buffer[Pico_mcd->cdc.PT.N], cp_buf, 2352);
	264	}
	265	}
	266	}
	267
	268	if (Pico_mcd->cdc.CTRL.B.B0 & 0x80) // DECEN = decoding enable
	269	{
	270	Pico_mcd->cdc.STAT.B.B0 = 0x80;
	271
	272	if (Pico_mcd->cdc.CTRL.B.B0 & 0x10) // determine form bit form sub header ?
	273	{
	274	Pico_mcd->cdc.STAT.B.B2 = Pico_mcd->cdc.CTRL.B.B1 & 0x08;
	275	}
	276	else
	277	{
	278	Pico_mcd->cdc.STAT.B.B2 = Pico_mcd->cdc.CTRL.B.B1 & 0x0C;
	279	}
	280
	281	if (Pico_mcd->cdc.CTRL.B.B0 & 0x02) Pico_mcd->cdc.STAT.B.B3 = 0x20; // ECC done
	282	else Pico_mcd->cdc.STAT.B.B3 = 0x00; // ECC not done
	283
	284	if (Pico_mcd->cdc.IFCTRL & 0x20)
	285	{
	286	if (Pico_mcd->s68k_regs[0x33] & (1<<5))
	287	{
	288	dprintf("cdc dec irq 5");
	289	SekInterruptS68k(5);
	290	}
	291
	292	Pico_mcd->cdc.IFSTAT &= ~0x20; // DEC interrupt happen
	293	CDC_Decode_Reg_Read = 0; // Reset read after DEC int
	294	}
	295	}
	296
	297
	298	return 0;
	299	}
	300
301
302	int FILE_Play_CD_LBA(void)
303	{
304	int index = Pico_mcd->scd.Cur_Track - Pico_mcd->scd.TOC.First_Track;
305
c459aefd	306	cdprintf("Play FILE Comp");
bf098bc5	307
	308	if (Tracks[index].F == NULL)
	309	{
	310	return 1;
	311	}
	312
	313	if (Tracks[index].Type == TYPE_MP3)
	314	{
	315	int Track_LBA_Pos = Pico_mcd->scd.Cur_LBA - Track_to_LBA(Pico_mcd->scd.Cur_Track);
	316	if (Track_LBA_Pos < 0) Track_LBA_Pos = 0;
	317
	318	// MP3_Play(index, Track_LBA_Pos); // TODO
	319	}
	320	else
	321	{
	322	return 3;
	323	}
	324
	325	return 0;
	326	}
	327