ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

PicoDrive: Mega CD. No CD audio yet.

This commit is contained in:
nattthebear 2017-07-02 20:46:01 -04:00
parent a80f16c032
commit 24cd317a1c
16 changed files with 729 additions and 1496 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
BizHawk.Emulation.Cores/Consoles/Sega/PicoDrive/LibPicoDrive.cs
View File

@ -17,7 +17,13 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.PicoDrive
public int Buttons; public int Buttons;
} }
[UnmanagedFunctionPointer(CC)]
public delegate void CDReadCallback(int lba, IntPtr dest, bool audio);
[BizImport(CC)] [BizImport(CC)]
public abstract bool Init(); public abstract bool Init(bool cd);
[BizImport(CC)]
public abstract void SetCDReadCallback(CDReadCallback callback);
} }
} }

84
BizHawk.Emulation.Cores/Consoles/Sega/PicoDrive/PicoDrive.cs
View File

@ -1,21 +1,35 @@
using BizHawk.Emulation.Common; using BizHawk.Emulation.Common;
using BizHawk.Emulation.Cores.Waterbox; using BizHawk.Emulation.Cores.Waterbox;
using BizHawk.Emulation.DiscSystem;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
using System.IO;
namespace BizHawk.Emulation.Cores.Consoles.Sega.PicoDrive namespace BizHawk.Emulation.Cores.Consoles.Sega.PicoDrive
{ {
[CoreAttributes("PicoDrive", "notaz", true, false, [CoreAttributes("PicoDrive", "notaz", true, false,
"0e352905c7aa80b166933970abbcecfce96ad64e", "https://github.com/notaz/picodrive", false)] "0e352905c7aa80b166933970abbcecfce96ad64e", "https://github.com/notaz/picodrive", false)]
public class PicoDrive : WaterboxCore public class PicoDrive : WaterboxCore, IDriveLight
{ {
private LibPicoDrive _core; private LibPicoDrive _core;
private LibPicoDrive.CDReadCallback _cdcallback;
private Disc _cd;
private DiscSectorReader _cdReader;
[CoreConstructor("GEN")] [CoreConstructor("GEN")]
public PicoDrive(CoreComm comm, byte[] rom, bool deterministic) public PicoDrive(CoreComm comm, byte[] rom, bool deterministic)
:this(comm, rom, null, deterministic)
{ }
public PicoDrive(CoreComm comm, Disc cd, bool deterministic)
:this(comm, null, cd, deterministic)
{ }
private PicoDrive(CoreComm comm, byte[] rom, Disc cd, bool deterministic)
: base(comm, new Configuration : base(comm, new Configuration
{ {
MaxSamples = 2048, MaxSamples = 2048,
@ -51,12 +65,38 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.PicoDrive
_exe.AddReadonlyFile(bioss, "32x.s"); _exe.AddReadonlyFile(bioss, "32x.s");
Console.WriteLine("Using supplied 32x BIOS files"); Console.WriteLine("Using supplied 32x BIOS files");
} }
_exe.AddReadonlyFile(rom, "romfile.md"); if (cd != null)
{
_exe.AddReadonlyFile(comm.CoreFileProvider.GetFirmware("GEN", "CD_BIOS_EU", true), "cd.eu");
_exe.AddReadonlyFile(comm.CoreFileProvider.GetFirmware("GEN", "CD_BIOS_US", true), "cd.us");
_exe.AddReadonlyFile(comm.CoreFileProvider.GetFirmware("GEN", "CD_BIOS_JP", true), "cd.jp");
_exe.AddReadonlyFile(gpgx64.GPGX.GetCDData(cd), "toc");
_cd = cd;
_cdReader = new DiscSectorReader(_cd);
_cdcallback = CDRead;
_core.SetCDReadCallback(_cdcallback);
DriveLightEnabled = true;
}
else
{
_exe.AddReadonlyFile(rom, "romfile.md");
}
if (!_core.Init()) if (!_core.Init(cd != null))
throw new InvalidOperationException("Core rejected the rom!"); throw new InvalidOperationException("Core rejected the file!");
_exe.RemoveReadonlyFile("romfile.md"); if (cd != null)
{
_exe.RemoveReadonlyFile("cd.eu");
_exe.RemoveReadonlyFile("cd.us");
_exe.RemoveReadonlyFile("cd.jp");
_exe.RemoveReadonlyFile("toc");
_core.SetCDReadCallback(null);
}
else
{
_exe.RemoveReadonlyFile("romfile.md");
}
if (has32xBios) if (has32xBios)
{ {
_exe.RemoveReadonlyFile("32x.g"); _exe.RemoveReadonlyFile("32x.g");
@ -67,6 +107,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.PicoDrive
PostInit(); PostInit();
ControllerDefinition = PicoDriveController; ControllerDefinition = PicoDriveController;
DeterministicEmulation = deterministic; DeterministicEmulation = deterministic;
_core.SetCDReadCallback(_cdcallback);
} }
public static readonly ControllerDefinition PicoDriveController = new ControllerDefinition public static readonly ControllerDefinition PicoDriveController = new ControllerDefinition
@ -97,7 +138,40 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.PicoDrive
b |= v; b |= v;
v <<= 1; v <<= 1;
} }
DriveLightOn = false;
return new LibPicoDrive.FrameInfo { Buttons = b }; return new LibPicoDrive.FrameInfo { Buttons = b };
} }
private void CDRead(int lba, IntPtr dest, bool audio)
{
if (audio)
{
byte[] data = new byte[2352];
if (lba < _cd.Session1.LeadoutLBA)
{
_cdReader.ReadLBA_2352(lba, data, 0);
}
Marshal.Copy(data, 0, dest, 2352);
}
else
{
byte[] data = new byte[2048];
_cdReader.ReadLBA_2048(lba, data, 0);
Marshal.Copy(data, 0, dest, 2048);
DriveLightOn = true;
}
}
protected override void LoadStateBinaryInternal(BinaryReader reader)
{
_core.SetCDReadCallback(_cdcallback);
}
#region IDriveLight
public bool DriveLightEnabled { get; private set; }
public bool DriveLightOn { get; private set; }
#endregion
} }
} }

