aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
4158d6485440edef37707ba221af02395d4db3b8
Aaru/DiscImageChef.DiscImages/DiscJuggler.cs

1365 lines
60 KiB
C#
Raw Normal View History

Added support for different character encodings.
2017-06-06 21:23:20 +01:00
// /***************************************************************************
* DiscImageChef.DiscImages/CloneCD.cs: Correct subchannel reading. * DiscImageChef/DetectImageFormat.cs: Add debug output.
2016-10-10 02:05:49 +01:00
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : DiscJuggler.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
// Component : Disc image plugins.
* DiscImageChef.DiscImages/CloneCD.cs: Correct subchannel reading. * DiscImageChef/DetectImageFormat.cs: Add debug output.
2016-10-10 02:05:49 +01:00
//
// --[ Description ] ----------------------------------------------------------
//
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
// Manages DiscJuggler disc images.
* DiscImageChef.DiscImages/CloneCD.cs: Correct subchannel reading. * DiscImageChef/DetectImageFormat.cs: Add debug output.
2016-10-10 02:05:49 +01:00
//
// --[ 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/>.
//
// ----------------------------------------------------------------------------
REFACTOR: Updated comments and copyright date.
2017-12-19 03:50:57 +00:00
// Copyright © 2011-2018 Natalia Portillo
* DiscImageChef.DiscImages/CloneCD.cs: Correct subchannel reading. * DiscImageChef/DetectImageFormat.cs: Add debug output.
2016-10-10 02:05:49 +01:00
// ****************************************************************************/
Adds support for DiscJuggler images, closes #56
2016-10-10 02:06:52 +01:00
* DiscImageChef.DiscImages/CloneCD.cs: Correct subchannel reading. * DiscImageChef/DetectImageFormat.cs: Add debug output.
2016-10-10 02:05:49 +01:00
using System;
Adds support for DiscJuggler images, closes #56
2016-10-10 02:06:52 +01:00
using System.Collections.Generic;
using System.IO;
using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.Console;
using DiscImageChef.Filters;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
using DiscImageChef.DiscImages;
Adds support for DiscJuggler images, closes #56
2016-10-10 02:06:52 +01:00
* DiscImageChef.DiscImages/CloneCD.cs: Correct subchannel reading. * DiscImageChef/DetectImageFormat.cs: Add debug output.
2016-10-10 02:05:49 +01:00
namespace DiscImageChef.DiscImages
{
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
// Support separate data files? Never seen a DiscJuggler image using them anyways...
public class DiscJuggler : ImagePlugin
{
Stream imageStream;
List<Session> sessions;
List<Track> tracks;
byte[] cdtext;
Dictionary<uint, ulong> offsetmap;
List<Partition> partitions;
Dictionary<uint, byte> trackFlags;
public DiscJuggler()
{
Name = "DiscJuggler";
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
PluginUuid = new Guid("2444DBC6-CD35-424C-A227-39B0C4DB01B2");
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
ImageInfo = new ImageInfo();
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
ImageInfo.ReadableSectorTags = new List<SectorTagType>();
ImageInfo.ReadableMediaTags = new List<MediaTagType>();
ImageInfo.ImageHasPartitions = true;
ImageInfo.ImageHasSessions = true;
ImageInfo.ImageVersion = null;
ImageInfo.ImageApplicationVersion = null;
ImageInfo.ImageName = null;
ImageInfo.ImageCreator = null;
ImageInfo.MediaManufacturer = null;
ImageInfo.MediaModel = null;
ImageInfo.MediaPartNumber = null;
ImageInfo.MediaSequence = 0;
ImageInfo.LastMediaSequence = 0;
ImageInfo.DriveManufacturer = null;
ImageInfo.DriveModel = null;
ImageInfo.DriveSerialNumber = null;
ImageInfo.DriveFirmwareRevision = null;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override bool IdentifyImage(Filter imageFilter)
{
imageStream = imageFilter.GetDataForkStream();
imageStream.Seek(-4, SeekOrigin.End);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] dscLenB = new byte[4];
imageStream.Read(dscLenB, 0, 4);
int dscLen = BitConverter.ToInt32(dscLenB, 0);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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
if(descriptor[2] > 99) return false;
return true;
}
public override bool OpenImage(Filter imageFilter)
{
imageStream = imageFilter.GetDataForkStream();
imageStream.Seek(-4, SeekOrigin.End);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] dscLenB = new byte[4];
imageStream.Read(dscLenB, 0, 4);
int dscLen = BitConverter.ToInt32(dscLenB, 0);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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();
session.SessionSequence = sessionSequence;
session.EndTrack = uint.MinValue;
session.StartTrack = uint.MaxValue;
position += 15;
bool addedATrack = false;
// Read track
for(byte t = 0; t < maxT; t++)
{
addedATrack = false;
DicConsole.DebugWriteLine("DiscJuggler plugin", "t = {0}", t);
Track track = new Track();
// Skip unknown
position += 16;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] trackFilenameB = new byte[descriptor[position]];
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
position++;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
Array.Copy(descriptor, position, trackFilenameB, 0, trackFilenameB.Length);
position += trackFilenameB.Length;
track.TrackFile = Path.GetFileName(Encoding.Default.GetString(trackFilenameB));
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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)
{
byte[] textBlk = new byte[bLen];
Array.Copy(descriptor, position, textBlk, 0, bLen);
position += bLen;
// Track title
if(cb == 10)
{
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;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
uint isrcValid = BitConverter.ToUInt32(descriptor, position);
DicConsole.DebugWriteLine("DiscJuggler plugin", "\tisrc_valid = {0}", isrcValid);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(ImageInfo.SectorSize < 2352) ImageInfo.SectorSize = 2352;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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(string.Format("Unknown read mode {0}",
readMode));
}
break;
// Mode 1 or DVD
case 1:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(ImageInfo.SectorSize < 2048) ImageInfo.SectorSize = 2048;
track.TrackType = TrackType.CdMode1;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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(string.Format("Invalid read mode {0} for this track",
readMode));
case 2:
track.TrackRawBytesPerSector = 2352;
currentOffset += trackLen * (ulong)track.TrackRawBytesPerSector;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
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);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
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);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
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);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default:
throw new ImageNotSupportedException(string.Format("Unknown read mode {0}",
readMode));
}
break;
// Mode 2
case 2:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(ImageInfo.SectorSize < 2336) ImageInfo.SectorSize = 2336;
track.TrackType = TrackType.CdMode2Formless;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
track.TrackBytesPerSector = 2336;
switch(readMode)
{
case 0:
throw new
ImageNotSupportedException(string.Format("Invalid read mode {0} for this track",
readMode));
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;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(!ImageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
ImageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
if(!ImageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
ImageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(!ImageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
ImageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
if(!ImageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
ImageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(!ImageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
ImageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
if(!ImageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
ImageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default:
throw new ImageNotSupportedException(string.Format("Unknown read mode {0}",
readMode));
}
break;
default:
throw new ImageNotSupportedException(string.Format("Unknown track mode {0}", trackMode));
}
track.TrackFile = imageFilter.GetFilename();
track.TrackFilter = imageFilter;
if(track.TrackSubchannelType != TrackSubchannelType.None)
{
track.TrackSubchannelFile = imageFilter.GetFilename();
track.TrackSubchannelFilter = imageFilter;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(!ImageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
ImageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubchannel);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
Partition partition = new Partition();
partition.Description = track.TrackDescription;
partition.Size = (ulong)(trackLen * track.TrackBytesPerSector);
partition.Length = trackLen;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
ImageInfo.Sectors += partition.Length;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
partition.Sequence = track.TrackSequence;
partition.Offset = track.TrackFileOffset;
partition.Start = track.TrackStartSector;
partition.Type = track.TrackType.ToString();
partitions.Add(partition);
offsetmap.Add(track.TrackSequence, track.TrackStartSector);
tracks.Add(track);
trackFlags.Add(track.TrackSequence, (byte)(trackCtl & 0xFF));
addedATrack = true;
}
if(addedATrack)
{
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);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] filenameB = new byte[descriptor[position]];
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
position++;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
Array.Copy(descriptor, position, filenameB, 0, filenameB.Length);
position += filenameB.Length;
string filename = Path.GetFileName(Encoding.Default.GetString(filenameB));
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] volidB = new byte[descriptor[position]];
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
position++;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
Array.Copy(descriptor, position, volidB, 0, volidB.Length);
position += volidB.Length;
string volid = Path.GetFileName(Encoding.Default.GetString(volidB));
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
uint mcnValid = BitConverter.ToUInt32(descriptor, position);
DicConsole.DebugWriteLine("DiscJuggler plugin", "mcn_valid = {0}", mcnValid);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
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;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
ImageInfo.ReadableMediaTags.Add(MediaTagType.CD_TEXT);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
// Skip unknown
position += 12;
DicConsole.DebugWriteLine("DiscJuggler plugin", "End position = {0}", position);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(ImageInfo.MediaType == MediaType.CDROM)
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
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)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case TrackType.CdMode2Form1:
case TrackType.CdMode2Form2:
case TrackType.CdMode2Formless:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
mode2 = true;
break;
}
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(!data && !firstdata) ImageInfo.MediaType = MediaType.CDDA;
else if(firstaudio && data && sessions.Count > 1 && mode2) ImageInfo.MediaType = MediaType.CDPLUS;
REFACTOR: Remove redundant parentheses.
2017-12-20 17:26:28 +00:00
else if(firstdata && audio || mode2) ImageInfo.MediaType = MediaType.CDROMXA;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
else if(!audio) ImageInfo.MediaType = MediaType.CDROM;
else ImageInfo.MediaType = MediaType.CD;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
ImageInfo.ImageApplication = "DiscJuggler";
ImageInfo.ImageSize = (ulong)imageFilter.GetDataForkLength();
ImageInfo.ImageCreationTime = imageFilter.GetCreationTime();
ImageInfo.ImageLastModificationTime = imageFilter.GetLastWriteTime();
ImageInfo.XmlMediaType = XmlMediaType.OpticalDisc;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
return true;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
static MediaType DecodeCdiMediumType(ushort type)
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
switch(type)
{
case 56: return MediaType.DVDROM;
case 152: return MediaType.CDROM;
default: return MediaType.Unknown;
}
}
public override bool ImageHasPartitions()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageHasPartitions;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override ulong GetImageSize()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageSize;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override ulong GetSectors()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.Sectors;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override uint GetSectorSize()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.SectorSize;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override 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 override byte[] ReadSector(ulong sectorAddress)
{
return ReadSectors(sectorAddress, 1);
}
public override byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag)
{
return ReadSectorsTag(sectorAddress, 1, tag);
}
public override byte[] ReadSector(ulong sectorAddress, uint track)
{
return ReadSectors(sectorAddress, 1, track);
}
public override byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag)
{
return ReadSectorsTag(sectorAddress, 1, track, tag);
}
public override byte[] ReadSectors(ulong sectorAddress, uint length)
{
foreach(KeyValuePair<uint, ulong> kvp in offsetmap)
{
if(sectorAddress >= kvp.Value)
{
foreach(Track _track in tracks)
{
if(_track.TrackSequence == kvp.Key)
{
if(sectorAddress < _track.TrackEndSector)
REFACTOR: Remove redundant parentheses.
2017-12-20 17:26:28 +00:00
return ReadSectors(sectorAddress - kvp.Value, length, kvp.Key);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
}
}
}
throw new ArgumentOutOfRangeException(nameof(sectorAddress),
string.Format("Sector address {0} not found", sectorAddress));
}
public override byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag)
{
foreach(KeyValuePair<uint, ulong> kvp in offsetmap)
{
if(sectorAddress >= kvp.Value)
{
foreach(Track _track in tracks)
{
if(_track.TrackSequence == kvp.Key)
{
if(sectorAddress < _track.TrackEndSector)
REFACTOR: Remove redundant parentheses.
2017-12-20 17:26:28 +00:00
return ReadSectorsTag(sectorAddress - kvp.Value, length, kvp.Key, tag);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
}
}
}
throw new ArgumentOutOfRangeException(nameof(sectorAddress),
string.Format("Sector address {0} not found", sectorAddress));
}
public override byte[] ReadSectors(ulong sectorAddress, uint length, uint track)
{
Track _track = new Track();
_track.TrackSequence = 0;
foreach(Track __track in tracks)
{
if(__track.TrackSequence == track)
{
_track = __track;
break;
}
}
if(_track.TrackSequence == 0)
throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");
REFACTOR: Remove redundant parentheses.
2017-12-20 17:26:28 +00:00
if(length + sectorAddress > _track.TrackEndSector)
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
throw new ArgumentOutOfRangeException(nameof(length),
string
.Format("Requested more sectors ({0}) than present in track ({1}), won't cross tracks",
length + sectorAddress, _track.TrackEndSector));
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
uint sectorOffset;
uint sectorSize;
uint sectorSkip;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
switch(_track.TrackType)
{
case TrackType.Audio:
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 0;
sectorSize = 2352;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case TrackType.CdMode1:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(_track.TrackRawBytesPerSector == 2352)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 16;
sectorSize = 2048;
sectorSkip = 288;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
else
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 0;
sectorSize = 2048;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
break;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case TrackType.CdMode2Formless:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(_track.TrackRawBytesPerSector == 2352)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 16;
sectorSize = 2336;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
else
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 0;
sectorSize = 2336;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
break;
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported track type");
}
switch(_track.TrackSubchannelType)
{
case TrackSubchannelType.None:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case TrackSubchannelType.Q16Interleaved:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 16;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case TrackSubchannelType.PackedInterleaved:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 96;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported subchannel type");
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] buffer = new byte[sectorSize * length];
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
imageStream.Seek((long)(_track.TrackFileOffset + sectorAddress * (ulong)_track.TrackRawBytesPerSector),
SeekOrigin.Begin);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(sectorOffset == 0 && sectorSkip == 0) imageStream.Read(buffer, 0, buffer.Length);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
else
{
for(int i = 0; i < length; i++)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] sector = new byte[sectorSize];
imageStream.Seek(sectorOffset, SeekOrigin.Current);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
imageStream.Read(sector, 0, sector.Length);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
imageStream.Seek(sectorSkip, SeekOrigin.Current);
Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
}
return buffer;
}
public override byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag)
{
Track _track = new Track();
_track.TrackSequence = 0;
foreach(Track __track in tracks)
{
if(__track.TrackSequence == track)
{
_track = __track;
break;
}
}
if(_track.TrackSequence == 0)
throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");
REFACTOR: Remove redundant parentheses.
2017-12-20 17:26:28 +00:00
if(length + sectorAddress > _track.TrackEndSector)
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
throw new ArgumentOutOfRangeException(nameof(length),
string
.Format("Requested more sectors ({0}) than present in track ({1}), won't cross tracks",
length + sectorAddress, _track.TrackEndSector));
if(_track.TrackType == TrackType.Data)
throw new ArgumentException("Unsupported tag requested", nameof(tag));
byte[] buffer;
switch(tag)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
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:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
byte flag;
if(trackFlags.TryGetValue(track, out flag)) return new byte[] {flag};
throw new ArgumentException("Unsupported tag requested", nameof(tag));
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
uint sectorOffset;
uint sectorSize;
uint sectorSkip;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
switch(_track.TrackType)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case TrackType.CdMode1:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(_track.TrackRawBytesPerSector != 2352)
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
switch(tag)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorSync:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 0;
sectorSize = 12;
sectorSkip = 2340;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorHeader:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 12;
sectorSize = 4;
sectorSkip = 2336;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorSubHeader:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorEcc:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2076;
sectorSize = 276;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorEccP:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2076;
sectorSize = 172;
sectorSkip = 104;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorEccQ:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2248;
sectorSize = 104;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorEdc:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2064;
sectorSize = 4;
sectorSkip = 284;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorSubchannel:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(_track.TrackSubchannelType == TrackSubchannelType.None)
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
if(_track.TrackSubchannelType == TrackSubchannelType.Q16Interleaved)
throw new ArgumentException("Q16 subchannel not yet supported");
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2352;
sectorSize = 96;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
}
break;
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case TrackType.CdMode2Formless:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(_track.TrackRawBytesPerSector != 2352)
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
{
switch(tag)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorSync:
case SectorTagType.CdSectorHeader:
case SectorTagType.CdSectorEcc:
case SectorTagType.CdSectorEccP:
case SectorTagType.CdSectorEccQ:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorSubHeader:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 0;
sectorSize = 8;
sectorSkip = 2328;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorEdc:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2332;
sectorSize = 4;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorSubchannel:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(_track.TrackSubchannelType == TrackSubchannelType.None)
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
if(_track.TrackSubchannelType == TrackSubchannelType.Q16Interleaved)
throw new ArgumentException("Q16 subchannel not yet supported");
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2352;
sectorSize = 96;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
}
break;
}
case TrackType.Audio:
{
switch(tag)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
case SectorTagType.CdSectorSubchannel:
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
if(_track.TrackSubchannelType == TrackSubchannelType.None)
throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
if(_track.TrackSubchannelType == TrackSubchannelType.Q16Interleaved)
throw new ArgumentException("Q16 subchannel not yet supported");
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorOffset = 2352;
sectorSize = 96;
sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
}
break;
}
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported track type");
}
switch(_track.TrackSubchannelType)
{
case TrackSubchannelType.None:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case TrackSubchannelType.Q16Interleaved:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 16;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case TrackSubchannelType.PackedInterleaved:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 96;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported subchannel type");
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
buffer = new byte[sectorSize * length];
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
imageStream.Seek((long)(_track.TrackFileOffset + sectorAddress * (ulong)_track.TrackRawBytesPerSector),
SeekOrigin.Begin);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(sectorOffset == 0 && sectorSkip == 0) imageStream.Read(buffer, 0, buffer.Length);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
else
{
for(int i = 0; i < length; i++)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] sector = new byte[sectorSize];
imageStream.Seek(sectorOffset, SeekOrigin.Current);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
imageStream.Read(sector, 0, sector.Length);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
imageStream.Seek(sectorSkip, SeekOrigin.Current);
Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
}
return buffer;
}
public override byte[] ReadSectorLong(ulong sectorAddress)
{
return ReadSectorsLong(sectorAddress, 1);
}
public override byte[] ReadSectorLong(ulong sectorAddress, uint track)
{
return ReadSectorsLong(sectorAddress, 1, track);
}
public override byte[] ReadSectorsLong(ulong sectorAddress, uint length)
{
foreach(KeyValuePair<uint, ulong> kvp in offsetmap)
{
if(sectorAddress >= kvp.Value)
{
foreach(Track track in tracks)
{
if(track.TrackSequence == kvp.Key)
{
REFACTOR: Remove redundant parentheses.
2017-12-20 17:26:28 +00:00
if(sectorAddress - kvp.Value < track.TrackEndSector - track.TrackStartSector)
return ReadSectorsLong(sectorAddress - kvp.Value, length, kvp.Key);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
}
}
}
throw new ArgumentOutOfRangeException(nameof(sectorAddress),
string.Format("Sector address {0} not found", sectorAddress));
}
public override byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track)
{
Track _track = new Track();
_track.TrackSequence = 0;
foreach(Track __track in tracks)
{
if(__track.TrackSequence == track)
{
_track = __track;
break;
}
}
if(_track.TrackSequence == 0)
throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");
REFACTOR: Remove redundant parentheses.
2017-12-20 17:26:28 +00:00
if(length + sectorAddress > _track.TrackEndSector)
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
throw new ArgumentOutOfRangeException(nameof(length),
string
.Format("Requested more sectors ({0}) than present in track ({1}), won't cross tracks",
length + sectorAddress, _track.TrackEndSector));
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
uint sectorOffset = 0;
uint sectorSize = (uint)_track.TrackRawBytesPerSector;
uint sectorSkip = 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
switch(_track.TrackSubchannelType)
{
case TrackSubchannelType.None:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 0;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case TrackSubchannelType.Q16Interleaved:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 16;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case TrackSubchannelType.PackedInterleaved:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
sectorSkip += 96;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
default: throw new FeatureSupportedButNotImplementedImageException("Unsupported subchannel type");
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] buffer = new byte[sectorSize * length];
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
imageStream.Seek((long)(_track.TrackFileOffset + sectorAddress * (ulong)_track.TrackRawBytesPerSector),
SeekOrigin.Begin);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(sectorOffset == 0 && sectorSkip == 0) imageStream.Read(buffer, 0, buffer.Length);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
else
{
for(int i = 0; i < length; i++)
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
byte[] sector = new byte[sectorSize];
imageStream.Seek(sectorOffset, SeekOrigin.Current);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
imageStream.Read(sector, 0, sector.Length);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
imageStream.Seek(sectorSkip, SeekOrigin.Current);
Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
}
return buffer;
}
public override string GetImageFormat()
{
return "DiscJuggler";
}
public override string GetImageVersion()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageVersion;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetImageApplication()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageApplication;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetImageApplicationVersion()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageApplicationVersion;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetImageCreator()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageCreator;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override DateTime GetImageCreationTime()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageCreationTime;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override DateTime GetImageLastModificationTime()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageLastModificationTime;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetImageName()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageName;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetImageComments()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.ImageComments;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetMediaManufacturer()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.MediaManufacturer;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetMediaModel()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.MediaModel;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetMediaSerialNumber()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.DriveSerialNumber;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetMediaBarcode()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.MediaBarcode;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetMediaPartNumber()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.MediaPartNumber;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override MediaType GetMediaType()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.MediaType;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override int GetMediaSequence()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.MediaSequence;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override int GetLastDiskSequence()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.LastMediaSequence;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetDriveManufacturer()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.DriveManufacturer;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetDriveModel()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.DriveModel;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override string GetDriveSerialNumber()
{
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return ImageInfo.DriveSerialNumber;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override List<Partition> GetPartitions()
{
return partitions;
}
public override List<Track> GetTracks()
{
return tracks;
}
public override List<Track> GetSessionTracks(Session session)
{
if(sessions.Contains(session)) { return GetSessionTracks(session.SessionSequence); }
throw new ImageNotSupportedException("Session does not exist in disc image");
}
public override List<Track> GetSessionTracks(ushort session)
{
List<Track> _tracks = new List<Track>();
foreach(Track _track in tracks) { if(_track.TrackSession == session) _tracks.Add(_track); }
return _tracks;
}
public override List<Session> GetSessions()
{
return sessions;
}
public override bool? VerifySector(ulong sectorAddress)
{
byte[] buffer = ReadSectorLong(sectorAddress);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return Checksums.CdChecksums.CheckCdSector(buffer);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
public override bool? VerifySector(ulong sectorAddress, uint track)
{
byte[] buffer = ReadSectorLong(sectorAddress, track);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
return Checksums.CdChecksums.CheckCdSector(buffer);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
public override bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
byte[] buffer = ReadSectorsLong(sectorAddress, length);
int bps = (int)(buffer.Length / length);
byte[] sector = new byte[bps];
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
for(int i = 0; i < length; i++)
{
Array.Copy(buffer, i * bps, sector, 0, bps);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
bool? sectorStatus = Checksums.CdChecksums.CheckCdSector(sector);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
switch(sectorStatus)
{
case null:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
unknownLbas.Add((ulong)i + sectorAddress);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case false:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
failingLbas.Add((ulong)i + sectorAddress);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(unknownLbas.Count > 0) return null;
if(failingLbas.Count > 0) return false;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
return true;
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
public override bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
{
byte[] buffer = ReadSectorsLong(sectorAddress, length, track);
int bps = (int)(buffer.Length / length);
byte[] sector = new byte[bps];
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
for(int i = 0; i < length; i++)
{
Array.Copy(buffer, i * bps, sector, 0, bps);
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
bool? sectorStatus = Checksums.CdChecksums.CheckCdSector(sector);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
switch(sectorStatus)
{
case null:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
unknownLbas.Add((ulong)i + sectorAddress);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
case false:
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
failingLbas.Add((ulong)i + sectorAddress);
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
break;
}
}
REFACTOR: Fixed MOST name inconsistencies.
2017-12-20 17:15:26 +00:00
if(unknownLbas.Count > 0) return null;
if(failingLbas.Count > 0) return false;
REFACTOR: Reformat code.
2017-12-19 20:33:03 +00:00
return true;
}
public override bool? VerifyMediaImage()
{
return null;
}
}
}
Reference in New Issue Copy Permalink