static extern unsafe int TECkit_Compile( byte *txt, UInt32 len, byte doCompression, Delegate errFunc, void *userData, Byte **outTable, UInt32 *outLen);
extern unsafe public static Byte *NeAACDecDecode2( IntPtr hDecoder, ref PInvoke_libfaad2.frameInfo frameInfo, Byte *buffer, Int32 buffer_size, Byte **pOutbuffer, Int32 out_buffer_size );
public static Dictionary <String, String> CreateStrMap(byte **key, byte **val) { Dictionary <String, String> map = new Dictionary <string, string>(); Byte **ppKey = key; Byte **ppVal = val; while (ppKey != null && ppVal != null) { String strKey = Marshal.PtrToStringAnsi((IntPtr)(*ppKey)); String strVal = Marshal.PtrToStringAnsi((IntPtr)(*ppVal)); if (String.IsNullOrEmpty(strKey) == false && String.IsNullOrEmpty(strVal) == false) { map[strKey] = map[strVal]; } ppKey++; ppVal++; } return(map); }
/// <summary> /// Get the data of the entry linked by the specified unique ID. /// All the data will be allocated in memory. It may fail. /// /// Return false if the entry does not exist. /// </summary> public Boolean GetEntryData(UInt32 ID, Byte **pData, Int32 *pLength) { *pData = null; Entry *pEntry = null; lock (Entries) { if (!Entries.ContainsKey(ID)) { return(false); } pEntry = (Entry *)Entries[ID]; } using (FileStream Stream = new FileStream(Filename, FileMode.Open, FileAccess.Read, FileShare.Read)) { Stream.Seek(pEntry->Offset, SeekOrigin.Begin); Byte[] Buffer = new Byte[Kernel.MAX_BUFFER_SIZE]; * pData = (Byte *)Kernel.malloc((Int32)pEntry->Size); * pLength = (Int32)pEntry->Size; Int32 Count = (Int32)(pEntry->Size / Buffer.Length); Int32 Rest = (Int32)(pEntry->Size % Buffer.Length); Int32 Pos = 0; for (Int32 i = 0; i < Count; i++) { Stream.Read(Buffer, 0, Buffer.Length); Kernel.memcpy((*pData) + Pos, Buffer, Buffer.Length); Pos += Buffer.Length; } Stream.Read(Buffer, 0, Rest); Kernel.memcpy((*pData) + Pos, Buffer, Rest); } return(true); }
public static unsafe void ReadPreAllocatedBytePtrArray(IPropertyContainer propertyContainer, UInt32 key, Byte[][] buffers) { var pinnedArrays = new GCHandle[buffers.Length]; // Pin arrays for (var i = 0; i < buffers.Length; i++) { pinnedArrays[i] = GCHandle.Alloc(buffers[i], GCHandleType.Pinned); } Byte **pointerArray = stackalloc Byte *[buffers.Length]; for (var i = 0; i < buffers.Length; i++) { pointerArray[i] = (Byte *)(pinnedArrays[i].AddrOfPinnedObject().ToPointer()); } propertyContainer.ReadProperty(key, new IntPtr(sizeof(IntPtr) * buffers.Length), pointerArray); for (var i = 0; i < buffers.Length; i++) { pinnedArrays[i].Free(); } }
private unsafe UInt32 UnsafeCompress(Byte[] source, UInt32 start, Byte[] destination, UInt32 size) { fixed(Byte *source_f = source, destination_c = destination) { Byte * source_c = source_f + start; UInt32 headerlen = 8 * 4; Byte * last_byte = source_c + size - 1; Byte * src = source_c + 1; Byte ** hashtable = (Byte **)(destination_c + size + 36000 - sizeof(Byte *) * 4096 - (((Int64)(destination_c + size)) % 8)); const UInt32 SEQLEN = 2 + (1 << 11); Byte * cword_ptr = destination_c + headerlen; Byte * dst = destination_c + headerlen + 4 + 1; Byte * prev_dst = dst; Byte * prev_src = src; UInt32 cword_val = 1 << 30; UInt32 hash; UInt32 * header = (UInt32 *)destination_c; Byte * guarentee_uncompressed = last_byte - 4 * 4; MemCopy(&header[(Int32)HeaderFields.QCLZ], "QCLZ"); destination_c[0] = (Byte)'Q'; destination_c[1] = (Byte)'C'; destination_c[2] = (Byte)'L'; destination_c[3] = (Byte)'Z'; FastWrite(3, &header[(Int32)HeaderFields.VERSION], 4); FastWrite(size, &header[(Int32)HeaderFields.UNCOMPSIZE], 4); //for (hash = 0; hash < 4096; ++hash) hashtable[hash] = source_c; *(destination_c + headerlen + 4) = *source_c; while (src < guarentee_uncompressed - SEQLEN) { UInt32 fetch; if ((cword_val & 1) == 1) { if (dst + SEQLEN + 128 > destination_c + size + SEQLEN + 256) { MemCopy(destination_c + headerlen, source_c, size); FastWrite(0, &header[(Int32)HeaderFields.COMPRESSIBLE], 4); FastWrite(size + headerlen + 4, &header[(Int32)HeaderFields.COMPSIZE], 4); MemCopy(destination_c + FastRead(&header[(Int32)HeaderFields.COMPSIZE], 4) - 4, "QCLZ"); return(FastRead(&header[(Int32)HeaderFields.COMPSIZE], 4)); } FastWrite((UInt32)((cword_val >> 1) | (1 << (4 * 8 - 1))), cword_ptr, 4); cword_ptr = dst; dst += 4; cword_val = 0x80000000; if (dst - prev_dst > src - prev_src && src + 2 * SEQLEN < guarentee_uncompressed) { while (src < prev_src + SEQLEN - 4 * 8) { FastWrite(0x80000000, dst - 4, 4); MemCopyUP(dst, src, 4 * 8 - 1); dst += 4 * 8 - 1 + 4; src += 4 * 8 - 1; } prev_src = src; prev_dst = dst; cword_ptr = dst - 4; } } if (FastRead(src, 4) == FastRead(src + 1, 4)) { Byte *orig_src; fetch = FastRead(src, 4); orig_src = src; src += 4 + 1; while (fetch == FastRead(src, 4) && src < orig_src + SEQLEN - 4) { src += 4; } FastWrite(((fetch & 0xFF) << 16) | (UInt32)((src - orig_src) << 4) | 15, dst, 4); dst += 3; cword_val = (cword_val >> 1) | 0x80000000; } else { Byte *o; fetch = FastRead(src, 4); hash = ((fetch >> 12) ^ fetch) & 0x0FFF; if (hashtable[hash] == (byte *)0) { hashtable[hash] = source_c; } o = hashtable[hash]; hashtable[hash] = src; Boolean tmp; if (BitConverter.IsLittleEndian) { tmp = src - o <= 131071 && src - o > 3 && (((*(UInt32 *)o) ^ (*(UInt32 *)src)) & 0xFFFFFF) == 0; } else { tmp = src - o <= 131071 && src - o > 3 && *src == *o && *(src + 1) == *(o + 1) && *(src + 2) == *(o + 2); } if (tmp) { UInt32 offset = (UInt32)(src - o); UInt32 matchlen; if (BitConverter.IsLittleEndian) { tmp = (*(UInt32 *)o) != (*(UInt32 *)src); } else { tmp = *(o + 3) != *(src + 3); } if (tmp) { if (offset <= 63) { *dst = (Byte)(offset << 2); ++dst; cword_val = (cword_val >> 1) | 0x80000000; src += 3; } else if (offset <= 16383) { UInt32 f = (offset << 2) | 1; FastWrite(f, dst, 2); dst += 2; cword_val = (cword_val >> 1) | 0x80000000; src += 3; } else { *dst = *src; ++dst; ++src; cword_val = (cword_val >> 1); } } else { cword_val = (cword_val >> 1) | 0x80000000; matchlen = 3; while (*(o + matchlen) == *(src + matchlen) && matchlen < SEQLEN) { ++matchlen; } src += matchlen; if (matchlen <= 18 && offset <= 1023) { UInt32 f = ((matchlen - 3) << 2) | (offset << 6) | 2; FastWrite(f, dst, 2); dst += 2; } else if (matchlen <= 34 && offset <= 65535) { UInt32 f = ((matchlen - 3) << 3) | (offset << 8) | 3; FastWrite(f, dst, 3); dst += 3; } else if (matchlen >= 3) { UInt32 f = ((matchlen - 3) << 4) | (offset << 15) | 7; FastWrite(f, dst, 4); dst += 4; } } } else { *dst = *src; ++dst; ++src; cword_val = (cword_val >> 1); } } } while (src <= last_byte) { if ((UInt32)(dst - destination_c - 1 + 4) > source.Length) { //compression is bigger than original data return(0); } if ((cword_val & 1) == 1) { FastWrite((cword_val >> 1) | 0x80000000, cword_ptr, 4); cword_ptr = dst; dst += 4; cword_val = 0x80000000; } *dst = *src; ++dst; ++src; cword_val = (cword_val >> 1); } while ((cword_val & 1) != 1) { cword_val = (cword_val >> 1); } if ((UInt32)(dst - destination_c - 1 + 4) > source.Length) { //compression is bigger than original data return(0); } FastWrite((cword_val >> 1) | 0x80000000, cword_ptr, 4); dst += 4; FastWrite(1, &header[(Int32)HeaderFields.COMPRESSIBLE], 4); FastWrite((UInt32)(dst - destination_c - 1 + 4), &header[(Int32)HeaderFields.COMPSIZE], 4); MemCopy(destination_c + FastRead(&header[(Int32)HeaderFields.COMPSIZE], 4) - 4, "QCLZ"); } return(GetCompressedSize(destination)); }
/// <summary> /// Get the data of the entry linked by the specified path. /// All the data will be allocated in memory. It may fail. /// /// Return false if the entry does not exist. /// </summary> public Boolean GetEntryData(String Path, Byte **pData, Int32 *pLength) { *pData = null; if (Path.StartsWith("/") || Path.StartsWith("\\")) { return(false); } Entry Entry; lock (Entries) { if (!Entries.TryGetValue(Path.ToLowerInvariant().Replace('\\', '/'), out Entry)) { return(false); } } *pData = (Byte *)Kernel.malloc((Int32)Entry.UncompressedSize); *pLength = (Int32)Entry.UncompressedSize; using (FileStream Input = new FileStream(TpdFile.GetFilename(), FileMode.Open, FileAccess.Read, FileShare.Read)) { Byte[] Buffer = new Byte[Kernel.MAX_BUFFER_SIZE]; Byte[] Tmp = new Byte[Kernel.MAX_BUFFER_SIZE]; Int32 Pos = 0; Input.Seek(Entry.Offset, SeekOrigin.Begin); { ZStream Stream = new ZStream(); Stream.inflateInit(); Int32 Result = 0; Int32 Length = 0; do { Stream.avail_in = Input.Read(Buffer, 0, Kernel.MAX_BUFFER_SIZE); Stream.next_in = Buffer; Stream.next_in_index = 0; if (Stream.avail_in == 0) { break; } do { Stream.avail_out = Kernel.MAX_BUFFER_SIZE; Stream.next_out = Tmp; Stream.next_out_index = 0; Result = Stream.inflate(zlibConst.Z_NO_FLUSH); Length = Kernel.MAX_BUFFER_SIZE - Stream.avail_out; Kernel.memcpy((*pData) + Pos, Tmp, Length); Pos += Length; }while (Stream.avail_out == 0); }while (Result != zlibConst.Z_STREAM_END); Stream.inflateEnd(); } } return(true); }
/// Get the data of the entry linked by the specified path. /// All the data will be allocated in memory. It may fail. /// /// Return false if the entry does not exist. /// </summary> public Boolean GetEntryData(String Path, Byte **pData, Int32 *pLength) { return(Package.GetEntryData(Path, pData, pLength)); }