mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
1200 lines
57 KiB
C#
1200 lines
57 KiB
C#
// /***************************************************************************
|
|
// The Disc Image Chef
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : DiscJuggler.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Disc image plugins.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Manages DiscJuggler disc images.
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as
|
|
// published by the Free Software Foundation; either version 2.1 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2018 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using DiscImageChef.Checksums;
|
|
using DiscImageChef.CommonTypes;
|
|
using DiscImageChef.CommonTypes.Enums;
|
|
using DiscImageChef.CommonTypes.Exceptions;
|
|
using DiscImageChef.CommonTypes.Interfaces;
|
|
using DiscImageChef.CommonTypes.Structs;
|
|
using DiscImageChef.Console;
|
|
using Schemas;
|
|
using TrackType = DiscImageChef.CommonTypes.Enums.TrackType;
|
|
|
|
namespace DiscImageChef.DiscImages
|
|
{
|
|
// Support separate data files? Never seen a DiscJuggler image using them anyways...
|
|
// TODO: Too many unknowns to make this writable
|
|
public class DiscJuggler : IMediaImage
|
|
{
|
|
byte[] cdtext;
|
|
ImageInfo imageInfo;
|
|
Stream imageStream;
|
|
Dictionary<uint, ulong> offsetmap;
|
|
Dictionary<uint, byte> trackFlags;
|
|
|
|
public DiscJuggler()
|
|
{
|
|
imageInfo = new ImageInfo
|
|
{
|
|
ReadableSectorTags = new List<SectorTagType>(),
|
|
ReadableMediaTags = new List<MediaTagType>(),
|
|
HasPartitions = true,
|
|
HasSessions = true,
|
|
Version = null,
|
|
ApplicationVersion = null,
|
|
MediaTitle = null,
|
|
Creator = null,
|
|
MediaManufacturer = null,
|
|
MediaModel = null,
|
|
MediaPartNumber = null,
|
|
MediaSequence = 0,
|
|
LastMediaSequence = 0,
|
|
DriveManufacturer = null,
|
|
DriveModel = null,
|
|
DriveSerialNumber = null,
|
|
DriveFirmwareRevision = null
|
|
};
|
|
}
|
|
|
|
public string Name => "DiscJuggler";
|
|
public Guid Id => new Guid("2444DBC6-CD35-424C-A227-39B0C4DB01B2");
|
|
public ImageInfo Info => imageInfo;
|
|
|
|
public string Format => "DiscJuggler";
|
|
|
|
public List<Partition> Partitions { get; private set; }
|
|
|
|
public List<Track> Tracks { get; private set; }
|
|
|
|
public List<Session> Sessions { get; private set; }
|
|
|
|
public bool Identify(IFilter imageFilter)
|
|
{
|
|
imageStream = imageFilter.GetDataForkStream();
|
|
|
|
imageStream.Seek(-4, SeekOrigin.End);
|
|
byte[] dscLenB = new byte[4];
|
|
imageStream.Read(dscLenB, 0, 4);
|
|
int dscLen = BitConverter.ToInt32(dscLenB, 0);
|
|
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "dscLen = {0}", dscLen);
|
|
|
|
if(dscLen >= imageStream.Length) return false;
|
|
|
|
byte[] descriptor = new byte[dscLen];
|
|
imageStream.Seek(-dscLen, SeekOrigin.End);
|
|
imageStream.Read(descriptor, 0, dscLen);
|
|
|
|
// Sessions
|
|
if(descriptor[0] > 99 || descriptor[0] == 0) return false;
|
|
|
|
// Seems all sessions start with this data
|
|
if(descriptor[1] != 0x00 || descriptor[3] != 0x00 || descriptor[4] != 0x00 || descriptor[5] != 0x00 ||
|
|
descriptor[6] != 0x00 || descriptor[7] != 0x00 || descriptor[8] != 0x00 || descriptor[9] != 0x00 ||
|
|
descriptor[10] != 0x01 || descriptor[11] != 0x00 || descriptor[12] != 0x00 || descriptor[13] != 0x00 ||
|
|
descriptor[14] != 0xFF || descriptor[15] != 0xFF) return false;
|
|
|
|
// Too many tracks
|
|
return descriptor[2] <= 99;
|
|
}
|
|
|
|
public bool Open(IFilter imageFilter)
|
|
{
|
|
imageStream = imageFilter.GetDataForkStream();
|
|
|
|
imageStream.Seek(-4, SeekOrigin.End);
|
|
byte[] dscLenB = new byte[4];
|
|
imageStream.Read(dscLenB, 0, 4);
|
|
int dscLen = BitConverter.ToInt32(dscLenB, 0);
|
|
|
|
if(dscLen >= imageStream.Length) return false;
|
|
|
|
byte[] descriptor = new byte[dscLen];
|
|
imageStream.Seek(-dscLen, SeekOrigin.End);
|
|
imageStream.Read(descriptor, 0, dscLen);
|
|
|
|
// Sessions
|
|
if(descriptor[0] > 99 || descriptor[0] == 0) return false;
|
|
|
|
int position = 1;
|
|
|
|
ushort sessionSequence = 0;
|
|
Sessions = new List<Session>();
|
|
Tracks = new List<Track>();
|
|
Partitions = new List<Partition>();
|
|
offsetmap = new Dictionary<uint, ulong>();
|
|
trackFlags = new Dictionary<uint, byte>();
|
|
ushort mediumType;
|
|
byte maxS = descriptor[0];
|
|
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "maxS = {0}", maxS);
|
|
uint lastSessionTrack = 0;
|
|
ulong currentOffset = 0;
|
|
|
|
// Read sessions
|
|
for(byte s = 0; s <= maxS; s++)
|
|
{
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "s = {0}", s);
|
|
|
|
// Seems all sessions start with this data
|
|
if(descriptor[position + 0] != 0x00 || descriptor[position + 2] != 0x00 ||
|
|
descriptor[position + 3] != 0x00 || descriptor[position + 4] != 0x00 ||
|
|
descriptor[position + 5] != 0x00 || descriptor[position + 6] != 0x00 ||
|
|
descriptor[position + 7] != 0x00 || descriptor[position + 8] != 0x00 ||
|
|
descriptor[position + 9] != 0x01 || descriptor[position + 10] != 0x00 ||
|
|
descriptor[position + 11] != 0x00 || descriptor[position + 12] != 0x00 ||
|
|
descriptor[position + 13] != 0xFF || descriptor[position + 14] != 0xFF) return false;
|
|
|
|
// Too many tracks
|
|
if(descriptor[position + 1] > 99) return false;
|
|
|
|
byte maxT = descriptor[position + 1];
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "maxT = {0}", maxT);
|
|
|
|
sessionSequence++;
|
|
Session session = new Session
|
|
{
|
|
SessionSequence = sessionSequence,
|
|
EndTrack = uint.MinValue,
|
|
StartTrack = uint.MaxValue
|
|
};
|
|
|
|
position += 15;
|
|
bool addedATrack = false;
|
|
|
|
// Read track
|
|
for(byte t = 0; t < maxT; t++)
|
|
{
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "t = {0}", t);
|
|
Track track = new Track();
|
|
|
|
// Skip unknown
|
|
position += 16;
|
|
|
|
byte[] trackFilenameB = new byte[descriptor[position]];
|
|
position++;
|
|
Array.Copy(descriptor, position, trackFilenameB, 0, trackFilenameB.Length);
|
|
position += trackFilenameB.Length;
|
|
track.TrackFile = Path.GetFileName(Encoding.Default.GetString(trackFilenameB));
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tfilename = {0}", track.TrackFile);
|
|
|
|
// Skip unknown
|
|
position += 29;
|
|
|
|
mediumType = BitConverter.ToUInt16(descriptor, position);
|
|
position += 2;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tmediumType = {0}", mediumType);
|
|
|
|
// Read indices
|
|
track.Indexes = new Dictionary<int, ulong>();
|
|
ushort maxI = BitConverter.ToUInt16(descriptor, position);
|
|
position += 2;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tmaxI = {0}", maxI);
|
|
for(ushort i = 0; i < maxI; i++)
|
|
{
|
|
uint index = BitConverter.ToUInt32(descriptor, position);
|
|
track.Indexes.Add(i, index);
|
|
position += 4;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tindex[{1}] = {0}", index, i);
|
|
}
|
|
|
|
// Read CD-Text
|
|
uint maxC = BitConverter.ToUInt32(descriptor, position);
|
|
position += 4;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tmaxC = {0}", maxC);
|
|
for(uint c = 0; c < maxC; c++)
|
|
{
|
|
for(int cb = 0; cb < 18; cb++)
|
|
{
|
|
int bLen = descriptor[position];
|
|
position++;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tc[{1}][{2}].Length = {0}", bLen, c, cb);
|
|
if(bLen <= 0) continue;
|
|
|
|
byte[] textBlk = new byte[bLen];
|
|
Array.Copy(descriptor, position, textBlk, 0, bLen);
|
|
position += bLen;
|
|
// Track title
|
|
if(cb != 10) continue;
|
|
|
|
track.TrackDescription = Encoding.Default.GetString(textBlk, 0, bLen);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tTrack title = {0}",
|
|
track.TrackDescription);
|
|
}
|
|
}
|
|
|
|
position += 2;
|
|
uint trackMode = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\ttrackMode = {0}", trackMode);
|
|
position += 4;
|
|
|
|
// Skip unknown
|
|
position += 4;
|
|
|
|
session.SessionSequence = (ushort)(BitConverter.ToUInt32(descriptor, position) + 1);
|
|
track.TrackSession = (ushort)(session.SessionSequence + 1);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tsession = {0}", session.SessionSequence);
|
|
position += 4;
|
|
track.TrackSequence = BitConverter.ToUInt32(descriptor, position) + lastSessionTrack + 1;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\ttrack = {1} + {2} + 1 = {0}",
|
|
track.TrackSequence, BitConverter.ToUInt32(descriptor, position),
|
|
lastSessionTrack);
|
|
position += 4;
|
|
track.TrackStartSector = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\ttrackStart = {0}", track.TrackStartSector);
|
|
position += 4;
|
|
uint trackLen = BitConverter.ToUInt32(descriptor, position);
|
|
track.TrackEndSector = track.TrackStartSector + trackLen - 1;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\ttrackEnd = {0}", track.TrackEndSector);
|
|
position += 4;
|
|
|
|
if(track.TrackSequence > session.EndTrack)
|
|
{
|
|
session.EndTrack = track.TrackSequence;
|
|
session.EndSector = track.TrackEndSector;
|
|
}
|
|
|
|
if(track.TrackSequence < session.StartTrack)
|
|
{
|
|
session.StartTrack = track.TrackSequence;
|
|
session.StartSector = track.TrackStartSector;
|
|
}
|
|
|
|
// Skip unknown
|
|
position += 16;
|
|
|
|
uint readMode = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\treadMode = {0}", readMode);
|
|
position += 4;
|
|
uint trackCtl = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\ttrackCtl = {0}", trackCtl);
|
|
position += 4;
|
|
|
|
// Skip unknown
|
|
position += 9;
|
|
|
|
byte[] isrc = new byte[12];
|
|
Array.Copy(descriptor, position, isrc, 0, 12);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tisrc = {0}", StringHandlers.CToString(isrc));
|
|
position += 12;
|
|
uint isrcValid = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tisrc_valid = {0}", isrcValid);
|
|
position += 4;
|
|
|
|
// Skip unknown
|
|
position += 87;
|
|
|
|
byte sessionType = descriptor[position];
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tsessionType = {0}", sessionType);
|
|
position++;
|
|
|
|
// Skip unknown
|
|
position += 5;
|
|
|
|
byte trackFollows = descriptor[position];
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\ttrackFollows = {0}", trackFollows);
|
|
position += 2;
|
|
|
|
uint endAddress = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tendAddress = {0}", endAddress);
|
|
position += 4;
|
|
|
|
// As to skip the lead-in
|
|
bool firstTrack = currentOffset == 0;
|
|
|
|
track.TrackSubchannelType = TrackSubchannelType.None;
|
|
|
|
switch(trackMode)
|
|
{
|
|
// Audio
|
|
case 0:
|
|
if(imageInfo.SectorSize < 2352) imageInfo.SectorSize = 2352;
|
|
track.TrackType = TrackType.Audio;
|
|
track.TrackBytesPerSector = 2352;
|
|
track.TrackRawBytesPerSector = 2352;
|
|
switch(readMode)
|
|
{
|
|
case 2:
|
|
if(firstTrack) currentOffset += 150 * (ulong)track.TrackRawBytesPerSector;
|
|
track.TrackFileOffset = currentOffset;
|
|
currentOffset += trackLen * (ulong)track.TrackRawBytesPerSector;
|
|
break;
|
|
case 3:
|
|
if(firstTrack) currentOffset += 150 * (ulong)(track.TrackRawBytesPerSector + 16);
|
|
track.TrackFileOffset = currentOffset;
|
|
track.TrackSubchannelFile = track.TrackFile;
|
|
track.TrackSubchannelOffset = currentOffset;
|
|
track.TrackSubchannelType = TrackSubchannelType.Q16Interleaved;
|
|
currentOffset +=
|
|
trackLen * (ulong)(track.TrackRawBytesPerSector + 16);
|
|
break;
|
|
case 4:
|
|
if(firstTrack) currentOffset += 150 * (ulong)(track.TrackRawBytesPerSector + 96);
|
|
track.TrackFileOffset = currentOffset;
|
|
track.TrackSubchannelFile = track.TrackFile;
|
|
track.TrackSubchannelOffset = currentOffset;
|
|
track.TrackSubchannelType = TrackSubchannelType.RawInterleaved;
|
|
currentOffset +=
|
|
trackLen * (ulong)(track.TrackRawBytesPerSector + 96);
|
|
break;
|
|
default: throw new ImageNotSupportedException($"Unknown read mode {readMode}");
|
|
}
|
|
|
|
break;
|
|
// Mode 1 or DVD
|
|
case 1:
|
|
if(imageInfo.SectorSize < 2048) imageInfo.SectorSize = 2048;
|
|
track.TrackType = TrackType.CdMode1;
|
|
track.TrackBytesPerSector = 2048;
|
|
switch(readMode)
|
|
{
|
|
case 0:
|
|
track.TrackRawBytesPerSector = 2048;
|
|
if(firstTrack) currentOffset += 150 * (ulong)track.TrackRawBytesPerSector;
|
|
track.TrackFileOffset = currentOffset;
|
|
currentOffset += trackLen * (ulong)track.TrackRawBytesPerSector;
|
|
break;
|
|
case 1:
|
|
throw
|
|
new ImageNotSupportedException($"Invalid read mode {readMode} for this track");
|
|
case 2:
|
|
track.TrackRawBytesPerSector = 2352;
|
|
currentOffset += trackLen * (ulong)track.TrackRawBytesPerSector;
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEcc))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEcc);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccP))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccP);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccQ))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccQ);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEdc))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEdc);
|
|
break;
|
|
case 3:
|
|
track.TrackRawBytesPerSector = 2352;
|
|
if(firstTrack) currentOffset += 150 * (ulong)(track.TrackRawBytesPerSector + 16);
|
|
track.TrackFileOffset = currentOffset;
|
|
track.TrackSubchannelFile = track.TrackFile;
|
|
track.TrackSubchannelOffset = currentOffset;
|
|
track.TrackSubchannelType = TrackSubchannelType.Q16Interleaved;
|
|
currentOffset +=
|
|
trackLen * (ulong)(track.TrackRawBytesPerSector + 16);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEcc))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEcc);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccP))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccP);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccQ))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccQ);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEdc))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEdc);
|
|
break;
|
|
case 4:
|
|
track.TrackRawBytesPerSector = 2352;
|
|
if(firstTrack) currentOffset += 150 * (ulong)(track.TrackRawBytesPerSector + 96);
|
|
track.TrackFileOffset = currentOffset;
|
|
track.TrackSubchannelFile = track.TrackFile;
|
|
track.TrackSubchannelOffset = currentOffset;
|
|
track.TrackSubchannelType = TrackSubchannelType.RawInterleaved;
|
|
currentOffset +=
|
|
trackLen * (ulong)(track.TrackRawBytesPerSector + 96);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEcc))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEcc);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccP))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccP);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccQ))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccQ);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEdc))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEdc);
|
|
break;
|
|
default: throw new ImageNotSupportedException($"Unknown read mode {readMode}");
|
|
}
|
|
|
|
break;
|
|
// Mode 2
|
|
case 2:
|
|
if(imageInfo.SectorSize < 2336) imageInfo.SectorSize = 2336;
|
|
track.TrackType = TrackType.CdMode2Formless;
|
|
track.TrackBytesPerSector = 2336;
|
|
switch(readMode)
|
|
{
|
|
case 0:
|
|
throw
|
|
new ImageNotSupportedException($"Invalid read mode {readMode} for this track");
|
|
case 1:
|
|
track.TrackRawBytesPerSector = 2336;
|
|
if(firstTrack) currentOffset += 150 * (ulong)track.TrackRawBytesPerSector;
|
|
track.TrackFileOffset = currentOffset;
|
|
currentOffset += trackLen * (ulong)track.TrackRawBytesPerSector;
|
|
break;
|
|
case 2:
|
|
track.TrackRawBytesPerSector = 2352;
|
|
currentOffset += trackLen * (ulong)track.TrackRawBytesPerSector;
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
|
|
break;
|
|
case 3:
|
|
track.TrackRawBytesPerSector = 2352;
|
|
if(firstTrack) currentOffset += 150 * (ulong)(track.TrackRawBytesPerSector + 16);
|
|
track.TrackFileOffset = currentOffset;
|
|
track.TrackSubchannelFile = track.TrackFile;
|
|
track.TrackSubchannelOffset = currentOffset;
|
|
track.TrackSubchannelType = TrackSubchannelType.Q16Interleaved;
|
|
currentOffset +=
|
|
trackLen * (ulong)(track.TrackRawBytesPerSector + 16);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
|
|
break;
|
|
case 4:
|
|
track.TrackRawBytesPerSector = 2352;
|
|
if(firstTrack) currentOffset += 150 * (ulong)(track.TrackRawBytesPerSector + 96);
|
|
track.TrackFileOffset = currentOffset;
|
|
track.TrackSubchannelFile = track.TrackFile;
|
|
track.TrackSubchannelOffset = currentOffset;
|
|
track.TrackSubchannelType = TrackSubchannelType.RawInterleaved;
|
|
currentOffset +=
|
|
trackLen * (ulong)(track.TrackRawBytesPerSector + 96);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
|
|
break;
|
|
default: throw new ImageNotSupportedException($"Unknown read mode {readMode}");
|
|
}
|
|
|
|
break;
|
|
default: throw new ImageNotSupportedException($"Unknown track mode {trackMode}");
|
|
}
|
|
|
|
track.TrackFile = imageFilter.GetFilename();
|
|
track.TrackFilter = imageFilter;
|
|
if(track.TrackSubchannelType != TrackSubchannelType.None)
|
|
{
|
|
track.TrackSubchannelFile = imageFilter.GetFilename();
|
|
track.TrackSubchannelFilter = imageFilter;
|
|
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
|
|
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubchannel);
|
|
}
|
|
|
|
Partition partition = new Partition
|
|
{
|
|
Description = track.TrackDescription,
|
|
Size = (ulong)(trackLen * track.TrackBytesPerSector),
|
|
Length = trackLen,
|
|
Sequence = track.TrackSequence,
|
|
Offset = track.TrackFileOffset,
|
|
Start = track.TrackStartSector,
|
|
Type = track.TrackType.ToString()
|
|
};
|
|
imageInfo.Sectors += partition.Length;
|
|
Partitions.Add(partition);
|
|
offsetmap.Add(track.TrackSequence, track.TrackStartSector);
|
|
Tracks.Add(track);
|
|
trackFlags.Add(track.TrackSequence, (byte)(trackCtl & 0xFF));
|
|
addedATrack = true;
|
|
}
|
|
|
|
if(!addedATrack) continue;
|
|
|
|
lastSessionTrack = session.EndTrack;
|
|
Sessions.Add(session);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "session.StartTrack = {0}", session.StartTrack);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "session.StartSector = {0}", session.StartSector);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "session.EndTrack = {0}", session.EndTrack);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "session.EndSector = {0}", session.EndSector);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "session.SessionSequence = {0}",
|
|
session.SessionSequence);
|
|
}
|
|
|
|
// Skip unknown
|
|
position += 16;
|
|
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "Current position = {0}", position);
|
|
byte[] filenameB = new byte[descriptor[position]];
|
|
position++;
|
|
Array.Copy(descriptor, position, filenameB, 0, filenameB.Length);
|
|
position += filenameB.Length;
|
|
string filename = Path.GetFileName(Encoding.Default.GetString(filenameB));
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "filename = {0}", filename);
|
|
|
|
// Skip unknown
|
|
position += 29;
|
|
|
|
mediumType = BitConverter.ToUInt16(descriptor, position);
|
|
position += 2;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "mediumType = {0}", mediumType);
|
|
|
|
uint discSize = BitConverter.ToUInt32(descriptor, position);
|
|
position += 4;
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "discSize = {0}", discSize);
|
|
|
|
byte[] volidB = new byte[descriptor[position]];
|
|
position++;
|
|
Array.Copy(descriptor, position, volidB, 0, volidB.Length);
|
|
position += volidB.Length;
|
|
string volid = Path.GetFileName(Encoding.Default.GetString(volidB));
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "volid = {0}", volid);
|
|
|
|
// Skip unknown
|
|
position += 9;
|
|
|
|
byte[] mcn = new byte[13];
|
|
Array.Copy(descriptor, position, mcn, 0, 13);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "mcn = {0}", StringHandlers.CToString(mcn));
|
|
position += 13;
|
|
uint mcnValid = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "mcn_valid = {0}", mcnValid);
|
|
position += 4;
|
|
|
|
uint cdtextLen = BitConverter.ToUInt32(descriptor, position);
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "cdtextLen = {0}", cdtextLen);
|
|
position += 4;
|
|
if(cdtextLen > 0)
|
|
{
|
|
cdtext = new byte[cdtextLen];
|
|
Array.Copy(descriptor, position, cdtext, 0, cdtextLen);
|
|
position += (int)cdtextLen;
|
|
imageInfo.ReadableMediaTags.Add(MediaTagType.CD_TEXT);
|
|
}
|
|
|
|
// Skip unknown
|
|
position += 12;
|
|
|
|
DicConsole.DebugWriteLine("DiscJuggler plugin", "End position = {0}", position);
|
|
|
|
if(imageInfo.MediaType == MediaType.CDROM)
|
|
{
|
|
bool data = false;
|
|
bool mode2 = false;
|
|
bool firstaudio = false;
|
|
bool firstdata = false;
|
|
bool audio = false;
|
|
|
|
for(int i = 0; i < Tracks.Count; i++)
|
|
{
|
|
// First track is audio
|
|
firstaudio |= i == 0 && Tracks[i].TrackType == TrackType.Audio;
|
|
|
|
// First track is data
|
|
firstdata |= i == 0 && Tracks[i].TrackType != TrackType.Audio;
|
|
|
|
// Any non first track is data
|
|
data |= i != 0 && Tracks[i].TrackType != TrackType.Audio;
|
|
|
|
// Any non first track is audio
|
|
audio |= i != 0 && Tracks[i].TrackType == TrackType.Audio;
|
|
|
|
switch(Tracks[i].TrackType)
|
|
{
|
|
case TrackType.CdMode2Form1:
|
|
case TrackType.CdMode2Form2:
|
|
case TrackType.CdMode2Formless:
|
|
mode2 = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!data && !firstdata) imageInfo.MediaType = MediaType.CDDA;
|
|
else if(firstaudio && data && Sessions.Count > 1 && mode2) imageInfo.MediaType = MediaType.CDPLUS;
|
|
else if(firstdata && audio || mode2) imageInfo.MediaType = MediaType.CDROMXA;
|
|
else if(!audio) imageInfo.MediaType = MediaType.CDROM;
|
|
else imageInfo.MediaType = MediaType.CD;
|
|
}
|
|
|
|
imageInfo.Application = "DiscJuggler";
|
|
imageInfo.ImageSize = (ulong)imageFilter.GetDataForkLength();
|
|
imageInfo.CreationTime = imageFilter.GetCreationTime();
|
|
imageInfo.LastModificationTime = imageFilter.GetLastWriteTime();
|
|
imageInfo.XmlMediaType = XmlMediaType.OpticalDisc;
|
|
|
|
return true;
|
|
}
|
|
|
|
public byte[] ReadDiskTag(MediaTagType tag)
|
|
{
|
|
switch(tag)
|
|
{
|
|
case MediaTagType.CD_TEXT:
|
|
{
|
|
if(cdtext != null && cdtext.Length > 0) return cdtext;
|
|
|
|
throw new FeatureNotPresentImageException("Image does not contain CD-TEXT information.");
|
|
}
|
|
default:
|
|
throw new FeatureSupportedButNotImplementedImageException("Feature not supported by image format");
|
|
}
|
|
}
|
|
|
|
public byte[] ReadSector(ulong sectorAddress)
|
|
{
|
|
return ReadSectors(sectorAddress, 1);
|
|
}
|
|
|
|
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag)
|
|
{
|
|
return ReadSectorsTag(sectorAddress, 1, tag);
|
|
}
|
|
|
|
public byte[] ReadSector(ulong sectorAddress, uint track)
|
|
{
|
|
return ReadSectors(sectorAddress, 1, track);
|
|
}
|
|
|
|
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag)
|
|
{
|
|
return ReadSectorsTag(sectorAddress, 1, track, tag);
|
|
}
|
|
|
|
public byte[] ReadSectors(ulong sectorAddress, uint length)
|
|
{
|
|
foreach(KeyValuePair<uint, ulong> kvp in from kvp in offsetmap
|
|
where sectorAddress >= kvp.Value
|
|
from track in Tracks
|
|
where track.TrackSequence == kvp.Key
|
|
where sectorAddress < track.TrackEndSector
|
|
select kvp)
|
|
return ReadSectors(sectorAddress - kvp.Value, length, kvp.Key);
|
|
|
|
throw new ArgumentOutOfRangeException(nameof(sectorAddress), $"Sector address {sectorAddress} not found");
|
|
}
|
|
|
|
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag)
|
|
{
|
|
foreach(KeyValuePair<uint, ulong> kvp in offsetmap
|
|
.Where(kvp => sectorAddress >= kvp.Value)
|
|
.Where(kvp => Tracks
|
|
.Where(track => track.TrackSequence == kvp.Key)
|
|
.Any(track => sectorAddress <
|
|
track.TrackEndSector)))
|
|
return ReadSectorsTag(sectorAddress - kvp.Value, length, kvp.Key, tag);
|
|
|
|
throw new ArgumentOutOfRangeException(nameof(sectorAddress), $"Sector address {sectorAddress} not found");
|
|
}
|
|
|
|
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track)
|
|
{
|
|
Track dicTrack = new Track {TrackSequence = 0};
|
|
|
|
foreach(Track linqTrack in Tracks.Where(linqTrack => linqTrack.TrackSequence == track))
|
|
{
|
|
dicTrack = linqTrack;
|
|
break;
|
|
}
|
|
|
|
if(dicTrack.TrackSequence == 0)
|
|
throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");
|
|
|
|
if(length + sectorAddress > dicTrack.TrackEndSector)
|
|
throw new ArgumentOutOfRangeException(nameof(length),
|
|
$"Requested more sectors ({length + sectorAddress}) than present in track ({dicTrack.TrackEndSector}), won't cross tracks");
|
|
|
|
uint sectorOffset;
|
|
uint sectorSize;
|
|
uint sectorSkip;
|
|
|
|
switch(dicTrack.TrackType)
|
|
{
|
|
case TrackType.Audio:
|
|
{
|
|
sectorOffset = 0;
|
|
sectorSize = 2352;
|
|
sectorSkip = 0;
|
|
break;
|
|
}
|
|
case TrackType.CdMode1:
|
|
if(dicTrack.TrackRawBytesPerSector == 2352)
|
|
{
|
|
sectorOffset = 16;
|
|
sectorSize = 2048;
|
|
sectorSkip = 288;
|
|
}
|
|
else
|
|
{
|
|
sectorOffset = 0;
|
|
sectorSize = 2048;
|
|
sectorSkip = 0;
|
|
}
|
|
|
|
break;
|
|
case TrackType.CdMode2Formless:
|
|
if(dicTrack.TrackRawBytesPerSector == 2352)
|
|
{
|
|
sectorOffset = 16;
|
|
sectorSize = 2336;
|
|
sectorSkip = 0;
|
|
}
|
|
else
|
|
{
|
|
sectorOffset = 0;
|
|
sectorSize = 2336;
|
|
sectorSkip = 0;
|
|
}
|
|
|
|
break;
|
|
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported track type");
|
|
}
|
|
|
|
switch(dicTrack.TrackSubchannelType)
|
|
{
|
|
case TrackSubchannelType.None:
|
|
sectorSkip += 0;
|
|
break;
|
|
case TrackSubchannelType.Q16Interleaved:
|
|
sectorSkip += 16;
|
|
break;
|
|
case TrackSubchannelType.PackedInterleaved:
|
|
sectorSkip += 96;
|
|
break;
|
|
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported subchannel type");
|
|
}
|
|
|
|
byte[] buffer = new byte[sectorSize * length];
|
|
|
|
imageStream.Seek((long)(dicTrack.TrackFileOffset + sectorAddress * (ulong)dicTrack.TrackRawBytesPerSector),
|
|
SeekOrigin.Begin);
|
|
if(sectorOffset == 0 && sectorSkip == 0) imageStream.Read(buffer, 0, buffer.Length);
|
|
else
|
|
for(int i = 0; i < length; i++)
|
|
{
|
|
byte[] sector = new byte[sectorSize];
|
|
imageStream.Seek(sectorOffset, SeekOrigin.Current);
|
|
imageStream.Read(sector, 0, sector.Length);
|
|
imageStream.Seek(sectorSkip, SeekOrigin.Current);
|
|
Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag)
|
|
{
|
|
Track dicTrack = new Track {TrackSequence = 0};
|
|
|
|
foreach(Track linqTrack in Tracks.Where(linqTrack => linqTrack.TrackSequence == track))
|
|
{
|
|
dicTrack = linqTrack;
|
|
break;
|
|
}
|
|
|
|
if(dicTrack.TrackSequence == 0)
|
|
throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");
|
|
|
|
if(length + sectorAddress > dicTrack.TrackEndSector)
|
|
throw new ArgumentOutOfRangeException(nameof(length),
|
|
$"Requested more sectors ({length + sectorAddress}) than present in track ({dicTrack.TrackEndSector}), won't cross tracks");
|
|
|
|
if(dicTrack.TrackType == TrackType.Data)
|
|
throw new ArgumentException("Unsupported tag requested", nameof(tag));
|
|
|
|
switch(tag)
|
|
{
|
|
case SectorTagType.CdSectorEcc:
|
|
case SectorTagType.CdSectorEccP:
|
|
case SectorTagType.CdSectorEccQ:
|
|
case SectorTagType.CdSectorEdc:
|
|
case SectorTagType.CdSectorHeader:
|
|
case SectorTagType.CdSectorSubchannel:
|
|
case SectorTagType.CdSectorSubHeader:
|
|
case SectorTagType.CdSectorSync: break;
|
|
case SectorTagType.CdTrackFlags:
|
|
if(trackFlags.TryGetValue(track, out byte flag)) return new[] {flag};
|
|
|
|
throw new ArgumentException("Unsupported tag requested", nameof(tag));
|
|
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
|
|
}
|
|
|
|
uint sectorOffset;
|
|
uint sectorSize;
|
|
uint sectorSkip;
|
|
|
|
switch(dicTrack.TrackType)
|
|
{
|
|
case TrackType.CdMode1:
|
|
if(dicTrack.TrackRawBytesPerSector != 2352)
|
|
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
|
|
|
|
switch(tag)
|
|
{
|
|
case SectorTagType.CdSectorSync:
|
|
{
|
|
sectorOffset = 0;
|
|
sectorSize = 12;
|
|
sectorSkip = 2340;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorHeader:
|
|
{
|
|
sectorOffset = 12;
|
|
sectorSize = 4;
|
|
sectorSkip = 2336;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorSubHeader:
|
|
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
|
|
case SectorTagType.CdSectorEcc:
|
|
{
|
|
sectorOffset = 2076;
|
|
sectorSize = 276;
|
|
sectorSkip = 0;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorEccP:
|
|
{
|
|
sectorOffset = 2076;
|
|
sectorSize = 172;
|
|
sectorSkip = 104;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorEccQ:
|
|
{
|
|
sectorOffset = 2248;
|
|
sectorSize = 104;
|
|
sectorSkip = 0;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorEdc:
|
|
{
|
|
sectorOffset = 2064;
|
|
sectorSize = 4;
|
|
sectorSkip = 284;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorSubchannel:
|
|
switch(dicTrack.TrackSubchannelType)
|
|
{
|
|
case TrackSubchannelType.None:
|
|
throw new ArgumentException("Unsupported tag requested for this track",
|
|
nameof(tag));
|
|
case TrackSubchannelType.Q16Interleaved:
|
|
throw new ArgumentException("Q16 subchannel not yet supported");
|
|
}
|
|
|
|
sectorOffset = 2352;
|
|
sectorSize = 96;
|
|
sectorSkip = 0;
|
|
break;
|
|
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
|
|
}
|
|
|
|
break;
|
|
case TrackType.CdMode2Formless:
|
|
if(dicTrack.TrackRawBytesPerSector != 2352)
|
|
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
|
|
|
|
{
|
|
switch(tag)
|
|
{
|
|
case SectorTagType.CdSectorSync:
|
|
case SectorTagType.CdSectorHeader:
|
|
case SectorTagType.CdSectorEcc:
|
|
case SectorTagType.CdSectorEccP:
|
|
case SectorTagType.CdSectorEccQ:
|
|
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
|
|
case SectorTagType.CdSectorSubHeader:
|
|
{
|
|
sectorOffset = 0;
|
|
sectorSize = 8;
|
|
sectorSkip = 2328;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorEdc:
|
|
{
|
|
sectorOffset = 2332;
|
|
sectorSize = 4;
|
|
sectorSkip = 0;
|
|
break;
|
|
}
|
|
case SectorTagType.CdSectorSubchannel:
|
|
switch(dicTrack.TrackSubchannelType)
|
|
{
|
|
case TrackSubchannelType.None:
|
|
throw new ArgumentException("Unsupported tag requested for this track",
|
|
nameof(tag));
|
|
case TrackSubchannelType.Q16Interleaved:
|
|
throw new ArgumentException("Q16 subchannel not yet supported");
|
|
}
|
|
|
|
sectorOffset = 2352;
|
|
sectorSize = 96;
|
|
sectorSkip = 0;
|
|
break;
|
|
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
|
|
}
|
|
|
|
break;
|
|
}
|
|
case TrackType.Audio:
|
|
{
|
|
switch(tag)
|
|
{
|
|
case SectorTagType.CdSectorSubchannel:
|
|
switch(dicTrack.TrackSubchannelType)
|
|
{
|
|
case TrackSubchannelType.None:
|
|
throw new ArgumentException("Unsupported tag requested for this track",
|
|
nameof(tag));
|
|
case TrackSubchannelType.Q16Interleaved:
|
|
throw new ArgumentException("Q16 subchannel not yet supported");
|
|
}
|
|
|
|
sectorOffset = 2352;
|
|
sectorSize = 96;
|
|
sectorSkip = 0;
|
|
break;
|
|
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
|
|
}
|
|
|
|
break;
|
|
}
|
|
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported track type");
|
|
}
|
|
|
|
switch(dicTrack.TrackSubchannelType)
|
|
{
|
|
case TrackSubchannelType.None:
|
|
sectorSkip += 0;
|
|
break;
|
|
case TrackSubchannelType.Q16Interleaved:
|
|
sectorSkip += 16;
|
|
break;
|
|
case TrackSubchannelType.PackedInterleaved:
|
|
sectorSkip += 96;
|
|
break;
|
|
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported subchannel type");
|
|
}
|
|
|
|
byte[] buffer = new byte[sectorSize * length];
|
|
|
|
imageStream.Seek((long)(dicTrack.TrackFileOffset + sectorAddress * (ulong)dicTrack.TrackRawBytesPerSector),
|
|
SeekOrigin.Begin);
|
|
if(sectorOffset == 0 && sectorSkip == 0) imageStream.Read(buffer, 0, buffer.Length);
|
|
else
|
|
for(int i = 0; i < length; i++)
|
|
{
|
|
byte[] sector = new byte[sectorSize];
|
|
imageStream.Seek(sectorOffset, SeekOrigin.Current);
|
|
imageStream.Read(sector, 0, sector.Length);
|
|
imageStream.Seek(sectorSkip, SeekOrigin.Current);
|
|
Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
public byte[] ReadSectorLong(ulong sectorAddress)
|
|
{
|
|
return ReadSectorsLong(sectorAddress, 1);
|
|
}
|
|
|
|
public byte[] ReadSectorLong(ulong sectorAddress, uint track)
|
|
{
|
|
return ReadSectorsLong(sectorAddress, 1, track);
|
|
}
|
|
|
|
public byte[] ReadSectorsLong(ulong sectorAddress, uint length)
|
|
{
|
|
foreach(KeyValuePair<uint, ulong> kvp in from kvp in offsetmap
|
|
where sectorAddress >= kvp.Value
|
|
from track in Tracks
|
|
where track.TrackSequence == kvp.Key
|
|
where sectorAddress - kvp.Value <
|
|
track.TrackEndSector - track.TrackStartSector
|
|
select kvp)
|
|
return ReadSectorsLong(sectorAddress - kvp.Value, length, kvp.Key);
|
|
|
|
throw new ArgumentOutOfRangeException(nameof(sectorAddress), $"Sector address {sectorAddress} not found");
|
|
}
|
|
|
|
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track)
|
|
{
|
|
Track dicTrack = new Track {TrackSequence = 0};
|
|
|
|
foreach(Track linqTrack in Tracks.Where(linqTrack => linqTrack.TrackSequence == track))
|
|
{
|
|
dicTrack = linqTrack;
|
|
break;
|
|
}
|
|
|
|
if(dicTrack.TrackSequence == 0)
|
|
throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");
|
|
|
|
if(length + sectorAddress > dicTrack.TrackEndSector)
|
|
throw new ArgumentOutOfRangeException(nameof(length),
|
|
$"Requested more sectors ({length + sectorAddress}) than present in track ({dicTrack.TrackEndSector}), won't cross tracks");
|
|
|
|
uint sectorSize = (uint)dicTrack.TrackRawBytesPerSector;
|
|
uint sectorSkip = 0;
|
|
|
|
switch(dicTrack.TrackSubchannelType)
|
|
{
|
|
case TrackSubchannelType.None:
|
|
sectorSkip += 0;
|
|
break;
|
|
case TrackSubchannelType.Q16Interleaved:
|
|
sectorSkip += 16;
|
|
break;
|
|
case TrackSubchannelType.PackedInterleaved:
|
|
sectorSkip += 96;
|
|
break;
|
|
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported subchannel type");
|
|
}
|
|
|
|
byte[] buffer = new byte[sectorSize * length];
|
|
|
|
imageStream.Seek((long)(dicTrack.TrackFileOffset + sectorAddress * (ulong)dicTrack.TrackRawBytesPerSector),
|
|
SeekOrigin.Begin);
|
|
if(sectorSkip == 0) imageStream.Read(buffer, 0, buffer.Length);
|
|
else
|
|
for(int i = 0; i < length; i++)
|
|
{
|
|
byte[] sector = new byte[sectorSize];
|
|
imageStream.Read(sector, 0, sector.Length);
|
|
imageStream.Seek(sectorSkip, SeekOrigin.Current);
|
|
Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
public List<Track> GetSessionTracks(Session session)
|
|
{
|
|
if(Sessions.Contains(session)) return GetSessionTracks(session.SessionSequence);
|
|
|
|
throw new ImageNotSupportedException("Session does not exist in disc image");
|
|
}
|
|
|
|
public List<Track> GetSessionTracks(ushort session)
|
|
{
|
|
return Tracks.Where(track => track.TrackSession == session).ToList();
|
|
}
|
|
|
|
public bool? VerifySector(ulong sectorAddress)
|
|
{
|
|
byte[] buffer = ReadSectorLong(sectorAddress);
|
|
return CdChecksums.CheckCdSector(buffer);
|
|
}
|
|
|
|
public bool? VerifySector(ulong sectorAddress, uint track)
|
|
{
|
|
byte[] buffer = ReadSectorLong(sectorAddress, track);
|
|
return CdChecksums.CheckCdSector(buffer);
|
|
}
|
|
|
|
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
|
|
out List<ulong> unknownLbas)
|
|
{
|
|
byte[] buffer = ReadSectorsLong(sectorAddress, length);
|
|
int bps = (int)(buffer.Length / length);
|
|
byte[] sector = new byte[bps];
|
|
failingLbas = new List<ulong>();
|
|
unknownLbas = new List<ulong>();
|
|
|
|
for(int i = 0; i < length; i++)
|
|
{
|
|
Array.Copy(buffer, i * bps, sector, 0, bps);
|
|
bool? sectorStatus = CdChecksums.CheckCdSector(sector);
|
|
|
|
switch(sectorStatus)
|
|
{
|
|
case null:
|
|
unknownLbas.Add((ulong)i + sectorAddress);
|
|
break;
|
|
case false:
|
|
failingLbas.Add((ulong)i + sectorAddress);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(unknownLbas.Count > 0) return null;
|
|
|
|
return failingLbas.Count <= 0;
|
|
}
|
|
|
|
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
|
|
out List<ulong> unknownLbas)
|
|
{
|
|
byte[] buffer = ReadSectorsLong(sectorAddress, length, track);
|
|
int bps = (int)(buffer.Length / length);
|
|
byte[] sector = new byte[bps];
|
|
failingLbas = new List<ulong>();
|
|
unknownLbas = new List<ulong>();
|
|
|
|
for(int i = 0; i < length; i++)
|
|
{
|
|
Array.Copy(buffer, i * bps, sector, 0, bps);
|
|
bool? sectorStatus = CdChecksums.CheckCdSector(sector);
|
|
|
|
switch(sectorStatus)
|
|
{
|
|
case null:
|
|
unknownLbas.Add((ulong)i + sectorAddress);
|
|
break;
|
|
case false:
|
|
failingLbas.Add((ulong)i + sectorAddress);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(unknownLbas.Count > 0) return null;
|
|
|
|
return failingLbas.Count <= 0;
|
|
}
|
|
|
|
public bool? VerifyMediaImage()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public List<DumpHardwareType> DumpHardware => null;
|
|
public CICMMetadataType CicmMetadata => null;
|
|
|
|
static MediaType DecodeCdiMediumType(ushort type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case 56: return MediaType.DVDROM;
|
|
case 152: return MediaType.CDROM;
|
|
default: return MediaType.Unknown;
|
|
}
|
|
}
|
|
}
|
|
} |