371 lines
13 KiB
C#
371 lines
13 KiB
C#
//TODO:
|
|
//"The first index of a file must start at 00:00:00" - if this isnt the case, we'll be doing nonsense for sure. so catch it
|
|
//Recover the idea of TOCPoints maybe, as it's a more flexible way of generating the structure.
|
|
|
|
//TODO
|
|
//check for flags changing after a PREGAP is processed. the PREGAP can't correctly run if the flags aren't set
|
|
//IN GENERAL: validate more pedantically (but that code gets in the way majorly)
|
|
// - perhaps isolate validation checks into a different pass distinct from a Burn pass
|
|
|
|
//NEW IDEA:
|
|
//a cue file is a compressed representation of a more verbose format which is easier to understand
|
|
//most fundamentally, it is organized with TRACK and INDEX commands alternating.
|
|
//these should be flattened into individual records with CURRTRACK and CURRINDEX fields.
|
|
//more generally, it's organized with 'register' settings and INDEX commands alternating.
|
|
//whenever an INDEX command is received from the cue file, individual flattened records are written with the current 'register' settings
|
|
//and an incrementing timestamp until the INDEX command appears (or the EOF happens)
|
|
//PREGAP commands are special : at the moment it is received, emit flat records with a different pregap structure
|
|
//POSTGAP commands are special : TBD
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
|
|
namespace BizHawk.Emulation.DiscSystem
|
|
{
|
|
partial class CUE_Format2
|
|
{
|
|
/// <summary>
|
|
/// Loads a cue file into a Disc.
|
|
/// For this job, virtually all nonsense input is treated as errors, but the process will try to recover as best it can.
|
|
/// The user should still reject any jobs which generated errors
|
|
/// </summary>
|
|
internal class LoadCueJob : LoggedJob
|
|
{
|
|
/// <summary>
|
|
/// The results of the compile job, a prerequisite for this
|
|
/// </summary>
|
|
public CompileCueJob IN_CompileJob;
|
|
|
|
/// <summary>
|
|
/// The resulting disc
|
|
/// </summary>
|
|
public Disc OUT_Disc;
|
|
|
|
private enum BurnType
|
|
{
|
|
Normal, Pregap, Postgap
|
|
}
|
|
|
|
class BlobInfo
|
|
{
|
|
public IBlob Blob;
|
|
public long Length;
|
|
}
|
|
|
|
//not sure if we need this...
|
|
class TrackInfo
|
|
{
|
|
public int Length;
|
|
|
|
public CompiledCueTrack CompiledCueTrack;
|
|
}
|
|
|
|
List<BlobInfo> BlobInfos;
|
|
List<TrackInfo> TrackInfos = new List<TrackInfo>();
|
|
|
|
|
|
void MountBlobs()
|
|
{
|
|
IBlob file_blob = null;
|
|
long file_len = 0;
|
|
|
|
BlobInfos = new List<BlobInfo>();
|
|
foreach (var ccf in IN_CompileJob.OUT_CompiledCueFiles)
|
|
{
|
|
var bi = new BlobInfo();
|
|
BlobInfos.Add(bi);
|
|
|
|
switch (ccf.Type)
|
|
{
|
|
case CompiledCueFileType.BIN:
|
|
case CompiledCueFileType.Unknown:
|
|
{
|
|
//raw files:
|
|
var blob = new Disc.Blob_RawFile { PhysicalPath = ccf.FullPath };
|
|
OUT_Disc.DisposableResources.Add(file_blob = blob);
|
|
bi.Length = blob.Length;
|
|
break;
|
|
}
|
|
case CompiledCueFileType.ECM:
|
|
{
|
|
var blob = new Disc.Blob_ECM();
|
|
OUT_Disc.DisposableResources.Add(file_blob = blob);
|
|
blob.Load(ccf.FullPath);
|
|
bi.Length = blob.Length;
|
|
break;
|
|
}
|
|
case CompiledCueFileType.WAVE:
|
|
{
|
|
var blob = new Disc.Blob_WaveFile();
|
|
OUT_Disc.DisposableResources.Add(file_blob = blob);
|
|
blob.Load(ccf.FullPath);
|
|
bi.Length = blob.Length;
|
|
break;
|
|
}
|
|
case CompiledCueFileType.DecodeAudio:
|
|
{
|
|
FFMpeg ffmpeg = new FFMpeg();
|
|
if (!ffmpeg.QueryServiceAvailable())
|
|
{
|
|
throw new DiscReferenceException(ccf.FullPath, "No decoding service was available (make sure ffmpeg.exe is available. even though this may be a wav, ffmpeg is used to load oddly formatted wave files. If you object to this, please send us a note and we'll see what we can do. It shouldn't be too hard.)");
|
|
}
|
|
AudioDecoder dec = new AudioDecoder();
|
|
byte[] buf = dec.AcquireWaveData(ccf.FullPath);
|
|
var blob = new Disc.Blob_WaveFile();
|
|
OUT_Disc.DisposableResources.Add(file_blob = blob);
|
|
blob.Load(new MemoryStream(buf));
|
|
bi.Length = buf.Length;
|
|
break;
|
|
}
|
|
default:
|
|
throw new InvalidOperationException();
|
|
} //switch(file type)
|
|
|
|
//wrap all the blobs with zero padding
|
|
bi.Blob = new Disc.Blob_ZeroPadAdapter(file_blob, bi.Length);
|
|
}
|
|
}
|
|
|
|
|
|
void AnalyzeTracks()
|
|
{
|
|
var compiledTracks = IN_CompileJob.OUT_CompiledCueTracks;
|
|
|
|
for(int t=0;t<compiledTracks.Count;t++)
|
|
{
|
|
var cct = compiledTracks[t];
|
|
|
|
var ti = new TrackInfo() { CompiledCueTrack = cct };
|
|
TrackInfos.Add(ti);
|
|
|
|
//OH NO! CANT DO THIS!
|
|
//need to read sectors from file to reliably know its ending size.
|
|
//could determine it from file mode.
|
|
//do we really need this?
|
|
//if (cct.IsFinalInFile)
|
|
//{
|
|
// //length is determined from length of file
|
|
|
|
//}
|
|
}
|
|
}
|
|
|
|
void EmitRawTOCEntry(CompiledCueTrack cct)
|
|
{
|
|
SubchannelQ toc_sq = new SubchannelQ();
|
|
//absent some kind of policy for how to set it, this is a safe assumption:
|
|
byte toc_ADR = 1;
|
|
toc_sq.SetStatus(toc_ADR, (EControlQ)(int)cct.Flags);
|
|
toc_sq.q_tno.BCDValue = 0; //kind of a little weird here.. the track number becomes the 'point' and put in the index instead. 0 is the track number here.
|
|
toc_sq.q_index = BCD2.FromDecimal(cct.Number);
|
|
//not too sure about these yet
|
|
toc_sq.min = BCD2.FromDecimal(0);
|
|
toc_sq.sec = BCD2.FromDecimal(0);
|
|
toc_sq.frame = BCD2.FromDecimal(0);
|
|
toc_sq.AP_Timestamp = new Timestamp(OUT_Disc.Sectors.Count);
|
|
OUT_Disc.RawTOCEntries.Add(new RawTOCEntry { QData = toc_sq });
|
|
}
|
|
|
|
public void Run()
|
|
{
|
|
//params
|
|
var compiled = IN_CompileJob;
|
|
OUT_Disc = new Disc();
|
|
|
|
//generation state
|
|
int curr_index;
|
|
int curr_blobIndex = -1;
|
|
int curr_blobMSF = -1;
|
|
BlobInfo curr_blobInfo = null;
|
|
long curr_blobOffset = -1;
|
|
|
|
//mount all input files
|
|
MountBlobs();
|
|
|
|
//unhappily, we cannot determine the length of all the tracks without knowing the length of the files
|
|
//now that the files are mounted, we can figure the track lengths
|
|
AnalyzeTracks();
|
|
|
|
//loop from track 1 to 99
|
|
//(track 0 isnt handled yet, that's way distant work)
|
|
for (int t = 1; t < TrackInfos.Count; t++)
|
|
{
|
|
TrackInfo ti = TrackInfos[t];
|
|
CompiledCueTrack cct = ti.CompiledCueTrack;
|
|
|
|
//---------------------------------
|
|
//generate track pregap
|
|
//per "Example 05" on digitalx.org, pregap can come from index specification and pregap command
|
|
int specifiedPregapLength = cct.PregapLength.Sector;
|
|
int impliedPregapLength = cct.Indexes[1].FileMSF.Sector - cct.Indexes[0].FileMSF.Sector;
|
|
//total pregap is needed for subQ addressing of the entire pregap area
|
|
int totalPregapLength = specifiedPregapLength + impliedPregapLength;
|
|
for (int s = 0; s < specifiedPregapLength; s++)
|
|
{
|
|
//TODO - do a better job synthesizing
|
|
var zero_sector = new Sector_Zero();
|
|
var zero_subSector = new ZeroSubcodeSector();
|
|
var se_pregap = new SectorEntry(zero_sector);
|
|
se_pregap.SubcodeSector = zero_subSector;
|
|
se_pregap.SectorSynth = new SS_Mode1_2048();
|
|
OUT_Disc.Sectors.Add(se_pregap);
|
|
}
|
|
|
|
//after this, pregap sectors are generated like a normal sector, but the subQ is specified as a pregap instead of a normal track
|
|
//---------------------------------
|
|
|
|
|
|
//---------------------------------
|
|
//generate sectors for this track.
|
|
|
|
//advance to the next file if needed
|
|
if (curr_blobIndex != cct.BlobIndex)
|
|
{
|
|
curr_blobIndex = cct.BlobIndex;
|
|
curr_blobOffset = 0;
|
|
curr_blobMSF = 0;
|
|
curr_blobInfo = BlobInfos[curr_blobIndex];
|
|
}
|
|
|
|
//work until the next track is reached, or the end of the current file is reached, depending on the track type
|
|
curr_index = 0;
|
|
for (; ; )
|
|
{
|
|
bool trackDone = false;
|
|
|
|
//select the appropriate index by inspecting the next index and seeing if we've reached it
|
|
for (; ; )
|
|
{
|
|
if (curr_index == cct.Indexes.Count - 1)
|
|
break;
|
|
if (curr_blobMSF >= cct.Indexes[curr_index + 1].FileMSF.Sector)
|
|
{
|
|
curr_index++;
|
|
if (curr_index == 1)
|
|
{
|
|
//WE ARE NOW AT INDEX 1: generate the RawTOCEntry for this track
|
|
EmitRawTOCEntry(cct);
|
|
}
|
|
}
|
|
else break;
|
|
}
|
|
|
|
//generate a sector:
|
|
SS_Base ss = null;
|
|
switch (cct.TrackType)
|
|
{
|
|
case CueFile.TrackType.Mode2_2352:
|
|
case CueFile.TrackType.Audio:
|
|
ss = new SS_2352() { Blob = curr_blobInfo.Blob, BlobOffset = curr_blobOffset };
|
|
curr_blobOffset += 2352;
|
|
break;
|
|
}
|
|
|
|
//make the subcode
|
|
//TODO - according to policies, or better yet, defer this til it's needed (user delivers a policies object to disc reader apis)
|
|
//at any rate, we'd paste this logic into there so let's go ahead and write it here
|
|
var subcode = new BufferedSubcodeSector(); //(its lame that we have to use this; make a static method when we delete this class)
|
|
SubchannelQ sq = new SubchannelQ();
|
|
byte ADR = 1; //absent some kind of policy for how to set it, this is a safe assumption:
|
|
sq.SetStatus(ADR, (EControlQ)(int)cct.Flags);
|
|
sq.q_tno = BCD2.FromDecimal(cct.Number);
|
|
sq.q_index = BCD2.FromDecimal(curr_index);
|
|
int LBA = OUT_Disc.Sectors.Count;
|
|
sq.ap_min = BCD2.FromDecimal(new Timestamp(LBA).MIN);
|
|
sq.ap_sec = BCD2.FromDecimal(new Timestamp(LBA).SEC);
|
|
sq.ap_frame = BCD2.FromDecimal(new Timestamp(LBA).FRAC);
|
|
int track_relative_msf = curr_blobMSF - cct.Indexes[1].FileMSF.Sector;
|
|
sq.min = BCD2.FromDecimal(new Timestamp(track_relative_msf).MIN);
|
|
sq.sec = BCD2.FromDecimal(new Timestamp(track_relative_msf).SEC);
|
|
sq.frame = BCD2.FromDecimal(new Timestamp(track_relative_msf).FRAC);
|
|
//finally we're done: synthesize subchannel
|
|
subcode.Synthesize_SubchannelQ(ref sq, true);
|
|
|
|
//make the SectorEntry (some temporary bullshit here)
|
|
var se = new SectorEntry(null);
|
|
se.SectorSynth = ss;
|
|
ss.sq = sq;
|
|
OUT_Disc.Sectors.Add(se);
|
|
curr_blobMSF++;
|
|
|
|
if (cct.IsFinalInFile)
|
|
{
|
|
//sometimes, break when the file is exhausted
|
|
if (curr_blobOffset >= curr_blobInfo.Length)
|
|
trackDone = true;
|
|
}
|
|
else
|
|
{
|
|
//other times, break when the track is done
|
|
//(this check is safe because it's not the final track overall if it's not the final track in a file)
|
|
if (curr_blobMSF >= TrackInfos[t + 1].CompiledCueTrack.Indexes[0].FileMSF.Sector)
|
|
trackDone = true;
|
|
}
|
|
|
|
if (trackDone)
|
|
break;
|
|
}
|
|
|
|
//TODO - POSTGAP
|
|
|
|
} //end track loop
|
|
|
|
|
|
//add RawTOCEntries A0 A1 A2 to round out the TOC
|
|
var TOCMiscInfo = new Synthesize_A0A1A2_Job {
|
|
IN_FirstRecordedTrackNumber = IN_CompileJob.OUT_CompiledDiscInfo.FirstRecordedTrackNumber,
|
|
IN_LastRecordedTrackNumber = IN_CompileJob.OUT_CompiledDiscInfo.LastRecordedTrackNumber,
|
|
IN_Session1Format = IN_CompileJob.OUT_CompiledDiscInfo.SessionFormat,
|
|
IN_LeadoutTimestamp = new Timestamp(OUT_Disc.Sectors.Count) //do we need a +150?
|
|
};
|
|
TOCMiscInfo.Run(OUT_Disc.RawTOCEntries);
|
|
|
|
//generate the TOCRaw from the RawTocEntries
|
|
var tocSynth = new DiscTOCRaw.SynthesizeFromRawTOCEntriesJob() { Entries = OUT_Disc.RawTOCEntries };
|
|
tocSynth.Run();
|
|
OUT_Disc.TOCRaw = tocSynth.Result;
|
|
|
|
////generate lead-out track with some canned number of sectors
|
|
////TODO - move this somewhere else and make it controllable depending on which console is loading up the disc
|
|
////TODO - we're not doing this yet
|
|
////var synthLeadoutJob = new Disc.SynthesizeLeadoutJob { Disc = disc, Length = 150 };
|
|
////synthLeadoutJob.Run();
|
|
|
|
////blech, old crap, maybe
|
|
//OUT_Disc.Structure.Synthesize_TOCPointsFromSessions();
|
|
|
|
//FinishLog();
|
|
|
|
} //Run()
|
|
} //class LoadCueJob
|
|
} //partial class CUE_Format2
|
|
} //namespace BizHawk.Emulation.DiscSystem
|
|
|
|
|
|
|
|
|
|
//TODO:
|
|
//if (index_num == 0 || type == SectorWriteType.Pregap)
|
|
//{
|
|
// //PREGAP:
|
|
// //things are negative here.
|
|
// if (track_relative_msf > 0) throw new InvalidOperationException("Perplexing internal error with non-negative pregap MSF");
|
|
// track_relative_msf = -track_relative_msf;
|
|
|
|
// //now for something special.
|
|
// //yellow-book says:
|
|
// //pre-gap for "first part of a digital data track not containing user data and encoded as a pause"
|
|
// //first interval: at least 75 sectors coded as preceding track
|
|
// //second interval: at least 150 sectors coded as user data track.
|
|
// //so... we ASSUME the 150 sector pregap is more important. so if thats all there is, theres no 75 sector pregap like the old track
|
|
// //if theres a longer pregap, then we generate weird old track pregap to contain the rest.
|
|
// if (track_relative_msf > 150)
|
|
// {
|
|
// //only if we're burning a data track now
|
|
// if((track_flags & CueFile.TrackFlags.DATA)!=0)
|
|
// sq.q_status = priorSubchannelQ.q_status;
|
|
// }
|
|
//} |