public static int Compress(Stream input, Stream output, int uncompressedSize, Action<long> compressed = null)
{
Exceptions.CheckArgumentNull(input, "input");
Exceptions.CheckArgumentNull(output, "output");
Exceptions.CheckArgumentOutOfRangeException(uncompressedSize, "uncompressedSize", 0, int.MaxValue);
byte[] buff = new byte[Math.Min(32 * 1024, uncompressedSize)];
ZOutputStream writer = new ZOutputStream(output, 6);
long position = output.Position;
int readed;
while (uncompressedSize > 0 && (readed = input.Read(buff, 0, Math.Min(buff.Length, uncompressedSize))) > 0)
{
uncompressedSize -= readed;
writer.Write(buff, 0, readed);
compressed.NullSafeInvoke(readed);
}
writer.finish();
if (uncompressedSize != 0)
throw new Exception("Неожиданный конец потока.");
return (int)(output.Position - position);
}
public void Compress()
{
//压缩
byte[] byteData = System.Text.Encoding.UTF8.GetBytes("ul{\"state\":1,\"nick\":\"小龙\",\"sex\":true,\"email\":\"[email protected]\",\"exp\":109040,\"isguest\":false,\"hotpoint\":26,\"money\":7099,\"styletype\":\"stand\",\"style\":\"2/2/2/1\",\"id\":\"2ef38760-9000-4f10-b96b-af4da8c656ae\",\"vertify\":1,\"level\":12,\"sign\":\"小龙\",\"score\":6323}");
MemoryStream ms = new MemoryStream();
Stream s = new ZOutputStream(ms, 9);
s.Write(byteData, 0, byteData.Length);
s.Close();
byte[] compressData = (byte[])ms.ToArray();
ms.Flush();
ms.Close();
Console.WriteLine(compressData.Length);
//解压
MemoryStream md = new MemoryStream();
Stream d = new ZOutputStream(md);
d.Write(compressData, 0, compressData.Length);
d.Close();
byte[] dompressData = (byte[])md.ToArray();
md.Flush();
md.Close();
Console.WriteLine(dompressData.Length);
}
public void Compress()
{
byte[] buffer = m_Stream.GetBuffer();
ZOutputStream zs = new ZOutputStream(m_Stream);
zs.Write(buffer, 0, buffer.Length);
zs.Close();
Init();
}
/// <summary>
/// Zip compress data with offset and length.
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static byte[] Compress(byte[] src, int offset, int length)
{
MemoryStream ms = new MemoryStream();
Stream s = new ZOutputStream(ms, 9);
s.Write(src, offset, length);
s.Close();
return (byte[])ms.ToArray();
}
/// <summary>
/// Zip uncompress data.
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static byte[] Uncompress(byte[] src)
{
MemoryStream md = new MemoryStream();
Stream d = new ZOutputStream(md);
d.Write(src, 0, src.Length);
d.Close();
return (byte[])md.ToArray();
}
public static Stream DecompressFrame(Stream stream, int compressedSize)
{
Stream stream1 = new MemoryStream();
ZOutputStream stream2 = new ZOutputStream(stream1);
Utils.CopyStream(stream, stream2, compressedSize);
stream1.Position = 0;
return stream1;
}
/// <summary>
/// Cache all item templates
/// </summary>
/// <param name="fname">
/// </param>
/// <returns>
/// number of cached items
/// </returns>
public static int CacheAllNanos(string fname)
{
Contract.Requires(!string.IsNullOrEmpty(fname));
DateTime _now = DateTime.Now;
NanoList = new Dictionary<int, NanoFormula>();
Stream sf = new FileStream(fname, FileMode.Open);
MemoryStream ms = new MemoryStream();
ZOutputStream sm = new ZOutputStream(ms);
CopyStream(sf, sm);
ms.Seek(0, SeekOrigin.Begin);
BinaryReader br = new BinaryReader(ms);
byte versionlength = (byte)ms.ReadByte();
char[] version = new char[versionlength];
version = br.ReadChars(versionlength);
// TODO: Check version and print a warning if not same as config.xml's
Console.WriteLine("Reading Nanos (" + new string(version) + "):");
MessagePackSerializer<List<NanoFormula>> bf = MessagePackSerializer.Create<List<NanoFormula>>();
byte[] buffer = new byte[4];
ms.Read(buffer, 0, 4);
int packaged = BitConverter.ToInt32(buffer, 0);
while (true)
{
List<NanoFormula> templist;
try
{
templist = bf.Unpack(ms);
foreach (NanoFormula nf in templist)
{
NanoList.Add(nf.ID, nf);
}
if (templist.Count != packaged)
{
break;
}
}
catch (Exception)
{
throw;
}
Console.Write(
"Loaded {0} nanos in {1}\r",
new object[] { NanoList.Count, new DateTime((DateTime.Now - _now).Ticks).ToString("mm:ss.ff") });
}
GC.Collect();
return NanoList.Count;
}
/// <summary>
/// Deflate a string using zlib.net library since IronRuby's Deflate module is buggy, f**k
/// </summary>
/// <param name="data">The string to compress</param>
/// <returns>The decompressed string as a Ruby string</returns>
public static MutableString ZlibDeflate(string data)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_BEST_COMPRESSION))
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
outZStream.Write(bytes, 0, bytes.Length);
outZStream.finish();
return MutableString.CreateBinary(outMemoryStream.ToArray());
}
}
public static byte[] CompressData(byte[] inData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
return outMemoryStream.ToArray();
}
}
public static byte[] DecompressData(byte[] inData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
return outMemoryStream.ToArray();
}
}
public static void Decompress(Stream compressed, Stream target)
{
var zip = new ZOutputStream(target);
int readBytes;
var buffer = new byte[512];
do {
readBytes = compressed.Read(buffer, 0, buffer.Length);
zip.Write(buffer, 0, readBytes);
} while (readBytes > 0);
zip.Flush();
target.Seek(0, SeekOrigin.Begin);
}
public static void Compress(Stream uncompressed, Stream target)
{
var buffer = new byte[4096];
int readBytes;
var zip = new ZOutputStream(target, zlibConst.Z_BEST_COMPRESSION);
do {
readBytes = uncompressed.Read(buffer, 0, buffer.Length);
zip.Write(buffer, 0, readBytes);
} while (readBytes > 0);
zip.finish();
zip.Flush();
}
/// <summary>
/// Cache all item templates
/// </summary>
/// <param name="fname">
/// File to load from
/// </param>
/// <returns>
/// Number of cached items
/// </returns>
public static int CacheAllItems(string fname)
{
Contract.Requires(!string.IsNullOrEmpty(fname));
DateTime _now = DateTime.UtcNow;
ItemList = new Dictionary<int, ItemTemplate>();
Stream fileStream = new FileStream(fname, FileMode.Open);
MemoryStream memoryStream = new MemoryStream();
ZOutputStream zOutputStream = new ZOutputStream(memoryStream);
CopyStream(fileStream, zOutputStream);
memoryStream.Seek(0, SeekOrigin.Begin);
BinaryReader binaryReader = new BinaryReader(memoryStream);
byte versionlength = (byte)memoryStream.ReadByte();
char[] version = new char[versionlength];
version = binaryReader.ReadChars(versionlength);
// TODO: Check version and print a warning if not same as config.xml's
MessagePackSerializer<List<ItemTemplate>> messagePackSerializer =
MessagePackSerializer.Create<List<ItemTemplate>>();
var buffer = new byte[4];
memoryStream.Read(buffer, 0, 4);
int packaged = BitConverter.ToInt32(buffer, 0);
Console.WriteLine("Reading Items (" + new string(version) + "):");
while (true)
{
try
{
List<ItemTemplate> templates = messagePackSerializer.Unpack(memoryStream);
foreach (ItemTemplate template in templates)
{
ItemList.Add(template.ID, template);
}
if (templates.Count != packaged)
{
break;
}
}
catch (Exception)
{
throw;
}
Console.Write(
"Loaded {0} items in {1}\r",
new object[] { ItemList.Count, new DateTime((DateTime.UtcNow - _now).Ticks).ToString("mm:ss.ff") });
}
GC.Collect();
return ItemList.Count;
}
private byte[] DecompressFile(byte[] data, int uncompresedSize)
{
MemoryStream inputStream = new MemoryStream(data);
MemoryStream outputStream = new MemoryStream();
zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outputStream);
CopyStream(inputStream, outZStream);
byte[] result = outputStream.ToArray();
return(result);
}
public void SendChunk(Chunk chunk)
{
Transmit(PacketType.PreChunk, chunk.ChunkX, chunk.ChunkZ, (sbyte) 1);
byte[] uncompressed = chunk.GetBytes();
MemoryStream mem = new MemoryStream();
ZOutputStream stream = new ZOutputStream(mem, zlibConst.Z_BEST_COMPRESSION);
stream.Write(uncompressed, 0, uncompressed.Length);
stream.Close();
byte[] data = mem.ToArray();
Transmit(PacketType.MapChunk, 16 * chunk.ChunkX, (short) 0, 16 * chunk.ChunkZ,
(sbyte) 15, (sbyte) 127, (sbyte) 15, data.Length, data);
}
public void Receive2(string Message)
{
MessageEventArgs args = new MessageEventArgs();
try
{
byte[] messagebytes = Helpers.DecodeBase64Byte(Message);
using (MemoryStream ms = new MemoryStream(messagebytes))
{
using (var output = new MemoryStream())
using (var zipStream = new zlib.ZOutputStream(output))
{
using (ms)
{
var buffer = new byte[2000];
int len;
while ((len = ms.Read(buffer, 0, 2000)) > 0)
{
zipStream.Write(buffer, 0, len);
}
}
// reset output stream to start so we can read it to a string
output.Position = 0;
byte[] content = new byte[output.Length];
output.Read(content, 0, (int)output.Length);
args.Message = Encoding.Default.GetString(content);
}
}
receivedCount++;
if (receivedCount >= 10)
{
receivedEvent.Set();
}
}
catch (Exception ex)
{
throw ex;
}
EventHandler <MessageEventArgs> handler = MessageReceived;
if (handler != null)
{
handler(this, args);
}
}
//导出
private void exportBtn_Click(object sender, EventArgs e)
{
int index = swfListBox.SelectedIndex;
SwfClass swf = ProcessHandle.getInstence().getSwfClassByIndex(index);
if (saveFileDialog.ShowDialog() == DialogResult.OK){
string localFilePath = saveFileDialog.FileName;
if(checkBox.Checked == false){
byte[] fileByte = swf.fileByte;
FileStream file = new FileStream(localFilePath, FileMode.Create);
file.Write(fileByte, 0, swf.size);
file.Flush();
file.Close();
}
else
{
MemoryStream mStream = new MemoryStream(swf.fileByte.Length);
mStream.WriteByte(0x43);
mStream.Write(swf.fileByte, 1, 7);
MemoryStream getStream = new MemoryStream(swf.fileByte.Length);
//ZipOutputStream outPut = new ZipOutputStream(getStream);
//ZipEntry entry = new ZipEntry("");
//entry.CompressionMethod = CompressionMethod.WinZipAES
//outPut.PutNextEntry(entry);
//outPut.Write(swf.fileByte, 8, swf.fileByte.Length - 8);
//outPut.Finish();
ZOutputStream outPut = new ZOutputStream(getStream,zlib.zlibConst.Z_DEFAULT_COMPRESSION);
outPut.Write(swf.fileByte, 8, swf.fileByte.Length - 8);
outPut.finish();
getStream.WriteTo(mStream);
outPut.Close();
FileStream file = new FileStream(localFilePath, FileMode.Create);
file.Write(mStream.ToArray(), 0,(int)mStream.Length);
file.Flush();
file.Close();
MessageBox.Show("导出swf成功,路径:" + localFilePath,"成功");
}
}
}
public static byte[] CompressData(byte[] inData)
{
byte[] byteArray = inData;
byte[] tmpArray;
using (MemoryStream ms = new MemoryStream())
{
using (zlib.ZOutputStream outZStream = new zlib.ZOutputStream(ms, zlib.zlibConst.Z_DEFAULT_COMPRESSION))
{
outZStream.Write(byteArray, 0, byteArray.Length);
outZStream.Flush();
}
tmpArray = ms.ToArray();
}
return(tmpArray);
}
private static void DecompressZLibData(byte[] inData, out byte[] outData)
{
// used to work.
using (MemoryStream outMemoryStream = new MemoryStream(1000000))
{
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream))
{
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
outData = outMemoryStream.ToArray();
}
}
}
}
private static void CompressData(byte[] inData, out byte[] outData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
{
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION))
{
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
outData = outMemoryStream.ToArray();
}
}
}
}
public static MemoryStream Decompress(BinaryReader input, long destLength)
{
int bufferLength = 4;
MemoryStream output = new MemoryStream();
ZOutputStream zipStream = new ZOutputStream(output);
byte[] buffer = new byte[bufferLength];
while (output.Length < destLength)
{
input.Read(buffer, 0, bufferLength);
zipStream.Write(buffer, 0, bufferLength);
}
return output;
}
private void button1_Click_1(object sender, EventArgs e)
{
//Compression.LZW.TestCompress();
System.IO.FileStream output = new System.IO.FileStream("CompressedZ1.txt", System.IO.FileMode.Create);
zlib.ZOutputStream outputZ = new zlib.ZOutputStream(output, zlib.zlibConst.Z_DEFAULT_COMPRESSION);
System.IO.FileStream input = new System.IO.FileStream("InputZ1.txt", System.IO.FileMode.Open);
try
{
CopyStream(input, outputZ);
}
finally
{
outputZ.Close();
output.Close();
input.Close();
}
}
public void Decompress()
{
long msPos = m_memoryStream.Position;
MemoryStream outMS = new MemoryStream();
zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outMS);
CopyStream(m_memoryStream, outZStream);
outZStream.finish();
outMS.Position = 0;
m_memoryStream.Position = msPos;
CopyStream(outMS, m_memoryStream);
m_memoryStream.Position = msPos;
outMS.Close();
outZStream.Close();
}
public static string Compress(string param)
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(param);
//byte[] data = Convert.FromBase64String(param);
MemoryStream ms = new MemoryStream();
Stream stream = new zlib.ZOutputStream(ms);
try
{
stream.Write(data, 0, data.Length);
}
finally
{
stream.Close();
ms.Close();
}
return(Convert.ToBase64String(ms.ToArray()));
}
public static byte[] compress(byte[] data)
{
for (int l = zlib.zlibConst.Z_BEST_COMPRESSION; l > 0; l--)
{
MemoryStream o = new MemoryStream();
ZOutputStream z = new ZOutputStream(o, l);
MemoryStream i = new MemoryStream(data);
CopyStream(i, z);
z.finish();
o.Position = 0;
byte[] res = o.ToArray();
i.Close();
z.Close();
o.Close();
if (res.Length > 2)
return res;
}
return data;
}
/// <summary>
/// zlib.net 压缩函数
/// </summary>
/// <param name="strSource">待压缩数据</param>
/// <returns>压缩后数据</returns>
public static byte[] Compress(byte[] bytes)
{
MemoryStream outms = new MemoryStream();
MemoryStream inms = new MemoryStream(bytes);
zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outms, zlib.zlibConst.Z_DEFAULT_COMPRESSION);
try
{
CopyStream(inms, outZStream, bytes);
}
catch (Exception ex)
{
throw ex;
}
finally
{
outZStream.Close();
}
return(outms.ToArray());
}
public static byte[] Decompress(byte[] input)
{
using (MemoryStream output = new MemoryStream())
{
using (ZOutputStream zipStream = new ZOutputStream(output))
{
using (MemoryStream inputStream = new MemoryStream(input))
{
var buffer = new byte[2000];
int len;
while ((len = inputStream.Read(buffer, 0, 2000)) > 0)
{
zipStream.Write(buffer, 0, len);
}
}
}
return output.ToArray();
}
}
private void button2_Click(object sender, EventArgs e)
{
//Compression.LZW.TestDecompres();
//System.IO.FileStream outFileStream = new System.IO.FileStream("DecompressedZ1.txt", System.IO.FileMode.Create);
//zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outFileStream);
//System.IO.FileStream inFileStream = new System.IO.FileStream("CompressedZ1.txt", System.IO.FileMode.Open);
System.IO.FileStream outFileStream = new System.IO.FileStream("DecompressedZ2.bin", System.IO.FileMode.Create);
zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outFileStream);
System.IO.FileStream inFileStream = new System.IO.FileStream("219outCompressed.bin", System.IO.FileMode.Open);
try
{
CopyStream(inFileStream, outZStream);
}
finally
{
outZStream.Close();
outFileStream.Close();
inFileStream.Close();
}
}
public void ReadSwf(string swfFilePath)
{
try
{
//using closes and disposes for you
using (MemoryStream uncompressedZip = new MemoryStream())
using (ZOutputStream zlibStream = new ZOutputStream(uncompressedZip))
using (FileStream compressedSwf = new FileInfo(swfFilePath).OpenRead())
{
byte[] firstHeaderBytes = ChompHeaderBytes(compressedSwf);
zlibStream.finish();
}
}
catch (IOException ioe)
{
}
catch (Exception e)
{
}
}
// Compression related
// partially from http://stackoverflow.com/a/6627194/5343630
public static void CompressData(string compLevel, byte[] inData, out byte[] outData)
{
int cmp_lvl = 0;
if (compLevel == "789C")
cmp_lvl = 6;
else if (compLevel == "7801" || compLevel == "78DA")
cmp_lvl = 0;
else
{
Console.WriteLine("\nERROR: Unsupported compression flag used.");
Console.WriteLine("Falling back to default.\n");
cmp_lvl = zlibConst.Z_DEFAULT_COMPRESSION;
}
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, cmp_lvl))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
outData = outMemoryStream.ToArray();
}
}
public static MemoryStream Decompress(Stream input)
{
var output = new MemoryStream();
var zipStream = new zlib.ZOutputStream(output);
using (input)
{
var buffer = new byte[2000];
int len;
while ((len = input.Read(buffer, 0, 2000)) > 0)
{
zipStream.Write(buffer, 0, len);
}
}
output.Position = 0;
byte[] content = new byte[output.Length];
output.Read(content, 0, (int)output.Length);
return output;
}
public static MemoryStream Decompress(Stream input)
{
var output = new MemoryStream();
var zipStream = new zlib.ZOutputStream(output);
using (input)
{
var buffer = new byte[2000];
int len;
while ((len = input.Read(buffer, 0, 2000)) > 0)
{
zipStream.Write(buffer, 0, len);
}
}
output.Position = 0;
byte[] content = new byte[output.Length];
output.Read(content, 0, (int)output.Length);
return(output);
}
private bool LoadVobSubFromMatroska(MatroskaTrackInfo matroskaSubtitleInfo, MatroskaFile matroska)
{
if (matroskaSubtitleInfo.ContentEncodingType == 1)
{
MessageBox.Show(this._language.NoSupportEncryptedVobSub);
}
this.ShowStatus(this._language.ParsingMatroskaFile);
this.Refresh();
Cursor.Current = Cursors.WaitCursor;
var sub = matroska.GetSubtitle(matroskaSubtitleInfo.TrackNumber, this.MatroskaProgress);
TaskbarList.SetProgressState(this.Handle, TaskbarButtonProgressFlags.NoProgress);
Cursor.Current = Cursors.Default;
this.MakeHistoryForUndo(this._language.BeforeImportFromMatroskaFile);
this._subtitleListViewIndex = -1;
this._subtitle.Paragraphs.Clear();
List<VobSubMergedPack> mergedVobSubPacks = new List<VobSubMergedPack>();
Idx idx = new Idx(matroskaSubtitleInfo.CodecPrivate.SplitToLines());
foreach (var p in sub)
{
if (matroskaSubtitleInfo.ContentEncodingType == 0)
{
// compressed with zlib
bool error = false;
MemoryStream outStream = new MemoryStream();
var outZStream = new ZOutputStream(outStream);
MemoryStream inStream = new MemoryStream(p.Data);
byte[] buffer = null;
try
{
CopyStream(inStream, outZStream);
buffer = new byte[outZStream.TotalOut];
outStream.Position = 0;
outStream.Read(buffer, 0, buffer.Length);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message + Environment.NewLine + Environment.NewLine + exception.StackTrace);
error = true;
}
finally
{
outZStream.Close();
inStream.Close();
}
if (!error && buffer.Length > 2)
{
mergedVobSubPacks.Add(new VobSubMergedPack(buffer, TimeSpan.FromMilliseconds(p.Start), 32, null));
}
}
else
{
mergedVobSubPacks.Add(new VobSubMergedPack(p.Data, TimeSpan.FromMilliseconds(p.Start), 32, null));
}
if (mergedVobSubPacks.Count > 0)
{
mergedVobSubPacks[mergedVobSubPacks.Count - 1].EndTime = TimeSpan.FromMilliseconds(p.End);
}
// fix overlapping (some versions of Handbrake makes overlapping time codes - thx Hawke)
if (mergedVobSubPacks.Count > 1 && mergedVobSubPacks[mergedVobSubPacks.Count - 2].EndTime > mergedVobSubPacks[mergedVobSubPacks.Count - 1].StartTime)
{
mergedVobSubPacks[mergedVobSubPacks.Count - 2].EndTime = TimeSpan.FromMilliseconds(mergedVobSubPacks[mergedVobSubPacks.Count - 1].StartTime.TotalMilliseconds - 1);
}
}
using (var formSubOcr = new VobSubOcr())
{
formSubOcr.Initialize(mergedVobSubPacks, idx.Palette, Configuration.Settings.VobSubOcr, null); // TODO: language???
if (this._loading)
{
formSubOcr.Icon = (Icon)this.Icon.Clone();
formSubOcr.ShowInTaskbar = true;
formSubOcr.ShowIcon = true;
}
if (formSubOcr.ShowDialog(this) == DialogResult.OK)
{
this.ResetSubtitle();
this._subtitle.Paragraphs.Clear();
this._subtitle.WasLoadedWithFrameNumbers = false;
foreach (var p in formSubOcr.SubtitleFromOcr.Paragraphs)
{
this._subtitle.Paragraphs.Add(p);
}
this.ShowSource();
this.SubtitleListview1.Fill(this._subtitle, this._subtitleAlternate);
this._subtitleListViewIndex = -1;
this.SubtitleListview1.FirstVisibleIndex = -1;
this.SubtitleListview1.SelectIndexAndEnsureVisible(0);
this._fileName = Path.GetFileNameWithoutExtension(matroska.Path);
this._converted = true;
this.Text = this.Title;
Configuration.Settings.Save();
return true;
}
}
return false;
}
private bool LoadBluRaySubFromMatroska(MatroskaTrackInfo matroskaSubtitleInfo, MatroskaFile matroska)
{
if (matroskaSubtitleInfo.ContentEncodingType == 1)
{
MessageBox.Show(this._language.NoSupportEncryptedVobSub);
}
this.ShowStatus(this._language.ParsingMatroskaFile);
this.Refresh();
Cursor.Current = Cursors.WaitCursor;
var sub = matroska.GetSubtitle(matroskaSubtitleInfo.TrackNumber, this.MatroskaProgress);
TaskbarList.SetProgressState(this.Handle, TaskbarButtonProgressFlags.NoProgress);
Cursor.Current = Cursors.Default;
int noOfErrors = 0;
string lastError = string.Empty;
this.MakeHistoryForUndo(this._language.BeforeImportFromMatroskaFile);
this._subtitleListViewIndex = -1;
this._subtitle.Paragraphs.Clear();
var subtitles = new List<BluRaySupParser.PcsData>();
var log = new StringBuilder();
foreach (var p in sub)
{
byte[] buffer = null;
if (matroskaSubtitleInfo.ContentEncodingType == 0)
{
// compressed with zlib
MemoryStream outStream = new MemoryStream();
var outZStream = new ZOutputStream(outStream);
MemoryStream inStream = new MemoryStream(p.Data);
try
{
CopyStream(inStream, outZStream);
buffer = new byte[outZStream.TotalOut];
outStream.Position = 0;
outStream.Read(buffer, 0, buffer.Length);
}
catch (Exception exception)
{
var tc = new TimeCode(p.Start);
lastError = tc + ": " + exception.Message + ": " + exception.StackTrace;
noOfErrors++;
}
finally
{
outZStream.Close();
inStream.Close();
}
}
else
{
buffer = p.Data;
}
if (buffer != null && buffer.Length > 100)
{
MemoryStream ms = new MemoryStream(buffer);
var list = BluRaySupParser.ParseBluRaySup(ms, log, true);
foreach (var sup in list)
{
sup.StartTime = (long)((p.Start - 1) * 90.0);
sup.EndTime = (long)((p.End - 1) * 90.0);
subtitles.Add(sup);
// fix overlapping
if (subtitles.Count > 1 && sub[subtitles.Count - 2].End > sub[subtitles.Count - 1].Start)
{
subtitles[subtitles.Count - 2].EndTime = subtitles[subtitles.Count - 1].StartTime - 1;
}
}
ms.Close();
}
else if (subtitles.Count > 0)
{
var lastSub = subtitles[subtitles.Count - 1];
if (lastSub.StartTime == lastSub.EndTime)
{
lastSub.EndTime = (long)((p.Start - 1) * 90.0);
if (lastSub.EndTime - lastSub.StartTime > 1000000)
{
lastSub.EndTime = lastSub.StartTime;
}
}
}
}
if (noOfErrors > 0)
{
MessageBox.Show(string.Format("{0} error(s) occured during extraction of bdsup\r\n\r\n{1}", noOfErrors, lastError));
}
using (var formSubOcr = new VobSubOcr())
{
formSubOcr.Initialize(subtitles, Configuration.Settings.VobSubOcr, matroska.Path);
if (this._loading)
{
formSubOcr.Icon = (Icon)this.Icon.Clone();
formSubOcr.ShowInTaskbar = true;
formSubOcr.ShowIcon = true;
}
if (formSubOcr.ShowDialog(this) == DialogResult.OK)
{
this.MakeHistoryForUndo(this._language.BeforeImportingDvdSubtitle);
this._subtitle.Paragraphs.Clear();
this.SetCurrentFormat(Configuration.Settings.General.DefaultSubtitleFormat);
this._subtitle.WasLoadedWithFrameNumbers = false;
this._subtitle.CalculateFrameNumbersFromTimeCodes(this.CurrentFrameRate);
foreach (var p in formSubOcr.SubtitleFromOcr.Paragraphs)
{
this._subtitle.Paragraphs.Add(p);
}
this.ShowSource();
this.SubtitleListview1.Fill(this._subtitle, this._subtitleAlternate);
this._subtitleListViewIndex = -1;
this.SubtitleListview1.FirstVisibleIndex = -1;
this.SubtitleListview1.SelectIndexAndEnsureVisible(0);
this._fileName = string.Empty;
this.Text = this.Title;
Configuration.Settings.Save();
return true;
}
}
return false;
}
public void SendChunk(Chunk c)
{
PreChunk(c.ChunkX, c.ChunkZ, 1);
// TODO: maybe we can cache some uncompressed chunk
byte[] uncompressed = c.GetBytes();
byte[] data;
using(MemoryStream mem = new MemoryStream()) {
using(ZOutputStream stream = new ZOutputStream(mem, zlibConst.Z_BEST_COMPRESSION)) {
stream.Write(uncompressed, 0, uncompressed.Length);
}
data = mem.ToArray();
}
CXMineServer.SendLogFile("Sending: MapChunk dimension: " + (data.Length + 18).ToString() + "\r\n");
Send(new MapChunk(16 * c.ChunkX, (short)0, 16 * c.ChunkZ, 15, 127, 15, data.Length, data));
//KeepAlive();
}
public override void Write(NetworkWriter writer)
{
writer.WriteInt32(ChunkX);
writer.WriteInt16(ChunkY);
writer.WriteInt32(ChunkZ);
writer.WriteByte((byte)(Width - 1));
writer.WriteByte((byte)(Height - 1));
writer.WriteByte((byte)(Depth - 1));
var compressed = new MemoryStream(Data.Length); // TODO: use better guess here
var zlib = new ZOutputStream(compressed, zlibConst.Z_DEFAULT_COMPRESSION);
zlib.Write(Data, 0, Data.Length);
zlib.Flush();
zlib.finish();
writer.WriteInt32((int)zlib.TotalOut);
writer.Write(compressed.GetBuffer(), 0, (int)zlib.TotalOut);
zlib.Close();
compressed.Close();
}
public override void Read(NetworkReader reader)
{
ChunkX = reader.ReadInt32();
ChunkY = reader.ReadInt16();
ChunkZ = reader.ReadInt32();
Width = reader.ReadByte() + 1;
Height = reader.ReadByte() + 1;
Depth = reader.ReadByte() + 1;
byte[] data = new byte[reader.ReadInt32()];
reader.Read(data, 0, data.Length);
var uncompressed = new MemoryStream(data.Length); // TODO: use better guess here
var zlib = new ZOutputStream(uncompressed);
zlib.Write(data, 0, data.Length);
zlib.Flush();
zlib.finish();
Data = new byte[zlib.TotalOut];
uncompressed.Read(Data, 0, Data.Length);
zlib.Close();
uncompressed.Close();
}
/// <summary>
/// Decompresses the block.
/// </summary>
/// <param name="compressed">The compressed data.</param>
/// <param name="type">The type data type contained in the block.</param>
/// <returns>The decompressed block.</returns>
private static byte[] DecompressBlock(byte[] compressed, ref DataType type)
{
byte[] data;
using (var decompressed = new MemoryStream())
{
using (var decompressor = new ZOutputStream(decompressed))
{
decompressor.Write(compressed, 0, compressed.Length);
decompressed.Position = 0;
var buf = new byte[4];
decompressed.Read(buf, 0, 4);
type = (DataType)BitConverter.ToInt32(buf, 0);
decompressed.Read(buf, 0, 4);
var size = BitConverter.ToInt32(buf, 0);
data = new byte[size];
decompressed.Read(data, 0, size);
}
}
return data;
}
public static void Deflate(Stream input, Stream output)
{
var zoutput = new ZOutputStream(output);
var inputReader = new BinaryReader(input);
zoutput.Write(inputReader.ReadBytes((int)input.Length), 0, (int)input.Length);
zoutput.Flush();
}