7
BizHawk.Emulation.Cores/Consoles/Sega/gpgx64/GPGX.cs
View File

@ -6,6 +6,7 @@ using BizHawk.Common.BizInvoke;
using BizHawk.Emulation.Common; using BizHawk.Emulation.Common;
using BizHawk.Emulation.Cores.Waterbox; using BizHawk.Emulation.Cores.Waterbox;
using BizHawk.Common; using BizHawk.Common;
using BizHawk.Emulation.DiscSystem;
namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx64 namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx64
{ {
@ -221,7 +222,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx64
Console.WriteLine("Couldn't satisfy firmware request {0} because none was provided.", filename); Console.WriteLine("Couldn't satisfy firmware request {0} because none was provided.", filename);
return 0; return 0;
} }
srcdata = GetCDData(); srcdata = GetCDData(CD);
if (srcdata.Length != maxsize) if (srcdata.Length != maxsize)
{ {
Console.WriteLine("Couldn't satisfy firmware request {0} because of struct size.", filename); Console.WriteLine("Couldn't satisfy firmware request {0} because of struct size.", filename);
@ -308,12 +309,12 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx64
LibGPGX.cd_read_cb cd_callback_handle; LibGPGX.cd_read_cb cd_callback_handle;
unsafe byte[] GetCDData() public static unsafe byte[] GetCDData(Disc cd)
{ {
LibGPGX.CDData ret = new LibGPGX.CDData(); LibGPGX.CDData ret = new LibGPGX.CDData();
int size = Marshal.SizeOf(ret); int size = Marshal.SizeOf(ret);
var ses = CD.Session1; var ses = cd.Session1;
int ntrack = ses.InformationTrackCount; int ntrack = ses.InformationTrackCount;
// bet you a dollar this is all wrong // bet you a dollar this is all wrong

59
waterbox/picodrive/bizhawk.c
View File

@ -6,7 +6,7 @@
#include "../emulibc/emulibc.h" #include "../emulibc/emulibc.h"
#include "../emulibc/waterboxcore.h" #include "../emulibc/waterboxcore.h"
#include "pico/pico.h" #include "pico/pico.h"
#include "pico/cd/cue.h" #include "pico/cd/cdd.h"
void lprintf(const char *fmt, ...) void lprintf(const char *fmt, ...)
{ {
@ -24,12 +24,41 @@ int PicoCartResize(int newsize)
int PicoCdCheck(const char *fname_in, int *pregion) int PicoCdCheck(const char *fname_in, int *pregion)
{ {
return CIT_NOT_CD; uint8_t buff[2048];
CDReadSector(0, buff, 0);
int region;
switch (buff[0x20b])
{
case 0x64:
region = 8; // EU
printf("Detected CD region EU\n");
break;
case 0xa1:
region = 1; // JP
printf("Detected CD region JP\n");
break;
default:
region = 4; // US
printf("Detected CD region US\n");
break;
}
if (pregion)
*pregion = region;
return CIT_BIN;
} }
cue_data_t *cue_parse(const char *fname) static const char *GetBiosFilename(int *region, const char *cd_fname)
{ {
return NULL; switch (*region)
{
case 8: // EU
return "cd.eu";
case 1: // JP
return "cd.jp";
default: // US?
return "cd.us";
}
} }
pm_file *pm_open(const char *path) pm_file *pm_open(const char *path)
@ -97,21 +126,21 @@ int mp3_get_bitrate(void *f, int size) { return 0; }
void mp3_start_play(void *f, int pos) {} void mp3_start_play(void *f, int pos) {}
void mp3_update(int *buffer, int length, int stereo) {} void mp3_update(int *buffer, int length, int stereo) {}
static const uint8_t* TryLoadBios(const char* name) static const uint8_t *TryLoadBios(const char *name)
{ {
FILE *f = fopen(name, "rb"); FILE *f = fopen(name, "rb");
if (!f) if (!f)
return NULL; return NULL;
fseek(f, 0, SEEK_END); fseek(f, 0, SEEK_END);
int size = ftell(f); int size = ftell(f);
uint8_t* ret = alloc_sealed(size); uint8_t *ret = alloc_sealed(size);
fseek(f, 0, SEEK_SET); fseek(f, 0, SEEK_SET);
fread(ret, 1, size, f); fread(ret, 1, size, f);
fclose(f); fclose(f);
return ret; return ret;
} }
ECL_EXPORT int Init(void) ECL_EXPORT int Init(int cd)
{ {
p32x_bios_g = TryLoadBios("32x.g"); p32x_bios_g = TryLoadBios("32x.g");
p32x_bios_m = TryLoadBios("32x.m"); p32x_bios_m = TryLoadBios("32x.m");
@ -120,8 +149,16 @@ ECL_EXPORT int Init(void)
PicoOpt = POPT_EN_FM | POPT_EN_PSG | POPT_EN_Z80 | POPT_EN_STEREO | POPT_ACC_SPRITES | POPT_DIS_32C_BORDER | POPT_EN_MCD_PCM | POPT_EN_MCD_CDDA | POPT_EN_MCD_GFX | POPT_EN_32X | POPT_EN_PWM; PicoOpt = POPT_EN_FM | POPT_EN_PSG | POPT_EN_Z80 | POPT_EN_STEREO | POPT_ACC_SPRITES | POPT_DIS_32C_BORDER | POPT_EN_MCD_PCM | POPT_EN_MCD_CDDA | POPT_EN_MCD_GFX | POPT_EN_32X | POPT_EN_PWM;
PicoInit(); PicoInit();
if (PicoLoadMedia("romfile.md", NULL, NULL, NULL, PM_MD_CART) != PM_MD_CART) if (cd)
return 0; {
if (PicoLoadMedia(NULL, NULL, GetBiosFilename, NULL, PM_CD) != PM_CD)
return 0;
}
else
{
if (PicoLoadMedia("romfile.md", NULL, NULL, NULL, PM_MD_CART) != PM_MD_CART)
return 0;
}
PicoLoopPrepare(); PicoLoopPrepare();
video_buffer = alloc_invisible(512 * 512 * sizeof(uint16_t)); video_buffer = alloc_invisible(512 * 512 * sizeof(uint16_t));
@ -189,6 +226,10 @@ ECL_EXPORT void SetInputCallback(void (*callback)(void))
{ {
PicoInputCallback = callback; PicoInputCallback = callback;
} }
ECL_EXPORT void SetCDReadCallback(void (*callback)(int lba, void *dest, int audio))
{
CDReadSector = callback;
}
int main(void) int main(void)
{ {

8
waterbox/picodrive/pico/carthw/svp/svp.c
View File

@ -107,14 +107,6 @@ void PicoSVPInit(void)
#endif #endif
} }
static void PicoSVPExit(void)
{
#ifdef _SVP_DRC
ssp1601_dyn_exit();
#endif
}
void PicoSVPStartup(void) void PicoSVPStartup(void)
{ {
int ret; int ret;

268
waterbox/picodrive/pico/cd/cd_image.c
View File

@ -1,268 +0,0 @@
/*
* CD image handler
* (C) notaz, 2007,2013
*
* This work is licensed under the terms of MAME license.
* See COPYING file in the top-level directory.
*/
#include "../pico_int.h"
#include "genplus_macros.h"
#include "cdd.h"
#include "cue.h"
static int handle_mp3(const char *fname, int index)
{
track_t *track = &cdd.toc.tracks[index];
FILE *tmp_file;
int kBps;
int fs, ret;
tmp_file = fopen(fname, "rb");
if (tmp_file == NULL)
return -1;
ret = fseek(tmp_file, 0, SEEK_END);
fs = ftell(tmp_file);
fseek(tmp_file, 0, SEEK_SET);
#ifdef _PSP_FW_VERSION
// some systems (like PSP) can't have many open files at a time,
// so we work with their names instead.
fclose(tmp_file);
tmp_file = (void *) strdup(fname);
#endif
kBps = mp3_get_bitrate(tmp_file, fs) / 8;
if (ret != 0 || kBps <= 0)
{
elprintf(EL_STATUS, "track %2i: mp3 bitrate %i", index+1, kBps);
#ifdef _PSP_FW_VERSION
free(tmp_file);
#else
fclose(tmp_file);
#endif
return -1;
}
track->fd = tmp_file;
track->offset = 0;
fs *= 75;
fs /= kBps * 1000;
return fs;
}
static void to_upper(char *d, const char *s)
{
for (; *s != 0; d++, s++) {
if ('a' <= *s && *s <= 'z')
*d = *s - 'a' + 'A';
else
*d = *s;
}
}
// cdd.c uses lba - 150
static void sprintf_lba(char *buf, size_t size, int lba)
{
lba += 150;
snprintf(buf, size, "%02d:%02d:%02d", lba / 60 / 75,
(lba / 75) % 60, lba % 75);
}
int load_cd_image(const char *cd_img_name, int *type)
{
static const char *exts[] = {
"%02d.mp3", " %02d.mp3", "-%02d.mp3", "_%02d.mp3", " - %02d.mp3",
"%d.mp3", " %d.mp3", "-%d.mp3", "_%d.mp3", " - %d.mp3",
};
int i, j, n, lba, index, length, ret;
int iso_name_len, missed, cd_img_sectors;
char tmp_name[256], tmp_ext[10], tmp_ext_u[10];
track_t *tracks = cdd.toc.tracks;
cue_data_t *cue_data = NULL;
pm_file *pmf;
if (PicoCDLoadProgressCB != NULL)
PicoCDLoadProgressCB(cd_img_name, 1);
Pico_mcd->cdda_type = CT_UNKNOWN;
/* is this a .cue? */
cue_data = cue_parse(cd_img_name);
if (cue_data != NULL) {
cd_img_name = cue_data->tracks[1].fname;
*type = cue_data->tracks[1].type;
}
pmf = pm_open(cd_img_name);
if (pmf == NULL)
{
if (cue_data != NULL)
cue_destroy(cue_data);
return -1;
}
tracks[0].fd = pmf;
if (*type == CT_ISO)
cd_img_sectors = pmf->size >>= 11; // size in sectors
else cd_img_sectors = pmf->size /= 2352;
// cdd.c operates with lba - 150
tracks[0].start = 0;
tracks[0].end = cd_img_sectors;
tracks[0].offset = 0;
sprintf_lba(tmp_ext, sizeof(tmp_ext), 0);
elprintf(EL_STATUS, "Track 1: %s %9i DATA %s",
tmp_ext, tracks[0].end, cd_img_name);
lba = cd_img_sectors;
if (cue_data != NULL)
{
if (cue_data->tracks[2].fname == NULL) {
// NULL fname means track2 is in same file as track1
lba = tracks[0].end = cue_data->tracks[2].sector_offset;
}
i = 100 / cue_data->track_count + 1; // progress display
for (n = 2; n <= cue_data->track_count; n++)
{
if (PicoCDLoadProgressCB != NULL)
PicoCDLoadProgressCB(cd_img_name, i * n);
index = n - 1;
lba += cue_data->tracks[n].pregap;
if (cue_data->tracks[n].type == CT_MP3) {
ret = handle_mp3(cue_data->tracks[n].fname, index);
if (ret < 0)
break;
length = ret;
}
else if (cue_data->tracks[n].fname != NULL)
{
pm_file *f = pm_open(cue_data->tracks[n].fname);
if (f != NULL)
{
// assume raw, ignore header for wav..
tracks[index].fd = f;
tracks[index].offset = cue_data->tracks[n].sector_offset;
length = f->size / 2352;
}
else
{
elprintf(EL_STATUS, "track %2i (%s): can't determine length",
n, cue_data->tracks[n].fname);
tracks[index].offset = 0;
length = 2*75;
}
}
else
{
if (n < cue_data->track_count)
length = cue_data->tracks[n+1].sector_offset -
cue_data->tracks[n].sector_offset;
else
length = cd_img_sectors - cue_data->tracks[n].sector_offset;
tracks[index].offset = cue_data->tracks[n].sector_offset;
}
if (cue_data->tracks[n].sector_xlength != 0)
// overriden by custom cue command
length = cue_data->tracks[n].sector_xlength;
Pico_mcd->cdda_type = cue_data->tracks[n].type;
tracks[index].start = lba;
lba += length;
tracks[index].end = lba;
sprintf_lba(tmp_ext, sizeof(tmp_ext), tracks[index].start);
elprintf(EL_STATUS, "Track %2i: %s %9i AUDIO %s",
n, tmp_ext, length, cue_data->tracks[n].fname);
}
goto finish;
}
/* mp3 track autosearch, Gens-like */
iso_name_len = strlen(cd_img_name);
if (iso_name_len >= sizeof(tmp_name))
iso_name_len = sizeof(tmp_name) - 1;
for (n = 2, i = 0, missed = 0; i < 100 && missed < 4; i++)
{
if (PicoCDLoadProgressCB != NULL && i > 1)
PicoCDLoadProgressCB(cd_img_name, i + (100-i)*missed/4);
for (j = 0; j < sizeof(exts)/sizeof(char *); j++)
{
int ext_len;
char *p;
index = n - 1;
snprintf(tmp_ext, sizeof(tmp_ext), exts[j], i);
ext_len = strlen(tmp_ext);
to_upper(tmp_ext_u, tmp_ext);
memcpy(tmp_name, cd_img_name, iso_name_len + 1);
p = tmp_name + iso_name_len - 4;
strcpy(p, tmp_ext);
ret = handle_mp3(tmp_name, index);
if (ret <= 0) {
strcpy(p, tmp_ext_u);
ret = handle_mp3(tmp_name, index);
}
if (ret <= 0 && i > 1 && iso_name_len > ext_len) {
p = tmp_name + iso_name_len - ext_len;
strcpy(p, tmp_ext);
ret = handle_mp3(tmp_name, index);
if (ret <= 0) {
strcpy(p, tmp_ext_u);
ret = handle_mp3(tmp_name, index);
}
}
if (ret > 0)
{
length = ret;
tracks[index].start = lba;
lba += length;
tracks[index].end = lba;
Pico_mcd->cdda_type = CT_MP3;
sprintf_lba(tmp_ext, sizeof(tmp_ext), tracks[index].start);
elprintf(EL_STATUS, "Track %2i: %s %9i AUDIO - %s",
n, tmp_ext, length, tmp_name);
n++;
missed = 0;
break;
}
}
if (ret <= 0 && i > 1)
missed++;
}
finish:
cdd.toc.last = n - 1;
cdd.toc.end = lba;
sprintf_lba(tmp_ext, sizeof(tmp_ext), cdd.toc.end);
elprintf(EL_STATUS, "End CD - %s\n", tmp_ext);
if (PicoCDLoadProgressCB != NULL)
PicoCDLoadProgressCB(cd_img_name, 100);
if (cue_data != NULL)
cue_destroy(cue_data);
return 0;
}
// vim:shiftwidth=2:ts=2:expandtab

116
waterbox/picodrive/pico/cd/cdc.c
View File

@ -130,120 +130,6 @@ void cdc_reset(void)
cdc.dma_w = 0; cdc.dma_w = 0;
} }
int cdc_context_save(uint8 *state)
{
uint8 tmp8;
int bufferptr = 0;
if (cdc.dma_w == pcm_ram_dma_w)
{
tmp8 = 1;
}
else if (cdc.dma_w == prg_ram_dma_w)
{
tmp8 = 2;
}
else if (cdc.dma_w == word_ram_0_dma_w)
{
tmp8 = 3;
}
else if (cdc.dma_w == word_ram_1_dma_w)
{
tmp8 = 4;
}
else if (cdc.dma_w == word_ram_2M_dma_w)
{
tmp8 = 5;
}
else
{
tmp8 = 0;
}
save_param(&cdc, sizeof(cdc));
save_param(&tmp8, 1);
return bufferptr;
}
int cdc_context_load(uint8 *state)
{
uint8 tmp8;
int bufferptr = 0;
load_param(&cdc, sizeof(cdc));
load_param(&tmp8, 1);
switch (tmp8)
{
case 1:
cdc.dma_w = pcm_ram_dma_w;
break;
case 2:
cdc.dma_w = prg_ram_dma_w;
break;
case 3:
cdc.dma_w = word_ram_0_dma_w;
break;
case 4:
cdc.dma_w = word_ram_1_dma_w;
break;
case 5:
cdc.dma_w = word_ram_2M_dma_w;
break;
default:
cdc.dma_w = 0;
break;
}
return bufferptr;
}
int cdc_context_load_old(uint8 *state)
{
#define old_load(v, ofs) \
memcpy(&cdc.v, state + ofs, sizeof(cdc.v))
memcpy(cdc.ram, state, 0x4000);
old_load(ifstat, 67892);
old_load(ifctrl, 67924);
old_load(dbc, 67896);
old_load(dac, 67900);
old_load(pt, 67908);
old_load(wa, 67912);
old_load(ctrl, 67928);
old_load(head[0], 67904);
old_load(stat, 67916);
cdc.dma_w = 0;
switch (Pico_mcd->s68k_regs[0x04+0] & 0x07)
{
case 4: /* PCM RAM DMA */
cdc.dma_w = pcm_ram_dma_w;
break;
case 5: /* PRG-RAM DMA */
cdc.dma_w = prg_ram_dma_w;
break;
case 7: /* WORD-RAM DMA */
if (Pico_mcd->s68k_regs[0x02+1] & 0x04)
{
if (Pico_mcd->s68k_regs[0x02+1] & 0x01)
cdc.dma_w = word_ram_0_dma_w;
else
cdc.dma_w = word_ram_1_dma_w;
}
else
{
if (Pico_mcd->s68k_regs[0x02+1] & 0x02)
cdc.dma_w = word_ram_2M_dma_w;
}
break;
}
return 0x10960; // sizeof(old_cdc)
#undef old_load
}
static void do_dma(enum dma_type type, int words_in) static void do_dma(enum dma_type type, int words_in)
{ {
int dma_addr = (Pico_mcd->s68k_regs[0x0a] << 8) | Pico_mcd->s68k_regs[0x0b]; int dma_addr = (Pico_mcd->s68k_regs[0x0a] << 8) | Pico_mcd->s68k_regs[0x0b];
@ -842,5 +728,3 @@ unsigned short cdc_host_r(void)
#endif #endif
return 0xffff; return 0xffff;
} }
// vim:shiftwidth=2:ts=2:expandtab

1470
waterbox/picodrive/pico/cd/cdd.c
View File

File diff suppressed because it is too large Load Diff

62
waterbox/picodrive/pico/cd/cdd.h
View File

@ -38,19 +38,17 @@
#ifndef _HW_CDD_ #ifndef _HW_CDD_
#define _HW_CDD_ #define _HW_CDD_
#ifdef USE_LIBTREMOR #include <stdint.h>
#include "tremor/ivorbisfile.h"
#endif
/* CDD status */ /* CDD status */
#define NO_DISC 0x00 #define NO_DISC 0x00
#define CD_PLAY 0x01 #define CD_PLAY 0x01
#define CD_SEEK 0x02 #define CD_SEEK 0x02
#define CD_SCAN 0x03 #define CD_SCAN 0x03
#define CD_READY 0x04 #define CD_READY 0x04
#define CD_OPEN 0x05 /* similar to 0x0E ? */ #define CD_OPEN 0x05 /* similar to 0x0E ? */
#define CD_STOP 0x09 #define CD_STOP 0x09
#define CD_END 0x0C #define CD_END 0x0C
/* CD blocks scanning speed */ /* CD blocks scanning speed */
#define CD_SCAN_SPEED 30 #define CD_SCAN_SPEED 30
@ -60,39 +58,35 @@
/* CD track */ /* CD track */
typedef struct typedef struct
{ {
void *fd; int start;
#ifdef USE_LIBTREMOR int end;
OggVorbis_File vf; } track_t;
#endif
int offset;
int start;
int end;
} track_t;
/* CD TOC */ /* CD TOC */
typedef struct typedef struct
{ {
int end; int end;
int last; int last;
track_t tracks[CD_MAX_TRACKS]; track_t tracks[CD_MAX_TRACKS];
} toc_t; } toc_t;
/* CDD hardware */ /* CDD hardware */
typedef struct typedef struct
{ {
uint32 cycles; uint32_t cycles;
uint32 latency; uint32_t latency;
int loaded; int loaded;
int index; int index;
int lba; int lba;
int scanOffset; int scanOffset;
int volume; int volume;
uint8 status; uint8_t status;
uint16 sectorSize; toc_t toc;
toc_t toc; int16_t audio[2];
int16 audio[2]; } cdd_t;
} cdd_t;
extern cdd_t cdd; extern cdd_t cdd;
extern void (*CDReadSector)(int lba, void *dest, int audio);
#endif #endif

35
waterbox/picodrive/pico/cd/cue.c
View File

@ -1,35 +0,0 @@
/*
* cuefile handling
* (C) notaz, 2008
*
* This work is licensed under the terms of MAME license.
* See COPYING file in the top-level directory.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cue.h"
#include "../pico_int.h"
// #define elprintf(w,f,...) printf(f "\n",##__VA_ARGS__);
#ifdef _MSC_VER
#define snprintf _snprintf
#endif
#ifdef __EPOC32__
#define snprintf(b,s,...) sprintf(b,##__VA_ARGS__)
#endif
#define BEGINS(buff,str) (strncmp(buff,str,sizeof(str)-1) == 0)
void cue_destroy(cue_data_t *data)
{
int c;
if (data == NULL) return;
for (c = data->track_count; c > 0; c--)
if (data->tracks[c].fname != NULL)
free(data->tracks[c].fname);
free(data);
}

29
waterbox/picodrive/pico/cd/cue.h
View File

@ -1,29 +0,0 @@
typedef enum
{
CT_UNKNOWN = 0,
CT_ISO = 1, /* 2048 B/sector */
CT_BIN = 2, /* 2352 B/sector */
CT_MP3 = 3,
CT_WAV = 4
} cue_track_type;
typedef struct
{
char *fname;
int pregap; /* pregap for current track */
int sector_offset; /* in current file */
int sector_xlength;
cue_track_type type;
} cue_track;
typedef struct
{
int track_count;
cue_track tracks[0];
} cue_data_t;
cue_data_t *cue_parse(const char *fname);
void cue_destroy(cue_data_t *data);

8
waterbox/picodrive/pico/cd/genplus_macros.h
View File

@ -14,11 +14,3 @@
#define READ_BYTE(BASE, ADDR) (BASE)[(ADDR)^1] #define READ_BYTE(BASE, ADDR) (BASE)[(ADDR)^1]
#define WRITE_BYTE(BASE, ADDR, VAL) (BASE)[(ADDR)^1] = (VAL) #define WRITE_BYTE(BASE, ADDR, VAL) (BASE)[(ADDR)^1] = (VAL)
#define load_param(param, size) \
memcpy(param, &state[bufferptr], size); \
bufferptr += size;
#define save_param(param, size) \
memcpy(&state[bufferptr], param, size); \
bufferptr += size;

48
waterbox/picodrive/pico/cd/gfx.c
View File

@ -127,54 +127,6 @@ void gfx_init(void)
} }
} }
int gfx_context_save(uint8 *state)
{
uint32 tmp32;
int bufferptr = 0;
//save_param(&gfx.cycles, sizeof(gfx.cycles));
//save_param(&gfx.cyclesPerLine, sizeof(gfx.cyclesPerLine));
save_param(&gfx.dotMask, sizeof(gfx.dotMask));
save_param(&gfx.stampShift, sizeof(gfx.stampShift));
save_param(&gfx.mapShift, sizeof(gfx.mapShift));
save_param(&gfx.bufferOffset, sizeof(gfx.bufferOffset));
save_param(&gfx.bufferStart, sizeof(gfx.bufferStart));
tmp32 = (uint8 *)(gfx.tracePtr) - Pico_mcd->word_ram2M;
save_param(&tmp32, 4);
tmp32 = (uint8 *)(gfx.mapPtr) - Pico_mcd->word_ram2M;
save_param(&tmp32, 4);
save_param(&gfx.y_step, sizeof(gfx.y_step));
return bufferptr;
}
int gfx_context_load(const uint8 *state)
{
uint32 tmp32;
int bufferptr = 0;
//load_param(&gfx.cycles, sizeof(gfx.cycles));
//load_param(&gfx.cyclesPerLine, sizeof(gfx.cyclesPerLine));
load_param(&gfx.dotMask, sizeof(gfx.dotMask));
load_param(&gfx.stampShift, sizeof(gfx.stampShift));
load_param(&gfx.mapShift, sizeof(gfx.mapShift));
load_param(&gfx.bufferOffset, sizeof(gfx.bufferOffset));
load_param(&gfx.bufferStart, sizeof(gfx.bufferStart));
load_param(&tmp32, 4);
gfx.tracePtr = (uint16 *)(Pico_mcd->word_ram2M + tmp32);
load_param(&tmp32, 4);
gfx.mapPtr = (uint16 *)(Pico_mcd->word_ram2M + tmp32);
load_param(&gfx.y_step, sizeof(gfx.y_step));
return bufferptr;
}
static void gfx_render(uint32 bufferIndex, uint32 width) static void gfx_render(uint32 bufferIndex, uint32 width)
{ {
uint8 pixel_in, pixel_out; uint8 pixel_in, pixel_out;

1
waterbox/picodrive/pico/media.c
View File

@ -8,7 +8,6 @@
#include <string.h> #include <string.h>
#include "pico_int.h" #include "pico_int.h"
#include "cd/cue.h"
unsigned char media_id_header[0x100]; unsigned char media_id_header[0x100];

8
waterbox/picodrive/pico/pico_int.h
View File

@ -596,9 +596,6 @@ PICO_INTERNAL void PicoMemSetupPico(void);
// cd/cdc.c // cd/cdc.c
void cdc_init(void); void cdc_init(void);
void cdc_reset(void); void cdc_reset(void);
int cdc_context_save(unsigned char *state);
int cdc_context_load(unsigned char *state);
int cdc_context_load_old(unsigned char *state);
void cdc_dma_update(void); void cdc_dma_update(void);
int cdc_decoder_update(unsigned char header[4]); int cdc_decoder_update(unsigned char header[4]);
void cdc_reg_w(unsigned char data); void cdc_reg_w(unsigned char data);
@ -607,9 +604,6 @@ unsigned short cdc_host_r(void);
// cd/cdd.c // cd/cdd.c
void cdd_reset(void); void cdd_reset(void);
int cdd_context_save(unsigned char *state);
int cdd_context_load(unsigned char *state);
int cdd_context_load_old(unsigned char *state);
void cdd_read_data(unsigned char *dst); void cdd_read_data(unsigned char *dst);
void cdd_read_audio(unsigned int samples); void cdd_read_audio(unsigned int samples);
void cdd_update(void); void cdd_update(void);
@ -622,8 +616,6 @@ int load_cd_image(const char *cd_img_name, int *type);
void gfx_init(void); void gfx_init(void);
void gfx_start(unsigned int base); void gfx_start(unsigned int base);
void gfx_update(unsigned int cycles); void gfx_update(unsigned int cycles);
int gfx_context_save(unsigned char *state);
int gfx_context_load(const unsigned char *state);
// cd/gfx_dma.c // cd/gfx_dma.c
void DmaSlowCell(unsigned int source, unsigned int a, int len, unsigned char inc); void DmaSlowCell(unsigned int source, unsigned int a, int len, unsigned char inc);

14
waterbox/picodrive/pico/sound/sound.c
View File

@ -11,7 +11,6 @@
#include "ym2612.h" #include "ym2612.h"
#include "sn76496.h" #include "sn76496.h"
#include "../pico_int.h" #include "../pico_int.h"
#include "../cd/cue.h"
#include "mix.h" #include "mix.h"
#define SIMPLE_WRITE_SOUND 0 #define SIMPLE_WRITE_SOUND 0
@ -191,7 +190,7 @@ PICO_INTERNAL void PsndDoDAC(int line_to)
// cdda // cdda
static void cdda_raw_update(int *buffer, int length) static void cdda_raw_update(int *buffer, int length)
{ {
int ret, cdda_bytes, mult = 1; /*int ret, cdda_bytes, mult = 1;
cdda_bytes = length*4; cdda_bytes = length*4;
if (PsndRate <= 22050 + 100) mult = 2; if (PsndRate <= 22050 + 100) mult = 2;
@ -210,12 +209,12 @@ static void cdda_raw_update(int *buffer, int length)
case 1: mix_16h_to_32(buffer, cdda_out_buffer, length*2); break; case 1: mix_16h_to_32(buffer, cdda_out_buffer, length*2); break;
case 2: mix_16h_to_32_s1(buffer, cdda_out_buffer, length*2); break; case 2: mix_16h_to_32_s1(buffer, cdda_out_buffer, length*2); break;
case 4: mix_16h_to_32_s2(buffer, cdda_out_buffer, length*2); break; case 4: mix_16h_to_32_s2(buffer, cdda_out_buffer, length*2); break;
} }*/
} }
void cdda_start_play(int lba_base, int lba_offset, int lb_len) void cdda_start_play(int lba_base, int lba_offset, int lb_len)
{ {
if (Pico_mcd->cdda_type == CT_MP3) /*if (Pico_mcd->cdda_type == CT_MP3)
{ {
int pos1024 = 0; int pos1024 = 0;
@ -231,7 +230,7 @@ void cdda_start_play(int lba_base, int lba_offset, int lb_len)
{ {
// skip headers, assume it's 44kHz stereo uncompressed // skip headers, assume it's 44kHz stereo uncompressed
pm_seek(Pico_mcd->cdda_stream, 44, SEEK_CUR); pm_seek(Pico_mcd->cdda_stream, 44, SEEK_CUR);
} }*/
} }
@ -302,10 +301,7 @@ static int PsndRender(int offset, int length)
&& !(Pico_mcd->s68k_regs[0x36] & 1)) && !(Pico_mcd->s68k_regs[0x36] & 1))
{ {
// note: only 44, 22 and 11 kHz supported, with forced stereo // note: only 44, 22 and 11 kHz supported, with forced stereo
if (Pico_mcd->cdda_type == CT_MP3) cdda_raw_update(buf32, length);
mp3_update(buf32, length, stereo);
else
cdda_raw_update(buf32, length);
} }
if ((PicoAHW & PAHW_32X) && (PicoOpt & POPT_EN_PWM)) if ((PicoAHW & PAHW_32X) && (PicoOpt & POPT_EN_PWM))