/// <summary> /// Patches the file at a given sector in an ISO. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="isoFile">Path to the ISO image</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="sectorNumber">The sector number where the file begins</param> /// <param name="offset">Where in the file to start writing</param> /// <param name="input">Bytes to write</param> public static void PatchFileAtSector(IsoType isoType, string isoFile, bool patchEccEdc, int sectorNumber, long offset, IList <byte> input, bool patchIso) { using (FileStream stream = new FileStream(isoFile, FileMode.Open)) { PatchFileAtSector(isoType, stream, patchEccEdc, sectorNumber, offset, input, patchIso); } }
private void readVolume() { volDesc = new GDFVolumeDescriptor(); volDesc.SectorSize = 0x800; fr.Seek(0x20 * volDesc.SectorSize, SeekOrigin.Begin); if (Encoding.ASCII.GetString(fr.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { type = IsoType.Xsf; volDesc.RootOffset = (uint)type; } else { file.Seek((0x20 * volDesc.SectorSize) + 0xfd90000, SeekOrigin.Begin); if (Encoding.ASCII.GetString(fr.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { type = IsoType.Gdf; volDesc.RootOffset = (uint)type; } else { type = IsoType.XGD3; volDesc.RootOffset = (uint)type; } } file.Seek((0x20 * volDesc.SectorSize) + volDesc.RootOffset, SeekOrigin.Begin); volDesc.Identifier = fr.ReadBytes(20); volDesc.RootDirSector = fr.ReadUInt32(); volDesc.RootDirSize = fr.ReadUInt32(); volDesc.ImageCreationTime = fr.ReadBytes(8); volDesc.VolumeSize = (ulong)(fr.BaseStream.Length - volDesc.RootOffset); volDesc.VolumeSectors = (uint)(volDesc.VolumeSize / volDesc.SectorSize); }
private void readVolume() { this.volDesc = new GDFVolumeDescriptor(); this.volDesc.SectorSize = 0x800; this.fr.Seek((long)(0x20 * this.volDesc.SectorSize), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.fr.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.type = IsoType.Xsf; this.volDesc.RootOffset = (uint)this.type; } else { this.file.Seek((long)((0x20 * this.volDesc.SectorSize) + 0xfd90000), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.fr.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.type = IsoType.Gdf; this.volDesc.RootOffset = (uint)this.type; } else { this.type = IsoType.XGD3; this.volDesc.RootOffset = (uint)this.type; } } this.file.Seek((long)((0x20 * this.volDesc.SectorSize) + this.volDesc.RootOffset), SeekOrigin.Begin); this.volDesc.Identifier = this.fr.ReadBytes(20); this.volDesc.RootDirSector = this.fr.ReadUInt32(); this.volDesc.RootDirSize = this.fr.ReadUInt32(); this.volDesc.ImageCreationTime = this.fr.ReadBytes(8); this.volDesc.VolumeSize = (ulong)(this.fr.BaseStream.Length - this.volDesc.RootOffset); this.volDesc.VolumeSectors = (uint)(this.volDesc.VolumeSize / ((ulong)this.volDesc.SectorSize)); }
/// <summary> /// Creates a new instance to store a value of a given type. This constructor /// is used for variable-length types (LLVAR, LLLVAR, ALPHA, NUMERIC) - /// variable in the sense that that length of the value does not depend /// solely on the ISO type. /// </summary> /// <param name="t">the ISO8583 type of the value to be stored.</param> /// <param name="val">The value to be stored.</param> /// <param name="len">The length of the field.</param> /// <param name="originalValue">The original value of field</param> public IsoValue(IsoType t, Parsing.ConfigParser.Base configBase, Object val, Int32 len, String originalValue, TypeElement typeElement) { if (val == null) { throw new ArgumentException("Value cannot be null"); } type = t; fval = val; length = len; b = configBase; this.originalValue = originalValue; if (typeElement == TypeElement.Field || typeElement == TypeElement.SubField) { if (length == 0 && IsoTypeHelper.NeedsLength(t)) { throw new ArgumentException("Length must be greater than zero"); } } if (t == IsoType.LLVAR || t == IsoType.LLLVAR) { length = val.ToString().Length; } }
public static string Format(this IsoType isoType, long value, int length) { if (isoType == IsoType.NUMERIC) { var x = value.ToString().PadLeft(length, '0'); if (x.Length > length) { throw new ArgumentException("Numeric value is larger than intended length: " + value + " LEN " + length); } return(x); } if (isoType == IsoType.ALPHA || isoType == IsoType.LLVAR || isoType == IsoType.LLLVAR || isoType == IsoType.LLLLVAR) { return(isoType.Format(Convert.ToString(value), length)); } if (isoType == IsoType.AMOUNT) { return(value.ToString("0000000000") + "00"); } if (isoType == IsoType.BINARY || isoType == IsoType.LLBIN || isoType == IsoType.LLLBIN || isoType == IsoType.LLLLBIN) { //TODO } throw new ArgumentException("Cannot format number as " + isoType); }
/// <summary> /// Creates a new instance to store a value of a given type. This constructor /// is used for variable-length types (LLVAR, LLLVAR, ALPHA, NUMERIC) - /// variable in the sense that that length of the value does not depend /// solely on the ISO type. /// </summary> /// <param name="t">the ISO8583 type of the value to be stored.</param> /// <param name="val">The value to be stored.</param> /// <param name="len">The length of the field.</param> /// <param name="originalValue">The original value of field</param> /// <param name="req">Indicates the requiremts (M,C, CE, ME, O )</param> /// <param name="typeElement">Indicates the Type of Element (Field, SubField, SubElement)</param> public IsoValue(IsoType t, Parsing.ConfigParser.Base configBase, Object val, Int32 len, String originalValue, String req, TypeElement typeElement, Dictionary <Int32, IsoValue> subData, Int32 subElementIDLength, Int32 lengthLengthSubElement) { if (val == null) { throw new ArgumentException("Value cannot be null"); } type = t; fval = val; length = len; this.originalValue = originalValue; requirements = req; this.typeElement = typeElement; this.subElementIDLength = subElementIDLength; this.lengthLengthSubElement = lengthLengthSubElement; this.subData = subData; b = configBase; if (typeElement == TypeElement.Field || typeElement == TypeElement.SubField) { if (length == 0 && IsoTypeHelper.NeedsLength(t)) { throw new ArgumentException("Length must be greater than zero"); } } if (t == IsoType.LLVAR || t == IsoType.LLLVAR) { length = val.ToString().Length; } }
/// <summary> /// Creates a new instance to store a value of a given type. This constructor /// is used for variable-length types (LLVAR, LLLVAR, ALPHA, NUMERIC) - /// variable in the sense that that length of the value does not depend /// solely on the ISO type. /// </summary> /// <param name="t">the ISO8583 type of the value to be stored.</param> /// <param name="val">The value to be stored.</param> /// <param name="len">The length of the field.</param> /// <param name="req">Indicates the requiremts (M,C, CE, ME, O )</param> /// <param name="subData">Collection of subDatas (SubField/SubElements) of field</param> public IsoValue(IsoType t, Parsing.ConfigParser.Base configBase, Object val, Int32 len, String originalValue, String req, Dictionary <Int32, IsoValue> subData) { if (val == null) { throw new ArgumentException("Value cannot be null"); } type = t; fval = val; length = len; b = configBase; this.subData = subData; requirements = req; FormatOriginalValue(); if (length == 0 && IsoTypeHelper.NeedsLength(t)) { throw new ArgumentException("Length must be greater than zero"); } if (t == IsoType.LLVAR || t == IsoType.LLLVAR) { length = val.ToString().Length; } }
public override string ToString() { StringBuilder sb = new StringBuilder(); sb.Append(string.Format("Protease={0}\n", Protease.ToString())); sb.Append(string.Format("RemoveIonWindow={0:0.####} Dalton\n", MzTolerance)); sb.Append("RemoveIsobaricIon=" + IsoType.ToString() + ","); foreach (var ion in FixIonRanges) { sb.Append(string.Format("{0:0.####}-{1:0.####},", ion.First, ion.Second)); } if (RemoveHighRange) { sb.Append(">=" + Protease.GetHighBYFreeWindowDescription() + ","); } if (RemovePrecursorMinusLabel) { sb.Append("Precursor-Label;"); } return(sb.ToString()); }
public static void FixupECC( IsoType isoType, Stream iso ) { int type = (int)isoType; int sectorSize = sectorSizes[type]; byte[] sector = new byte[sectorSize]; if ( iso.Length % sectorSize != 0 ) { throw new ArgumentException( "ISO does not have correct length for its type", "isoType" ); } if ( isoType == IsoType.Mode1 ) { throw new ArgumentException( "Mode1 does not support ECC/EDC", "isoType" ); } Int64 numberOfSectors = iso.Length / sectorSize; iso.Seek( 0, SeekOrigin.Begin ); for ( Int64 i = 0; i < numberOfSectors; i++ ) { iso.Read( sector, 0, sectorSize ); if ( isoType != IsoType.Mode1 && ( sector[0x12] & 8 ) == 0 ) { sector[0x12] = 8; sector[0x16] = 8; } GenerateEccEdc( sector, isoType ); iso.Seek( -sectorSize, SeekOrigin.Current ); iso.Write( sector, 0, sectorSize ); } }
/// <summary> /// Patches the bytes at a given offset. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="iso">Stream that contains the ISO</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="offset">Where in the ISO to start writing</param> /// <param name="input">Bytes to write</param> public static void PatchFile(IsoType isoType, Stream iso, bool patchEccEdc, long offset, IList <byte> input, bool patchIso) { using (MemoryStream inputStream = new MemoryStream(input.ToArray())) { PatchFile(isoType, iso, patchEccEdc, offset, inputStream, patchIso); } }
/// <summary> /// Gets the type of the input. /// </summary> /// <param name="path">The path.</param> /// <param name="videoType">Type of the video.</param> /// <param name="isoType">Type of the iso.</param> /// <returns>InputType.</returns> public static InputType GetInputType(string path, VideoType? videoType, IsoType? isoType) { var type = InputType.AudioFile; if (videoType.HasValue) { switch (videoType.Value) { case VideoType.BluRay: type = InputType.Bluray; break; case VideoType.Dvd: type = InputType.Dvd; break; case VideoType.Iso: if (isoType.HasValue) { switch (isoType.Value) { case IsoType.BluRay: type = InputType.Bluray; break; case IsoType.Dvd: type = InputType.Dvd; break; } } break; } } return type; }
/// <summary> /// Formats a DateTime of the specified IsoType as a string. /// </summary> /// <param name="d">A DateTime object.</param> /// <param name="t">An IsoType (must be DATE10, DATE4, DATE_EXP or TIME).</param> /// <returns>The date formatted as a string according to the specified IsoType.</returns> public static String Format(DateTime d, IsoType t) { if (t == IsoType.DATE10) { return(d.ToString("MMddHHmmss")); } if (t == IsoType.DATE12) { return(d.ToString("yyMMddHHmmss")); } if (t == IsoType.DATE4) { return(d.ToString("MMdd")); } if (t == IsoType.DATE6) { return(d.ToString("yyMMdd")); } if (t == IsoType.DATE_EXP) { return(d.ToString("yyMM")); } if (t == IsoType.TIME) { return(d.ToString("HHmmss")); } throw new ArgumentException("IsoType must be DATE10, DATE12, DATE4, DATE6, DATE_EXP or TIME"); }
public static byte[] ReadFile(IsoType isoType, Stream iso, int fileSector, int offset, int length) { int dataSize = dataSizes[(int)isoType]; int dataStart = dataStarts[(int)isoType]; int sectorSize = sectorSizes[(int)isoType]; int desiredStartSector = fileSector + offset / dataSize; int startOffset = offset % dataSize; int bytesLeftInFirstSector = dataSize - startOffset; iso.Seek(desiredStartSector * sectorSize + dataStart + startOffset, SeekOrigin.Begin); byte[] result = new byte[length]; int bytesRead = iso.Read(result, 0, Math.Min(bytesLeftInFirstSector, length)); desiredStartSector++; while (bytesRead < length) { iso.Seek(desiredStartSector * sectorSize + dataStart, SeekOrigin.Begin); bytesRead += iso.Read(result, bytesRead, Math.Min(length - bytesRead, dataSize)); desiredStartSector++; } return(result); }
/// <summary> /// Creates a new instance to store a value of a fixed-length type. /// Fixed-length types are DATE4, DATE_EXP, DATE10, TIME, AMOUNT. /// </summary> /// <param name="t">The ISO8583 type of the value that is going to be stored.</param> /// <param name="value">The value to store.s</param> /// <param name="originalValue">The original value of field</param> /// <param name="req">Indicates the requiremts (M,C, CE, ME, O )</param> public IsoValue(IsoType t, Parsing.ConfigParser.Base configBase, Object value, String originalValue, String req) { if (value == null) { throw new ArgumentException("Value cannot be null"); } if (IsoTypeHelper.NeedsLength(t)) { throw new ArgumentException("Use IsoValue constructor for Fixed-value types"); } type = t; fval = value; b = configBase; this.originalValue = originalValue; requirements = req; if (t == IsoType.LLVAR || type == IsoType.LLLVAR) { length = value.ToString().Length; } else { length = IsoTypeHelper.GetLength(t); } }
/// <summary> /// Sets the specified value in the specified field, creating an IsoValue internally. /// </summary> /// <param name="index">The field number (2 to 128)</param> /// <param name="value">The value to be stored.</param> /// <param name="encoder">An optional CustomField to encode/decode the value.</param> /// <param name="t"></param> /// <param name="length"></param> /// <returns></returns> public IsoMessage SetValue(int index, object value, ICustomField encoder, IsoType t, int length) { if (index < 2 || index > 128) { throw new IndexOutOfRangeException("Field index must be between 2 and 128"); } if (value == null) { _fields[index] = null; } else { IsoValue v; v = t.NeedsLength() ? new IsoValue(t, value, length, encoder) : new IsoValue(t, value, encoder); v.Encoding = Encoding; _fields[index] = v; } return(this); }
public void Dispose() { this.CloseFile(); this.defaultXeX.Dispose(); this.isoType = IsoType.GDF; this.isoInfo = new XkeyBrew.Utils.IsoGameReader.IsoInfo(); }
public void Dispose() { CloseFile(); this.defaultXeX.Dispose(); this.isoType = IsoType.GDF; this.isoInfo = new IsoInfo(); }
public static void FixupECC(IsoType isoType, Stream iso) { int type = (int)isoType; int sectorSize = sectorSizes[type]; byte[] sector = new byte[sectorSize]; if (iso.Length % sectorSize != 0) { throw new ArgumentException("ISO does not have correct length for its type", "isoType"); } if (isoType == IsoType.Mode1) { throw new ArgumentException("Mode1 does not support ECC/EDC", "isoType"); } Int64 numberOfSectors = iso.Length / sectorSize; iso.Seek(0, SeekOrigin.Begin); for (Int64 i = 0; i < numberOfSectors; i++) { iso.Read(sector, 0, sectorSize); if (isoType != IsoType.Mode1 && (sector[0x12] & 8) == 0) { sector[0x12] = 8; sector[0x16] = 8; } GenerateEccEdc(sector, isoType); iso.Seek(-sectorSize, SeekOrigin.Current); iso.Write(sector, 0, sectorSize); } }
/// <summary> /// Formats a decimal value as an ISO8583 type. /// </summary> /// <param name="value">The decimal value to format.</param> /// <param name="t">The ISO8583 type to format the value as.</param> /// <param name="length">The length for the formatting, useful if the type is NUMERIC or ALPHA.</param> /// <returns>The formatted string representation of the value.</returns> public static String Format(Decimal value, IsoType t, Int32 length) { if (t == IsoType.AMOUNT) { Char[] x = value.ToString("0000000000.00").ToCharArray(); Char[] digits = new Char[12]; Array.Copy(x, digits, 10); Array.Copy(x, 11, digits, 10, 2); return(new String(digits)); } if (t == IsoType.NUMERIC || t == IsoType.ALPHA) { return(Format(value.ToString(), t, length)); } if (t == IsoType.LLVAR || t == IsoType.LLLVAR) { return(value.ToString()); } throw new ArgumentException("IsoType must be AMOUNT, NUMERIC, ALPHA, LLLVAR or LLVAR"); }
/// <summary> /// Returns the length of a type, for types that always have the same /// length, of 0 in case of types that can have a variable length. /// </summary> /// <param name="t">The type in question.</param> /// <returns>The length of the type if it's a fixed-length type, /// or 0 if it's a variable-length type.</returns> public static Int32 GetLength(IsoType t) { if (t == IsoType.DATE10) { return(10); } if (t == IsoType.TIME) { return(6); } if (t == IsoType.AMOUNT || t == IsoType.DATE12) { return(12); } if (t == IsoType.DATE4 || t == IsoType.DATE_EXP) { return(4); } if (t == IsoType.DATE6 || t == IsoType.DATE_EXP) { return(6); } return(0); }
public void Dispose() { this.path = string.Empty; this.isoType = IsoType.GDF; this.xexHeader = null; this.xexHeader.Dispose(); this.defaultXexFile = null; }
/// <summary> /// Disposes object /// </summary> public void Dispose() { path = String.Empty; isoType = IsoType.GDF; xexHeader = null; xexHeader.Dispose(); defaultXexFile = null; }
/// <summary> /// Formats a string to the given length, padding it if necessary. /// </summary> /// <param name="value">The string to format.</param> /// <param name="t">The ISO8583 type to format the string as.</param> /// <param name="length">The length (in case of ALPHA or NUMERIC).</param> /// <returns>The formatted string.</returns> public static string Format(string value, IsoType t, int length) { if (t == IsoType.ALPHA) { char[] c = new char[length]; if (value == null) { value = ""; } else if (value.Length == length) { return(value); } else if (value.Length > length) { return(value.Substring(0, length)); } Array.Copy(value.ToCharArray(), c, value.Length); for (int i = value.Length; i < length; i++) { c[i] = ' '; } return(new string(c)); } else if (t == IsoType.LLVAR || t == IsoType.LLLVAR) { //TAM for packed values if ODD the padd with F if (value.Length % 2 == 0) { return(value); } else { return(value + "F"); } } else if (t == IsoType.NUMERIC) { if (value.Length == length) { return(value); } char[] c = new char[length]; char[] x = value.ToCharArray(); if (x.Length > length) { throw new ArgumentOutOfRangeException("Numeric value is larger than intended length"); } int lim = c.Length - x.Length; for (int i = 0; i < lim; i++) { c[i] = '0'; } Array.Copy(x, 0, c, lim, x.Length); return(new string(c)); } throw new ArgumentException("IsoType must be ALPHA, LLVAR, LLLVAR or NUMERIC"); }
public void Close() { this.volDesc = new GDFVolumeDescriptor(); this.Exceptions.Clear(); this.type = IsoType.Gdf; this.rootDir.Clear(); this.fr.Close(); this.file.Close(); }
public void Close() { this.volDesc = new GDFVolumeDescriptor(); this.Exceptions.Clear(); this.type = IsoType.Gdf; this.rootDir.Clear(); this.fr.Close(); this.file.Close(); }
/// <summary> /// Creates a new instance that knows how to parse a value of the given /// type and the given length (the length is necessary for ALPHA and NUMERIC /// values only). /// </summary> /// <param name="t">The ISO8583 type.</param> /// <param name="len">The length of the value to parse (for ALPHA and NUMERIC values).</param> /// <param name="req">Define mandatory xml item</param> public FieldParseInfo(IsoType t, Int32 len, Boolean req, TypeElement st, Dictionary <Int32, FieldParseInfo> sub, ConfigParser.Base b) { type = t; length = len; required = req; subDataElements_Fields = sub; typeElement = st; this.b = b; }
public void Close() { volDesc = new GDFVolumeDescriptor(); Exceptions.Clear(); type = IsoType.Gdf; rootDir.Clear(); fr.Close(); file.Close(); }
private void ReadIsoData() { try { this.isoInfo = new XkeyBrew.Utils.IsoGameReader.IsoInfo(); this.isoInfo.SectorSize = 0x800; this.reader.BaseStream.Seek((long)(0x20 * (long)this.isoInfo.SectorSize), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.reader.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.isoType = IsoType.XSF; this.isoInfo.RootOffset = (uint)this.isoType; } else { this.file.Seek((long)((0x20 * (long)this.isoInfo.SectorSize) + (long)IsoType.GDF), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.reader.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.isoType = IsoType.GDF; this.isoInfo.RootOffset = (uint)this.isoType; } else { this.file.Seek((long)((0x20 * (long)this.isoInfo.SectorSize) + (long)IsoType.XGD3), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.reader.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.isoType = IsoType.XGD3; this.isoInfo.RootOffset = (uint)this.isoType; } else { this.file.Seek((long)((0x20 * (long)this.isoInfo.SectorSize) + (long)IsoType.XBOX1), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.reader.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.isoType = IsoType.XBOX1; this.isoInfo.RootOffset = (uint)this.isoType; } else { throw new Exception("Invalid Iso Type"); } } } } this.reader.BaseStream.Seek((long)((0x20 * (long)this.isoInfo.SectorSize) + (long)this.isoInfo.RootOffset), SeekOrigin.Begin); this.isoInfo.Identifier = this.reader.ReadBytes(20); this.isoInfo.RootDirSector = this.reader.ReadUInt32(); this.isoInfo.RootDirSize = this.reader.ReadUInt32(); this.isoInfo.ImageCreationTime = this.reader.ReadBytes(8); this.isoInfo.VolumeSize = (ulong)(this.reader.BaseStream.Length - this.isoInfo.RootOffset); this.isoInfo.VolumeSectors = (uint)(this.isoInfo.VolumeSize / ((ulong)this.isoInfo.SectorSize)); } catch (Exception exception) { throw new Exception("Cannot read ISO info", exception); } }
/// <summary> /// Creates a new instance that knows how to parse a value of the given /// type and the given length (the length is necessary for ALPHA and NUMERIC /// values only). /// </summary> /// <param name="t">The ISO8583 type.</param> /// <param name="len">The length of the value to parse (for ALPHA and NUMERIC values).</param> /// <param name="req">Define mandatory xml item</param> public FieldParseInfo(IsoType t, Int32 len, Boolean req, TypeElement st, Dictionary <Int32, FieldParseInfo> sub, Int32 subElementIDLength, Int32 lengthLengthSubElement) { type = t; length = len; required = req; typeElement = st; this.subElementIDLength = subElementIDLength; this.lengthLengthSubElement = lengthLengthSubElement; subDataElements_Fields = sub; }
/// <summary> /// Sets the specified value in the specified field, creating an IsoValue internally. /// </summary> /// <param name="index">The field number (2 to 128)</param> /// <param name="value">The value to be stored.</param> /// <param name="t">he ISO type.</param> /// <param name="length">The length of the field, used for ALPHA and NUMERIC values only, ignored with any other type.</param> /// <returns></returns> public IsoMessage SetValue(int index, object value, IsoType t, int length) { return(SetValue(index, value, null, t, length)); }
/// <summary> /// Patches the file at a given sector in an ISO. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="iso">Stream that contains the ISO</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="sectorNumber">The sector number where the file begins</param> /// <param name="offset">Where in the file to start writing</param> /// <param name="input">Bytes to write</param> public static void PatchFileAtSector(IsoType isoType, Stream iso, bool patchEccEdc, int sectorNumber, long offset, IList <byte> input, bool patchIso) { int dataSize = dataSizes[(int)isoType]; int dataStart = dataStarts[(int)isoType]; int sectorSize = sectorSizes[(int)isoType]; long sectorsToAdvance = offset / dataSize; long newOffset = offset % dataSize; long realOffset = (sectorNumber + sectorsToAdvance) * sectorSize + dataStart + newOffset; PatchFile(isoType, iso, patchEccEdc, realOffset, input, patchIso); }
public CompositeField AddValue(object val, ICustomField encoder, IsoType t, int length) { return(AddValue(t.NeedsLength() ? new IsoValue(t, val, length, encoder) : new IsoValue(t, val, encoder))); }
/// <summary> /// Formats a number as an ISO8583 type. /// </summary> /// <param name="value">The number to format.</param> /// <param name="t">The ISO8583 type to format the value as.</param> /// <param name="length">The length to format to (in case of ALPHA or NUMERIC)</param> /// <returns>The formatted string representation of the value.</returns> public static string Format(long value, IsoType t, int length) { if (t == IsoType.NUMERIC || t == IsoType.ALPHA) { return(Format(value.ToString(), t, length)); } else if (t == IsoType.LLLVAR || t == IsoType.LLVAR) { return(value.ToString()); } else if (t == IsoType.AMOUNT) { return(value.ToString("0000000000") + "00"); } throw new ArgumentException("IsoType must be AMOUNT, NUMERIC, ALPHA, LLLVAR or LLVAR"); }
/// <summary> /// Gets the input argument. /// </summary> /// <param name="videoPath">The video path.</param> /// <param name="isRemote">if set to <c>true</c> [is remote].</param> /// <param name="videoType">Type of the video.</param> /// <param name="isoType">Type of the iso.</param> /// <param name="isoMount">The iso mount.</param> /// <param name="playableStreamFileNames">The playable stream file names.</param> /// <param name="type">The type.</param> /// <returns>System.String[][].</returns> public static string[] GetInputArgument(string videoPath, bool isRemote, VideoType videoType, IsoType? isoType, IIsoMount isoMount, IEnumerable<string> playableStreamFileNames, out InputType type) { var inputPath = isoMount == null ? new[] { videoPath } : new[] { isoMount.MountedPath }; type = InputType.File; switch (videoType) { case VideoType.BluRay: type = InputType.Bluray; inputPath = GetPlayableStreamFiles(inputPath[0], playableStreamFileNames).ToArray(); break; case VideoType.Dvd: type = InputType.Dvd; inputPath = GetPlayableStreamFiles(inputPath[0], playableStreamFileNames).ToArray(); break; case VideoType.Iso: if (isoType.HasValue) { switch (isoType.Value) { case IsoType.BluRay: type = InputType.Bluray; inputPath = GetPlayableStreamFiles(inputPath[0], playableStreamFileNames).ToArray(); break; case IsoType.Dvd: type = InputType.Dvd; inputPath = GetPlayableStreamFiles(inputPath[0], playableStreamFileNames).ToArray(); break; } } break; case VideoType.VideoFile: { if (isRemote) { type = InputType.Url; } break; } } return inputPath; }
/// <summary> /// Main constructor of IsoGameInfo /// </summary> /// <param name="path">path to iso file</param> public IsoGameInfo(string path) { try { this.path = path; Iso iso = new Iso(path); this.xexHeader = ObjectCopier.Clone<XeXHeader>(iso.DefaultXeX.XeXHeader); this.defaultXexFile = new byte[iso.DefaultXeX.File.Length]; iso.DefaultXeX.File.CopyTo(this.defaultXexFile, 0); this.isoType = iso.IsoType; //this.gameInfo = new GameInfo(this.xexHeader.TitleId); iso.Dispose(); iso = null; } catch (Exception ex) { throw ex; } }
private void readVolume() { this.volDesc = new GDFVolumeDescriptor(); this.volDesc.SectorSize = 0x800; this.fr.Seek((long) (0x20 * this.volDesc.SectorSize), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.fr.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.type = IsoType.Xsf; this.volDesc.RootOffset = (uint) this.type; } else { this.file.Seek((long) ((0x20 * this.volDesc.SectorSize) + 0xfd90000), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.fr.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.type = IsoType.Gdf; this.volDesc.RootOffset = (uint) this.type; } else { this.type = IsoType.XGD3; this.volDesc.RootOffset = (uint) this.type; } } this.file.Seek((long) ((0x20 * this.volDesc.SectorSize) + this.volDesc.RootOffset), SeekOrigin.Begin); this.volDesc.Identifier = this.fr.ReadBytes(20); this.volDesc.RootDirSector = this.fr.ReadUInt32(); this.volDesc.RootDirSize = this.fr.ReadUInt32(); this.volDesc.ImageCreationTime = this.fr.ReadBytes(8); this.volDesc.VolumeSize = (ulong) (this.fr.BaseStream.Length - this.volDesc.RootOffset); this.volDesc.VolumeSectors = (uint) (this.volDesc.VolumeSize / ((ulong) this.volDesc.SectorSize)); }
public void Dispose() { CloseFile(); this.defaultXeX.Dispose(); this.isoType = IsoType.GDF; this.isoInfo = new IsoInfo(); }
/// <summary> /// Reads file system info /// </summary> private void ReadIsoData() { try { this.isoInfo = new IsoInfo(); this.isoInfo.SectorSize = 0x800; this.reader.BaseStream.Seek((long)(0x20 * this.isoInfo.SectorSize), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.reader.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.isoType = IsoType.XSF; this.isoInfo.RootOffset = (uint)this.isoType; } else { this.file.Seek((long)((0x20 * this.isoInfo.SectorSize) + 0xfd90000), SeekOrigin.Begin); if (Encoding.ASCII.GetString(this.reader.ReadBytes(20)) == "MICROSOFT*XBOX*MEDIA") { this.isoType = IsoType.GDF; this.isoInfo.RootOffset = (uint)this.isoType; } else { this.isoType = IsoType.XGD3; this.isoInfo.RootOffset = (uint)this.isoType; } } this.reader.BaseStream.Seek((long)((0x20 * this.isoInfo.SectorSize) + this.isoInfo.RootOffset), SeekOrigin.Begin); this.isoInfo.Identifier = this.reader.ReadBytes(20); this.isoInfo.RootDirSector = this.reader.ReadUInt32(); this.isoInfo.RootDirSize = this.reader.ReadUInt32(); this.isoInfo.ImageCreationTime = this.reader.ReadBytes(8); this.isoInfo.VolumeSize = (ulong)(this.reader.BaseStream.Length - this.isoInfo.RootOffset); this.isoInfo.VolumeSectors = (uint)(this.isoInfo.VolumeSize / ((ulong)this.isoInfo.SectorSize)); } catch (Exception ex) { throw new Exception("Cannot read ISO info", ex); } }
public static void GenerateEccEdc( IList<byte> sector, IsoType isoType ) { switch( isoType ) { case IsoType.Mode2Form1: ComputeEdcBlock( sector.Sub( 0x10 ), 0x808, sector.Sub( 0x818 ) ); GenerateEcc( sector, true ); break; case IsoType.Mode2Form2: ComputeEdcBlock( sector.Sub( 0x10 ), 0x91C, sector.Sub( 0x92C ) ); break; case IsoType.Mode1: default: throw new ArgumentException( "isotype" ); } }
/// <summary> /// Patches the bytes at a given offset. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="iso">Stream that contains the ISO</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="offset">Where in the ISO to start writing</param> /// <param name="input">Bytes to write</param> public static void PatchFile( IsoType isoType, Stream iso, bool patchEccEdc, long offset, IList<byte> input, bool patchIso ) { using ( MemoryStream inputStream = new MemoryStream( input.ToArray() ) ) { PatchFile( isoType, iso, patchEccEdc, offset, inputStream, patchIso ); } }
/// <summary> /// Patches the bytes at a given offset. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="iso">Stream that contains the ISO</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="offset">Where in the ISO to start writing</param> /// <param name="input">Stream that contains the bytes to write</param> public static void PatchFile( IsoType isoType, Stream iso, bool patchEccEdc, long offset, Stream input, bool patchIso ) { int type = (int)isoType; int sectorSize = sectorSizes[type]; byte[] sector = new byte[sectorSize]; long sectorStart = offset % sectorSize; if( sectorStart < dataStarts[type] || sectorStart >= (dataStarts[type] + dataSizes[type]) ) { throw new ArgumentException( "start offset is incorrect", "offset" ); } if( patchEccEdc && isoType == IsoType.Mode1 ) { throw new ArgumentException( "Mode1 does not support ECC/EDC", "patchEccEdc" ); } long sectorLength = dataSizes[type] + dataStarts[type] - sectorStart; int totalPatchedBytes = 0; int sizeRead = 0; long temp = offset - (offset % sectorSize); iso.Seek( temp, SeekOrigin.Begin ); input.Seek( 0, SeekOrigin.Begin ); while( input.Position < input.Length ) { iso.Read( sector, 0, sectorSize ); byte[] originalSector = sector.ToArray(); sizeRead = input.Read( sector, (int)sectorStart, (int)sectorLength ); if( isoType != IsoType.Mode1 && (sector[0x12] & 8) == 0 ) { sector[0x12] = 8; sector[0x16] = 8; } if( patchEccEdc ) { GenerateEccEdc( sector, isoType ); } iso.Seek( -sectorSize, SeekOrigin.Current ); if( patchIso ) { iso.Write( sector, 0, sectorSize ); } else { iso.Seek( sectorSize, SeekOrigin.Current ); } totalPatchedBytes += sizeRead; sectorStart = dataStarts[type]; sectorLength = dataSizes[type]; } }
/// <summary> /// Patches the file at a given sector in an ISO. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="isoFile">Path to the ISO image</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="sectorNumber">The sector number where the file begins</param> /// <param name="input">Bytes to write</param> public static void PatchFileAtSector( IsoType isoType, string isoFile, bool patchEccEdc, int sectorNumber, IList<byte> input, bool patchIso ) { PatchFileAtSector( isoType, isoFile, patchEccEdc, sectorNumber, 0, input, patchIso ); }
/// <summary> /// Patches the file at a given sector in an ISO. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="isoFile">Path to the ISO image</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="sectorNumber">The sector number where the file begins</param> /// <param name="offset">Where in the file to start writing</param> /// <param name="input">Bytes to write</param> public static void PatchFileAtSector( IsoType isoType, string isoFile, bool patchEccEdc, int sectorNumber, long offset, IList<byte> input, bool patchIso ) { using ( FileStream stream = new FileStream( isoFile, FileMode.Open ) ) { PatchFileAtSector( isoType, stream, patchEccEdc, sectorNumber, offset, input, patchIso ); } }
/// <summary> /// Patches the file at a given sector in an ISO. /// </summary> /// <param name="isoType">The type of ISO</param> /// <param name="iso">Stream that contains the ISO</param> /// <param name="patchEccEdc">Whether or not ECC/EDC blocks should be updated</param> /// <param name="sectorNumber">The sector number where the file begins</param> /// <param name="offset">Where in the file to start writing</param> /// <param name="input">Bytes to write</param> public static void PatchFileAtSector( IsoType isoType, Stream iso, bool patchEccEdc, int sectorNumber, long offset, IList<byte> input, bool patchIso ) { int dataSize = dataSizes[(int)isoType]; int dataStart = dataStarts[(int)isoType]; int sectorSize = sectorSizes[(int)isoType]; long sectorsToAdvance = offset / dataSize; long newOffset = offset % dataSize; long realOffset = (sectorNumber + sectorsToAdvance) * sectorSize + dataStart + newOffset; PatchFile( isoType, iso, patchEccEdc, realOffset, input, patchIso ); }
public static byte[] ReadFile( IsoType isoType, Stream iso, int fileSector, int offset, int length ) { int dataSize = dataSizes[(int)isoType]; int dataStart = dataStarts[(int)isoType]; int sectorSize = sectorSizes[(int)isoType]; int desiredStartSector = fileSector + offset / dataSize; int startOffset = offset % dataSize; int bytesLeftInFirstSector = dataSize - startOffset; iso.Seek( desiredStartSector * sectorSize + dataStart + startOffset, SeekOrigin.Begin ); byte[] result = new byte[length]; int bytesRead = iso.Read( result, 0, Math.Min( bytesLeftInFirstSector, length ) ); desiredStartSector++; while ( bytesRead < length ) { iso.Seek( desiredStartSector * sectorSize + dataStart, SeekOrigin.Begin ); bytesRead += iso.Read( result, bytesRead, Math.Min( length - bytesRead, dataSize) ); desiredStartSector++; } return result; }
/// <summary> /// Disposes object /// </summary> public void Dispose() { path = String.Empty; isoType = IsoType.GDF; xexHeader = null; xexHeader.Dispose(); defaultXexFile = null; }
/// <summary> /// Gets the probe size argument. /// </summary> /// <param name="mediaPath">The media path.</param> /// <param name="isVideo">if set to <c>true</c> [is video].</param> /// <param name="videoType">Type of the video.</param> /// <param name="isoType">Type of the iso.</param> /// <returns>System.String.</returns> protected string GetProbeSizeArgument(string mediaPath, bool isVideo, VideoType? videoType, IsoType? isoType) { var type = !isVideo ? MediaEncoderHelpers.GetInputType(mediaPath, null, null) : MediaEncoderHelpers.GetInputType(mediaPath, videoType, isoType); return MediaEncoder.GetProbeSizeArgument(type); }