protected void SetIsoType(Video video)
{
if (video.VideoType == VideoType.Iso)
{
if (video.Path.Contains("dvd", StringComparison.OrdinalIgnoreCase))
{
video.IsoType = IsoType.Dvd;
}
else if (video.Path.Contains("bluray", StringComparison.OrdinalIgnoreCase))
{
video.IsoType = IsoType.BluRay;
}
else
{
// use disc-utils, both DVDs and BDs use UDF filesystem
using (var videoFileStream = File.Open(video.Path, FileMode.Open, FileAccess.Read))
using (UdfReader udfReader = new UdfReader(videoFileStream))
{
if (udfReader.DirectoryExists("VIDEO_TS"))
{
video.IsoType = IsoType.Dvd;
}
else if (udfReader.DirectoryExists("BDMV"))
{
video.IsoType = IsoType.BluRay;
}
}
}
}
}
public TSStreamClipFile(FileInfo fileInfo)
{
FileInfo = fileInfo;
DFileInfo = null;
CdReader = null;
Name = fileInfo.Name.ToUpper();
}
public TSInterleavedFile(FileInfo fileInfo)
{
FileInfo = fileInfo;
DFileInfo = null;
_cdReader = null;
Name = fileInfo.Name.ToUpper();
}
public TSInterleavedFile(DiscFileInfo fileInfo, UdfReader reader)
{
DFileInfo = fileInfo;
FileInfo = null;
_cdReader = reader;
Name = fileInfo.Name.ToUpper();
}
public TSStreamClipFile(DiscFileInfo fileInfo,
UdfReader reader)
{
DFileInfo = fileInfo;
FileInfo = null;
CdReader = reader;
Name = fileInfo.Name.ToUpper();
}
void ExtractISO(string ISOName, string ExtractionPath)
{
using (FileStream ISOStream = File.Open(ISOName, FileMode.Open))
{
UdfReader Reader = new UdfReader(ISOStream);
ExtractDirectory(Reader.Root, ExtractionPath + "\\", "");
Reader.Dispose();
}
}
public TSPlaylistFile(
BDROM bdrom,
FileInfo fileInfo)
{
BDROM = bdrom;
FileInfo = fileInfo;
DFileInfo = null;
CdReader = null;
Name = fileInfo.Name.ToUpper();
}
public TSPlaylistFile(
BDROM bdrom,
DiscFileInfo fileInfo,
UdfReader reader)
{
BDROM = bdrom;
DFileInfo = fileInfo;
FileInfo = null;
CdReader = reader;
Name = fileInfo.Name.ToUpper();
}
public void CloseDiscImage()
{
if (IsImage && CdReader != null)
{
CdReader.Dispose();
CdReader = null;
IoStream.Close();
IoStream.Dispose();
IoStream = null;
}
}
public void GetThumbnail(uint cx, out IntPtr phbmp, out WTS_ALPHATYPE pdwAlpha)
{
phbmp = IntPtr.Zero;
pdwAlpha = WTS_ALPHATYPE.WTSAT_UNKNOWN;
if (cx == 0 || cx > MaxThumbnailSize)
{
return;
}
Bitmap thumbnail = null;
using (FileStream isoStream = File.OpenRead(this.FilePath))
{
UdfReader cd = new UdfReader(isoStream);
//read META\DL img
if (cd.Exists(@"BDMV\META\DL"))
{
string[] files = cd.GetFiles(@"BDMV\META\DL", "*.jpg");
//find file that size is most similar and bigger than cx;
foreach (var item in files)
{
Stream fileStream = cd.OpenFile(item, FileMode.Open);
Bitmap bmp = new Bitmap(fileStream);
if (thumbnail != null)
{
if ((cx < Math.Max(thumbnail.Width, thumbnail.Height) && Math.Max(bmp.Width, bmp.Height) < Math.Max(thumbnail.Width, thumbnail.Height)) ||
(cx > Math.Max(thumbnail.Width, thumbnail.Height) && Math.Max(bmp.Width, bmp.Height) > Math.Max(thumbnail.Width, thumbnail.Height)))
{
thumbnail = bmp;
}
}
}
if (thumbnail == null)
{
return;
}
if (thumbnail.Width != cx && thumbnail.Height != cx)
{
// We are not the appropriate size for caller. Resize now while
// respecting the aspect ratio.
float scale = Math.Min((float)cx / thumbnail.Width, (float)cx / thumbnail.Height);
int scaleWidth = (int)(thumbnail.Width * scale);
int scaleHeight = (int)(thumbnail.Height * scale);
thumbnail = ResizeImage(thumbnail, scaleWidth, scaleHeight);
}
phbmp = thumbnail.GetHbitmap();
pdwAlpha = WTS_ALPHATYPE.WTSAT_RGB;
}
}
}
public override FileSystemInfo[] Detect(Stream stream, VolumeInfo volume)
{
List <FileSystemInfo> detected = new List <FileSystemInfo>();
if (UdfReader.Detect(stream))
{
detected.Add(new VfsFileSystemInfo("UDF", "OSTA Universal Disk Format (UDF)", OpenUdf));
}
if (CDReader.Detect(stream))
{
detected.Add(new VfsFileSystemInfo("ISO9660", "ISO 9660 (CD-ROM)", OpenIso));
}
return(detected.ToArray());
}
public static void CopyFilesfromISO(string isoName, string baseDirectory)
{
using (FileStream isoStream = File.OpenRead(isoName))
{
if (UdfReader.Detect(isoStream))
{
using (UdfReader iso = new UdfReader(isoStream))
{
DoCopyFilesfromISO(iso, baseDirectory);
}
}
else if (CDReader.Detect(isoStream))
{
using (CDReader iso = new CDReader(isoStream, true))
{
DoCopyFilesfromISO(iso, baseDirectory);
}
}
}
}
public static IFileSystem GetFileSystem(Stream underlayingStream)
{
// Try UDF access first; if that doesn't work, try iso9660
try
{
if (!UdfReader.Detect(underlayingStream))
{
throw new ArgumentException("The given stream does not contain a valid UDF filesystem");
}
return(new UdfReader(underlayingStream));
}
catch
{
if (!CDReader.Detect(underlayingStream))
{
throw new ArgumentException("The given stream does neither contain a valid UDF nor a valid ISO9660 filesystem");
}
return(new CDReader(underlayingStream, true, true));
}
}
/// <summary>
/// The get files.
/// </summary>
public void GetFiles()
{
using (var fileStream = new FileStream(this.IsoPath, FileMode.Open))
{
DiscFileSystem fs;
if (UdfReader.Detect(fileStream))
{
fs = new UdfReader(fileStream);
}
else
{
fs = new CDReader(fileStream, true);
}
// DiscUtils.Iso9660.CDReader reader = new CDReader(fs, true);
var returnFiles = new List <string>();
this.Files.AddRange(RecursiveFolders(fs, fs.Root.FullName));
}
}
protected void SetIsoType(Video video)
{
if (video.VideoType == VideoType.Iso)
{
if (video.Path.Contains("dvd", StringComparison.OrdinalIgnoreCase))
{
video.IsoType = IsoType.Dvd;
}
else if (video.Path.Contains("bluray", StringComparison.OrdinalIgnoreCase))
{
video.IsoType = IsoType.BluRay;
}
else
{
try
{
// use disc-utils, both DVDs and BDs use UDF filesystem
using (var videoFileStream = File.Open(video.Path, FileMode.Open, FileAccess.Read))
using (UdfReader udfReader = new UdfReader(videoFileStream))
{
if (udfReader.DirectoryExists("VIDEO_TS"))
{
video.IsoType = IsoType.Dvd;
}
else if (udfReader.DirectoryExists("BDMV"))
{
video.IsoType = IsoType.BluRay;
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error opening UDF/ISO image: {Value}", video.Path ?? video.Name);
}
}
}
}
static bool ProcessRecoveryISO(Stream isoStream, string outputPath, bool extractFiles = true, bool consoleOutput = true)
{
if (ProcessRecoveryGDF(isoStream, outputPath, extractFiles, consoleOutput))
{
return(true);
}
DiscUtils.Vfs.VfsFileSystemFacade vfs = new CDReader(isoStream, true, false);
if (!vfs.FileExists("recctrl.bin"))
{
vfs = new UdfReader(isoStream);
}
if (!vfs.FileExists("recctrl.bin"))
{
Console.WriteLine("Failed to find recctrl.bin inside image!");
return(false);
}
using (var reader = new BinaryReader(vfs.OpenFile("recctrl.bin", FileMode.Open)))
{
Stream dataStream = null;
if (extractFiles)
{
dataStream = vfs.OpenFile("recdata.bin", FileMode.Open);
}
bool res = ProcessRecovery(reader, dataStream, outputPath, consoleOutput);
if (dataStream != null)
{
dataStream.Close();
}
return(res);
}
}
public BDROM(
string path)
{
//
// Locate BDMV directories.
//
if ((new FileInfo(path).Attributes & FileAttributes.Directory) != FileAttributes.Directory)
{
IsImage = true;
IoStream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
CdReader = new UdfReader(IoStream);
}
if (!IsImage)
{
DirectoryBDMV = GetDirectoryBDMV(path);
}
else
{
DiscDirectoryBDMV = GetDiscDirectoryBDMV();
}
if ((!IsImage && DirectoryBDMV == null) || (IsImage && DiscDirectoryBDMV == null))
{
throw new Exception("Unable to locate BD structure.");
}
if (IsImage)
{
DiscDirectoryRoot = DiscDirectoryBDMV.Parent;
DiscDirectoryBDJO = GetDiscDirectory("BDJO", DiscDirectoryBDMV, 0);
DiscDirectoryCLIPINF = GetDiscDirectory("CLIPINF", DiscDirectoryBDMV, 0);
DiscDirectoryPLAYLIST = GetDiscDirectory("PLAYLIST", DiscDirectoryBDMV, 0);
DiscDirectorySNP = GetDiscDirectory("SNP", DiscDirectoryRoot, 0);
DiscDirectorySTREAM = GetDiscDirectory("STREAM", DiscDirectoryBDMV, 0);
DiscDirectorySSIF = GetDiscDirectory("SSIF", DiscDirectorySTREAM, 0);
DiscDirectoryMETA = GetDiscDirectory("META", DiscDirectoryBDMV, 0);
}
else
{
DirectoryRoot = DirectoryBDMV.Parent;
DirectoryBDJO = GetDirectory("BDJO", DirectoryBDMV, 0);
DirectoryCLIPINF = GetDirectory("CLIPINF", DirectoryBDMV, 0);
DirectoryPLAYLIST = GetDirectory("PLAYLIST", DirectoryBDMV, 0);
DirectorySNP = GetDirectory("SNP", DirectoryRoot, 0);
DirectorySTREAM = GetDirectory("STREAM", DirectoryBDMV, 0);
DirectorySSIF = GetDirectory("SSIF", DirectorySTREAM, 0);
DirectoryMETA = GetDirectory("META", DirectoryBDMV, 0);
}
if ((!IsImage & (DirectoryCLIPINF == null || DirectoryPLAYLIST == null)) || (IsImage & (DiscDirectoryCLIPINF == null || DiscDirectoryPLAYLIST == null)))
{
throw new Exception("Unable to locate BD structure.");
}
//
// Initialize basic disc properties.
//
if (IsImage)
{
VolumeLabel = CdReader.VolumeLabel;
Size = (ulong)GetDiscDirectorySize(DiscDirectoryRoot);
var indexFiles = DiscDirectoryBDMV?.GetFiles();
DiscFileInfo indexFile = null;
for (int i = 0; i < indexFiles?.Length; i++)
{
if (indexFiles[i].Name.ToLower() == "index.bdmv")
{
indexFile = indexFiles[i];
break;
}
}
if (indexFile != null)
{
using (var indexStream = indexFile.OpenRead())
{
ReadIndexVersion(indexStream);
}
}
if (null != GetDiscDirectory("BDSVM", DiscDirectoryRoot, 0))
{
IsBDPlus = true;
}
if (null != GetDiscDirectory("SLYVM", DiscDirectoryRoot, 0))
{
IsBDPlus = true;
}
if (null != GetDiscDirectory("ANYVM", DiscDirectoryRoot, 0))
{
IsBDPlus = true;
}
if (DiscDirectoryBDJO != null &&
DiscDirectoryBDJO.GetFiles().Length > 0)
{
IsBDJava = true;
}
if (DiscDirectorySNP != null &&
(DiscDirectorySNP.GetFiles("*.mnv").Length > 0 || DiscDirectorySNP.GetFiles("*.MNV").Length > 0))
{
IsPSP = true;
}
if (DiscDirectorySSIF != null &&
DiscDirectorySSIF.GetFiles().Length > 0)
{
Is3D = true;
}
DiscFileInfo[] discFiles = DiscDirectoryRoot.GetFiles("FilmIndex.xml");
if (discFiles != null && discFiles.Length > 0)
{
IsDBOX = true;
}
if (DiscDirectoryMETA != null)
{
DiscFileInfo[] metaFiles = DiscDirectoryMETA.GetFiles("bdmt_eng.xml", SearchOption.AllDirectories);
if (metaFiles != null && metaFiles.Length > 0)
{
ReadDiscTitle(metaFiles[0].OpenText());
}
}
//
// Initialize file lists.
//
if (DiscDirectoryPLAYLIST != null)
{
DiscFileInfo[] files = DiscDirectoryPLAYLIST.GetFiles("*.mpls");
if (files.Length == 0)
{
files = DiscDirectoryPLAYLIST.GetFiles("*.MPLS");
}
foreach (DiscFileInfo file in files)
{
PlaylistFiles.Add(file.Name.ToUpper(), new TSPlaylistFile(this, file, CdReader));
}
}
if (DiscDirectorySTREAM != null)
{
DiscFileInfo[] files = DiscDirectorySTREAM.GetFiles("*.m2ts");
if (files.Length == 0)
{
files = DiscDirectoryPLAYLIST.GetFiles("*.M2TS");
}
foreach (DiscFileInfo file in files)
{
StreamFiles.Add(file.Name.ToUpper(), new TSStreamFile(file, CdReader));
}
}
if (DiscDirectoryCLIPINF != null)
{
DiscFileInfo[] files = DiscDirectoryCLIPINF.GetFiles("*.clpi");
if (files.Length == 0)
{
files = DiscDirectoryPLAYLIST.GetFiles("*.CLPI");
}
foreach (DiscFileInfo file in files)
{
StreamClipFiles.Add(file.Name.ToUpper(), new TSStreamClipFile(file, CdReader));
}
}
if (DiscDirectorySSIF != null)
{
DiscFileInfo[] files = DiscDirectorySSIF.GetFiles("*.ssif");
if (files.Length == 0)
{
files = DiscDirectorySSIF.GetFiles("*.SSIF");
}
foreach (DiscFileInfo file in files)
{
InterleavedFiles.Add(file.Name.ToUpper(), new TSInterleavedFile(file, CdReader));
}
}
}
else
{
VolumeLabel = GetVolumeLabel(DirectoryRoot);
Size = (ulong)GetDirectorySize(DirectoryRoot);
var indexFiles = DirectoryBDMV.GetFiles();
FileInfo indexFile = null;
for (int i = 0; i < indexFiles.Length; i++)
{
if (indexFiles[i].Name.ToLower() == "index.bdmv")
{
indexFile = indexFiles[i];
break;
}
}
if (indexFile != null)
{
using (var indexStream = indexFile.OpenRead())
{
ReadIndexVersion(indexStream);
}
}
if (null != GetDirectory("BDSVM", DirectoryRoot, 0))
{
IsBDPlus = true;
}
if (null != GetDirectory("SLYVM", DirectoryRoot, 0))
{
IsBDPlus = true;
}
if (null != GetDirectory("ANYVM", DirectoryRoot, 0))
{
IsBDPlus = true;
}
if (DirectoryBDJO != null &&
DirectoryBDJO.GetFiles().Length > 0)
{
IsBDJava = true;
}
if (DirectorySNP != null &&
(DirectorySNP.GetFiles("*.mnv").Length > 0 || DirectorySNP.GetFiles("*.MNV").Length > 0))
{
IsPSP = true;
}
if (DirectorySSIF != null &&
DirectorySSIF.GetFiles().Length > 0)
{
Is3D = true;
}
if (File.Exists(Path.Combine(DirectoryRoot.FullName, "FilmIndex.xml")))
{
IsDBOX = true;
}
if (DirectoryMETA != null)
{
FileInfo[] metaFiles = DirectoryMETA.GetFiles("bdmt_eng.xml", SearchOption.AllDirectories);
if (metaFiles != null && metaFiles.Length > 0)
{
ReadDiscTitle(metaFiles[0].OpenText());
}
}
//
// Initialize file lists.
//
if (DirectoryPLAYLIST != null)
{
FileInfo[] files = DirectoryPLAYLIST.GetFiles("*.mpls");
if (files.Length == 0)
{
files = DirectoryPLAYLIST.GetFiles("*.MPLS");
}
foreach (FileInfo file in files)
{
PlaylistFiles.Add(
file.Name.ToUpper(), new TSPlaylistFile(this, file));
}
}
if (DirectorySTREAM != null)
{
FileInfo[] files = DirectorySTREAM.GetFiles("*.m2ts");
if (files.Length == 0)
{
files = DirectoryPLAYLIST.GetFiles("*.M2TS");
}
foreach (FileInfo file in files)
{
StreamFiles.Add(
file.Name.ToUpper(), new TSStreamFile(file));
}
}
if (DirectoryCLIPINF != null)
{
FileInfo[] files = DirectoryCLIPINF.GetFiles("*.clpi");
if (files.Length == 0)
{
files = DirectoryPLAYLIST.GetFiles("*.CLPI");
}
foreach (FileInfo file in files)
{
StreamClipFiles.Add(
file.Name.ToUpper(), new TSStreamClipFile(file));
}
}
if (DirectorySSIF != null)
{
FileInfo[] files = DirectorySSIF.GetFiles("*.ssif");
if (files.Length == 0)
{
files = DirectorySSIF.GetFiles("*.SSIF");
}
foreach (FileInfo file in files)
{
InterleavedFiles.Add(
file.Name.ToUpper(), new TSInterleavedFile(file));
}
}
}
}
/**************************************************************************************************************
* ISO Extract
*************************************************************************************************************/
public bool ExtractISO(string in_sIsoPathAndFileName
, string in_sIsoExtractionRootDir
, bool in_bCreateSubdirectory)
{
try
{
using (FileStream ISOStream = File.Open(in_sIsoPathAndFileName, FileMode.Open))
{
DiscUtils.FileSystemManager oMgr = new FileSystemManager();
DiscUtils.FileSystemInfo[] oFileInfoItems = oMgr.DetectFileSystems(ISOStream);
bool bIsUDF = false;
foreach (DiscUtils.FileSystemInfo oInfo in oFileInfoItems)
{
string sDesc = oInfo.Description;
if (sDesc == "OSTA Universal Disk Format (UDF)")
{
bIsUDF = true;
}
}
string sIsoExtractionPath = "";
if (in_bCreateSubdirectory)
{
// Extract to subdirectory on drive
sIsoExtractionPath
= Path.Combine(in_sIsoExtractionRootDir, Path.GetFileNameWithoutExtension(in_sIsoPathAndFileName));
}
else
{
// Extract to ISO Extraction Root directory
sIsoExtractionPath = in_sIsoExtractionRootDir;
}
if (bIsUDF)
{
BootmanLog.LogError(LogTextBox, "Processing ISO Extract as ISO-UDF");
UdfReader oUDFReader = new UdfReader(ISOStream);
ExtractDirectoryISOUDF(oUDFReader.Root
, sIsoExtractionPath
, "");
oUDFReader.Dispose();
return(true);
}
else
{
BootmanLog.LogError(LogTextBox, "Processing ISO Extract as ISO-9660");
CDReader oISO9660Reader = new CDReader(ISOStream, true, true);
ExtractDirectoryISO9660(oISO9660Reader.Root
, sIsoExtractionPath
, "");
oISO9660Reader.Dispose();
return(true);
}
}
}
catch (Exception oEx)
{
BootmanLog.LogError(LogTextBox, "Error Extracting ISO: " + oEx.Message);
return(false);
}
}
public static void Gather(Media medium, Stream infile)
{
string failed = "";
XboxISOFileSource xboxIso = XboxISOFileSource.TryOpen(infile);
if (xboxIso != null)
{
XDvdFsFileSystemEntry xdvdfs = xboxIso.GetFileSystem();
Gather(medium, xdvdfs, null);
infile.Dispose();
return;
}
failed += "XDVDFS\n";
if (CDReader.Detect(infile))
{
CDReader cdReader = new CDReader(infile, true, false);
Gather(medium, cdReader.Root, null);
infile.Dispose();
return;
}
failed += "ISO9660\n";
if (UdfReader.Detect(infile))
{
UdfReader udfReader = new UdfReader(infile);
if (udfReader != null)
{
try
{
Gather(medium, udfReader.Root, null);
return;
}
catch (Exception)
{
AzusaContext.GetInstance().DatabaseDriver.ForgetFilesystemContents(medium.Id);
}
}
}
failed += "UDF\n";
if (FatFileSystem.Detect(infile))
{
FatFileSystem fat = new FatFileSystem(infile);
Gather(medium, fat.Root, null);
infile.Dispose();
return;
}
failed += "FAT32\n";
if (infile.Length < 3200)
{
FileStream fileStream = infile as FileStream;
if (fileStream != null)
{
fileStream.Dispose();
FileInfo fi = new FileInfo(fileStream.Name);
Stream gdRomStream = GDROMReader.BuildGdRomStream(fi);
if (CDReader.Detect(gdRomStream))
{
CDReader cdReader = new CDReader(gdRomStream, true, false);
Gather(medium, cdReader.Root, null);
infile.Dispose();
return;
}
}
}
failed += "GD-ROM\n";
infile.Position = 0;
byte[] firstSector = new byte[2352];
if (infile.Read(firstSector, 0, firstSector.Length) == firstSector.Length)
{
byte[] firstSectorSync = new byte[cdromSyncBytes.Length];
Array.Copy(firstSector, firstSectorSync, cdromSyncBytes.Length);
if (memcmp(cdromSyncBytes, firstSectorSync))
{
byte mode = firstSector[15];
if (mode == 1 || mode == 2)
{
infile.Position = 0;
RawCdRomStream rawCdRomStream = new RawCdRomStream(infile);
Gather(medium, rawCdRomStream);
return;
}
}
}
failed += "RAW CD-ROM";
MessageBox.Show("Konnte kein Dateisystem erkennen. Versucht wurden:" + failed);
}
/// <summary>
/// Detects whether a stream is an udf disc.
/// </summary>
/// <param name="root">A stream.</param>
/// <returns>A boolean.</returns>
public static bool IsUdfFile(Stream root)
{
return(UdfReader.Detect(root));
}
