public static FileType GetFileType(FileInfo file)
{
byte[] markerMKV = new byte[] { 0x1A, 0x45, 0xDF, 0xA3 };
byte[] markerAVI = new byte[] { 0x52, 0x49, 0x46, 0x46 };
byte[] markerRAR = new byte[] { 0x52, 0x61, 0x72, 0x21 };
byte[] fileHeader = new byte[4];
using (FileStream fs = file.OpenRead())
fs.Read(fileHeader, 0, 4);
if (ByteArrayComparer.AreEqual(fileHeader, markerRAR))
{
using (RarStream rs = new RarStream(file.FullName))
rs.Read(fileHeader, 0, 4);
}
if (ByteArrayComparer.AreEqual(fileHeader, markerMKV))
{
return(FileType.MKV);
}
else if (ByteArrayComparer.AreEqual(fileHeader, markerAVI))
{
return(FileType.AVI);
}
else
{
return(FileType.Unknown);
}
}
public static void ExtractSampleStreams(SortedList <int, TrackData> tracks, Dictionary <string, AttachmentData> attachments, FileData file, FileInfo inFile, DirectoryInfo outDir)
{
Stream fs;
if (RarFileNameComparer.IsRarFile(inFile.Name))
{
fs = new RarStream(inFile.FullName);
}
else
{
fs = inFile.OpenRead();
}
using (EbmlReader rdr = new EbmlReader(fs, EbmlReadMode.MKV))
{
long startOffset = long.MaxValue;
foreach (TrackData track in tracks.Values)
{
if (track.MatchOffset > 0)
{
startOffset = Math.Min(track.MatchOffset, startOffset);
}
}
string currentAttachment = null;
int clustercount = 0;
bool done = false;
while (rdr.Read() && !done)
{
switch (rdr.ElementType)
{
case EbmlElementType.Segment:
case EbmlElementType.AttachmentList:
case EbmlElementType.Attachment:
case EbmlElementType.BlockGroup:
rdr.MoveToChild();
break;
case EbmlElementType.Cluster:
// simple progress indicator since this can take a while (cluster is good because they're about 1mb each)
Console.Write("\b{0}", Program.spinners[clustercount++ % Program.spinners.Length]);
// in extract mode, we know the first data offset we're looking for, so skip any clusters before that
if (rdr.Element.ElementStartPos + rdr.Element.RawHeader.Length + rdr.Element.Length < startOffset)
{
rdr.SkipContents();
}
else
{
rdr.MoveToChild();
}
break;
case EbmlElementType.AttachedFileName:
currentAttachment = Encoding.UTF8.GetString(rdr.ReadContents());
if (!attachments.ContainsKey(currentAttachment))
{
attachments.Add(currentAttachment, new AttachmentData()
{
Name = currentAttachment
});
}
break;
case EbmlElementType.AttachedFileData:
AttachmentData attachment = attachments[currentAttachment];
attachment.Size = rdr.Element.Length;
// in extract mode, extract all attachments in case we need them later
if (attachment.AttachmentFile == null)
{
attachment.AttachmentFile = new FileStream(Path.Combine(outDir.FullName, attachment.Name), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, 0x10000, FileOptions.DeleteOnClose);
}
byte[] buff = rdr.ReadContents();
attachment.AttachmentFile.Write(buff, 0, buff.Length);
attachment.AttachmentFile.Seek(0, SeekOrigin.Begin);
break;
case EbmlElementType.Block:
TrackData track = tracks[rdr.Block.TrackNumber];
if (rdr.Block.ElementStartPos + rdr.Block.RawHeader.Length + rdr.Block.RawBlockHeader.Length + rdr.Block.Length > track.MatchOffset)
{
if (track.TrackFile == null)
{
track.TrackFile = new FileStream(Path.Combine(outDir.FullName, inFile.Name + "." + track.TrackNumber.ToString("d3")), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, 0x10000, FileOptions.DeleteOnClose);
}
buff = rdr.ReadContents();
int offset = 0;
for (int i = 0; i < rdr.Block.FrameLengths.Length; i++)
{
if (rdr.Block.ElementStartPos + rdr.Block.RawHeader.Length + rdr.Block.RawBlockHeader.Length + offset >= track.MatchOffset && track.TrackFile.Position < track.DataLength)
{
track.TrackFile.Write(buff, offset, rdr.Block.FrameLengths[i]);
}
offset += rdr.Block.FrameLengths[i];
}
bool tracksDone = true;
foreach (TrackData t in tracks.Values)
{
if (t.TrackFile == null || t.TrackFile.Length < t.DataLength)
{
tracksDone = false;
break;
}
}
done = tracksDone;
}
else
{
rdr.SkipContents();
}
break;
default:
rdr.SkipContents();
break;
}
}
}
Console.Write('\b');
}
public static void FindSampleStreams(SortedList <int, TrackData> tracks, FileInfo inFile)
{
Stream fs;
if (RarFileNameComparer.IsRarFile(inFile.Name))
{
fs = new RarStream(inFile.FullName);
}
else
{
fs = inFile.OpenRead();
}
using (EbmlReader rdr = new EbmlReader(fs, EbmlReadMode.MKV))
{
int clustercount = 0;
bool done = false;
while (rdr.Read() && !done)
{
switch (rdr.ElementType)
{
case EbmlElementType.Segment:
case EbmlElementType.BlockGroup:
rdr.MoveToChild();
break;
case EbmlElementType.Cluster:
// simple progress indicator since this can take a while (cluster is good because they're about 1mb each)
Console.Write("\b{0}", Program.spinners[clustercount++ % Program.spinners.Length]);
rdr.MoveToChild();
break;
case EbmlElementType.Block:
if (!tracks.ContainsKey(rdr.Block.TrackNumber))
{
tracks.Add(rdr.Block.TrackNumber, new TrackData()
{
TrackNumber = (ushort)rdr.Block.TrackNumber
});
}
TrackData track = tracks[rdr.Block.TrackNumber];
// it's possible the sample didn't require or contain data for all tracks in the main file
// if that happens, we obviously don't want to try to match the data
if (track.SignatureBytes != null && (track.MatchOffset == 0 || track.CheckBytes.Length < track.SignatureBytes.Length))
{
// here, the data we're looking for might not start in the first frame (lace) of the block, so we need to check them all
byte[] buff = rdr.ReadContents();
int offset = 0;
for (int i = 0; i < rdr.Block.FrameLengths.Length; i++)
{
if (track.CheckBytes != null && track.CheckBytes.Length < track.SignatureBytes.Length)
{
byte[] checkBytes = new byte[Math.Min(track.SignatureBytes.Length, rdr.Block.FrameLengths[i] + track.CheckBytes.Length)];
Buffer.BlockCopy(track.CheckBytes, 0, checkBytes, 0, track.CheckBytes.Length);
Buffer.BlockCopy(buff, offset, checkBytes, track.CheckBytes.Length, checkBytes.Length - track.CheckBytes.Length);
if (ByteArrayComparer.AreEqual(track.SignatureBytes, checkBytes, checkBytes.Length))
{
track.CheckBytes = checkBytes;
}
else
{
// it was only a partial match. start over
track.CheckBytes = null;
track.MatchOffset = 0;
track.MatchLength = 0;
}
}
// this is a bit weird, but if we had a false positive match going and discovered it above, we check this frame again
// to see if it's the start of a new match (rare problem, but it can happen with subtitles especially)
if (track.CheckBytes == null)
{
byte[] checkBytes = new byte[Math.Min(track.SignatureBytes.Length, rdr.Block.FrameLengths[i])];
Buffer.BlockCopy(buff, offset, checkBytes, 0, checkBytes.Length);
if (ByteArrayComparer.AreEqual(track.SignatureBytes, checkBytes, checkBytes.Length))
{
track.CheckBytes = checkBytes;
track.MatchOffset = rdr.Block.ElementStartPos + rdr.Block.RawHeader.Length + rdr.Block.RawBlockHeader.Length + offset;
track.MatchLength = Math.Min(track.DataLength, rdr.Block.FrameLengths[i]);
}
}
else
{
track.MatchLength += Math.Min(track.DataLength - track.MatchLength, rdr.Block.FrameLengths[i]);
}
offset += rdr.Block.FrameLengths[i];
}
}
else if (track.MatchLength < track.DataLength)
{
track.MatchLength += Math.Min(track.DataLength - track.MatchLength, rdr.Element.Length);
rdr.SkipContents();
bool tracksDone = true;
foreach (TrackData t in tracks.Values)
{
if (t.MatchLength < t.DataLength)
{
tracksDone = false;
break;
}
}
done = tracksDone;
}
else
{
rdr.SkipContents();
}
break;
default:
rdr.SkipContents();
break;
}
}
}
Console.Write('\b');
}
public static void ExtractSampleStreams(SortedList <int, TrackData> tracks, FileData file, FileInfo inFile, DirectoryInfo outDir)
{
Stream fs;
if (RarFileNameComparer.IsRarFile(inFile.Name))
{
fs = new RarStream(inFile.FullName);
}
else
{
fs = inFile.OpenRead();
}
using (RiffReader rdr = new RiffReader(fs, RiffReadMode.AVI))
{
long startOffset = long.MaxValue;
foreach (TrackData track in tracks.Values)
{
if (track.MatchOffset > 0)
{
startOffset = Math.Min(track.MatchOffset, startOffset);
}
}
int blockcount = 0;
bool done = false;
while (rdr.Read() && !done)
{
if (rdr.ChunkType == RiffChunkType.List)
{
rdr.MoveToChild();
}
else // normal chunk
{
if (rdr.ChunkType == RiffChunkType.Movi)
{
if (++blockcount % 15 == 0)
{
Console.Write("\b{0}", Program.spinners[blockcount % Program.spinners.Length]);
}
if (!tracks.ContainsKey(rdr.MoviChunk.StreamNumber))
{
tracks.Add(rdr.MoviChunk.StreamNumber, new TrackData());
}
TrackData track = tracks[rdr.MoviChunk.StreamNumber];
if (rdr.MoviChunk.ChunkStartPos + rdr.MoviChunk.RawHeader.Length + rdr.MoviChunk.Length > track.MatchOffset)
{
if (track.TrackFile == null)
{
track.TrackFile = new FileStream(Path.Combine(outDir.FullName, inFile.Name + "." + track.TrackNumber.ToString("d3")), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, 0x10000, FileOptions.DeleteOnClose);
}
if (track.TrackFile.Position < track.DataLength)
{
if (rdr.MoviChunk.ChunkStartPos + rdr.MoviChunk.RawHeader.Length >= track.MatchOffset)
{
track.TrackFile.Write(rdr.ReadContents(), 0, (int)rdr.MoviChunk.Length);
}
else
{
int chunkOffset = (int)(track.MatchOffset - (rdr.MoviChunk.ChunkStartPos + rdr.MoviChunk.RawHeader.Length));
track.TrackFile.Write(rdr.ReadContents(), chunkOffset, (int)rdr.MoviChunk.Length - chunkOffset);
}
}
bool tracksDone = true;
foreach (TrackData t in tracks.Values)
{
if (t.TrackFile == null || t.TrackFile.Length < t.DataLength)
{
tracksDone = false;
break;
}
}
done = tracksDone;
}
rdr.SkipContents();
}
else
{
rdr.SkipContents();
}
}
}
}
Console.Write('\b');
}
public static void FindSampleStreams(SortedList <int, TrackData> tracks, FileInfo inFile)
{
Stream fs;
if (RarFileNameComparer.IsRarFile(inFile.Name))
{
fs = new RarStream(inFile.FullName);
}
else
{
fs = inFile.OpenRead();
}
using (RiffReader rdr = new RiffReader(fs, RiffReadMode.AVI))
{
int blockcount = 0;
bool done = false;
while (rdr.Read() && !done)
{
if (rdr.ChunkType == RiffChunkType.List)
{
rdr.MoveToChild();
}
else // normal chunk
{
if (rdr.ChunkType == RiffChunkType.Movi)
{
if (++blockcount % 15 == 0)
{
Console.Write("\b{0}", Program.spinners[blockcount % Program.spinners.Length]);
}
int trackno = rdr.MoviChunk.StreamNumber;
if (!tracks.ContainsKey(trackno))
{
tracks.Add(trackno, new TrackData());
}
TrackData track = tracks[trackno];
track.TrackNumber = (byte)trackno;
if (track.MatchOffset == 0 || track.CheckBytes.Length < track.SignatureBytes.Length)
{
// it's possible the sample didn't require or contain data for all tracks in the main file
// if that happens, we obviously don't want to try to match the data
if (track.SignatureBytes != null)
{
if (track.CheckBytes != null && track.CheckBytes.Length < track.SignatureBytes.Length)
{
byte[] checkBytes = new byte[Math.Min(track.SignatureBytes.Length, rdr.MoviChunk.Length + track.CheckBytes.Length)];
track.CheckBytes.CopyTo(checkBytes, 0);
Buffer.BlockCopy(rdr.ReadContents(), 0, checkBytes, track.CheckBytes.Length, checkBytes.Length - track.CheckBytes.Length);
if (ByteArrayComparer.AreEqual(track.SignatureBytes, checkBytes, checkBytes.Length))
{
track.CheckBytes = checkBytes;
}
else
{
// it was only a partial match. start over
track.CheckBytes = null;
track.MatchOffset = 0;
track.MatchLength = 0;
}
}
// this is a bit weird, but if we had a false positive match going and discovered it above, we check this frame again
// to see if it's the start of a new match (probably will never happen with AVI, but it does in MKV, so just in case...)
if (track.CheckBytes == null)
{
byte[] chunkBytes = rdr.ReadContents();
byte searchByte = track.SignatureBytes[0];
int foundPos = -1;
while ((foundPos = Array.IndexOf <byte>(chunkBytes, searchByte, foundPos + 1)) > -1)
{
byte[] checkBytes = new byte[Math.Min(track.SignatureBytes.Length, chunkBytes.Length - foundPos)];
Buffer.BlockCopy(chunkBytes, foundPos, checkBytes, 0, checkBytes.Length);
if (ByteArrayComparer.AreEqual(track.SignatureBytes, checkBytes, checkBytes.Length))
{
track.CheckBytes = checkBytes;
track.MatchOffset = rdr.Chunk.ChunkStartPos + rdr.Chunk.RawHeader.Length + foundPos;
track.MatchLength = Math.Min(track.DataLength, chunkBytes.Length - foundPos);
break;
}
}
}
else
{
track.MatchLength += Math.Min(track.DataLength - track.MatchLength, rdr.MoviChunk.Length);
}
}
}
else if (track.MatchLength < track.DataLength)
{
track.MatchLength += Math.Min(track.DataLength - track.MatchLength, rdr.MoviChunk.Length);
bool tracksDone = true;
foreach (TrackData t in tracks.Values)
{
if (t.MatchLength < t.DataLength)
{
tracksDone = false;
break;
}
}
done = tracksDone;
}
rdr.SkipContents();
}
else
{
rdr.SkipContents();
}
}
}
}
Console.Write('\b');
}
