Example #1
0
        public static int IMOS_XP_OpenInputStream(int port, byte[] header, uint bufPoolSize = 2 * 1024 * 1024)
        {
            int    size = 0;
            IntPtr ptr  = IntPtr.Zero;

            if (header != null)
            {
                size = header.Length;
                ptr  = Marshal.AllocHGlobal(size);
                Marshal.Copy(header, 0, ptr, size);
            }

            int ret = 0;

            if (_isX64)
            {
                ret = Native64.IMOS_XP_OpenInputStream((uint)port, ptr, (uint)size, bufPoolSize);
            }
            else
            {
                ret = Native32.IMOS_XP_OpenInputStream((uint)port, ptr, (uint)size, bufPoolSize);
            }

            if (ptr != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(ptr);
            }

            return(ret);
        }
Example #2
0
        public static int IMOS_XP_InputMediaData(int port, byte[] data)
        {
            int    size = 0;
            IntPtr ptr  = IntPtr.Zero;

            if (data != null)
            {
                size = data.Length;
                ptr  = Marshal.AllocHGlobal(size);
                Marshal.Copy(data, 0, ptr, size);
            }

            int ret = 0;

            if (_isX64)
            {
                ret = Native64.IMOS_XP_InputMediaData((uint)port, ptr, (uint)size);
            }
            else
            {
                ret = Native32.IMOS_XP_InputMediaData((uint)port, ptr, (uint)size);
            }

            if (ptr != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(ptr);
            }

            return(ret);
        }
Example #3
0
 public static int IMOS_XP_SetDecodeVideoMediaDataCB(int port, DecodeVideoDataCallback onDecodeVideoData, bool bContinue)
 {
     _decVideoCallbacks[port] = onDecodeVideoData;
     if (onDecodeVideoData != null)
     {
         IntPtr userParam = Marshal.GetFunctionPointerForDelegate(onDecodeVideoData);
         if (_isX64)
         {
             return(Native64.IMOS_XP_SetDecodeVideoMediaDataCB((uint)port, _onDecVideoData, bContinue, userParam));
         }
         else
         {
             return(Native32.IMOS_XP_SetDecodeVideoMediaDataCB((uint)port, _onDecVideoData, bContinue, userParam));
         }
     }
     else
     {
         if (_isX64)
         {
             return(Native64.IMOS_XP_SetDecodeVideoMediaDataCB((uint)port, null, bContinue, IntPtr.Zero));
         }
         else
         {
             return(Native32.IMOS_XP_SetDecodeVideoMediaDataCB((uint)port, null, bContinue, IntPtr.Zero));
         }
     }
 }
Example #4
0
        public static int Decompress(byte[] inbuf, uint inlen, byte[] outbuf, ref uint outlen)
        {
            if (_Is64Bit == true)
            {
                return(Native64.NativeDecompress(inbuf, inlen, outbuf, ref outlen));
            }

            return(Native32.NativeDecompress(inbuf, inlen, outbuf, ref outlen));
        }
Example #5
0
 public static int IMOS_XP_SetDecoderTag(int port, string decoderTag)
 {
     if (_isX64)
     {
         return(Native64.IMOS_XP_SetDecoderTag((uint)port, decoderTag));
     }
     else
     {
         return(Native32.IMOS_XP_SetDecoderTag((uint)port, decoderTag));
     }
 }
Example #6
0
 public static int IMOS_XP_CloseInputStream(int port)
 {
     if (_isX64)
     {
         return(Native64.IMOS_XP_CloseInputStream((uint)port));
     }
     else
     {
         return(Native32.IMOS_XP_CloseInputStream((uint)port));
     }
 }
Example #7
0
 public static void IMOS_XP_Cleanup()
 {
     if (_isX64)
     {
         Native64.IMOS_XP_Cleanup();
     }
     else
     {
         Native32.IMOS_XP_Cleanup();
     }
 }
Example #8
0
 public static int IMOS_XP_Init()
 {
     if (_isX64)
     {
         return(Native64.IMOS_XP_Init());
     }
     else
     {
         return(Native32.IMOS_XP_Init());
     }
 }
Example #9
0
 public static int IMOS_XP_StopPlay(int port)
 {
     if (_isX64)
     {
         return(Native64.IMOS_XP_StopPlay((uint)port));
     }
     else
     {
         return(Native32.IMOS_XP_StopPlay((uint)port));
     }
 }
Example #10
0
 public static int IMOS_XP_SetPlayWnd(int port, IntPtr handle)
 {
     if (_isX64)
     {
         return(Native64.IMOS_XP_SetPlayWnd((uint)port, handle));
     }
     else
     {
         return(Native32.IMOS_XP_SetPlayWnd((uint)port, handle));
     }
 }
Example #11
0
 private static void CallDecompressImage(byte[] rgba, int width, int height, byte[] blocks, int flags)
 {
     if (Is64Bit() == true)
     {
         Native64.DecompressImage(rgba, width, height, blocks, flags);
     }
     else
     {
         Native32.DecompressImage(rgba, width, height, blocks, flags);
     }
 }
Example #12
0
        public static int Compress(byte[] inbuf, uint inlen, byte[] outbuf, ref uint outlen)
        {
            lock (CompressWork)
            {
                if (_Is64Bit == true)
                {
                    return(Native64.NativeCompress(inbuf, inlen, outbuf, ref outlen, CompressWork));
                }

                return(Native32.NativeCompress(inbuf, inlen, outbuf, ref outlen, CompressWork));
            }
        }
Example #13
0
        public static ErrorCode Compress(
            byte[] dest,
            ref uint destLen,
            byte[] src,
            uint srcLen,
            byte[] outProps,
            ref uint outPropsSize,
            int level,
            uint dictSize,
            int lc,
            int lp,
            int pb,
            int fb,
            int numThreads)
        {
            if (Is64Bit == true)
            {
                return((ErrorCode)Native64.CompressInternal(
                           dest,
                           ref destLen,
                           src,
                           srcLen,
                           outProps,
                           ref outPropsSize,
                           level,
                           dictSize,
                           lc,
                           lp,
                           pb,
                           fb,
                           numThreads));
            }

            return((ErrorCode)Native32.CompressInternal(
                       dest,
                       ref destLen,
                       src,
                       srcLen,
                       outProps,
                       ref outPropsSize,
                       level,
                       dictSize,
                       lc,
                       lp,
                       pb,
                       fb,
                       numThreads));
        }
Example #14
0
        public static ErrorCode Decompress(
            byte[] dest,
            ref uint destLen,
            byte[] src,
            ref uint srcLen,
            byte[] props,
            uint propsSize)
        {
            if (Is64Bit == true)
            {
                return((ErrorCode)Native64.DecompressInternal(
                           dest, ref destLen, src, ref srcLen, props, propsSize));
            }

            return((ErrorCode)Native32.DecompressInternal(
                       dest, ref destLen, src, ref srcLen, props, propsSize));
        }
Example #15
0
        public static ErrorCode Compress(byte[] inputBytes,
                                         int inputOffset,
                                         int inputCount,
                                         byte[] outputBytes,
                                         int outputOffset,
                                         ref int outputCount)
        {
            if (inputBytes == null)
            {
                throw new ArgumentNullException("inputBytes");
            }

            if (inputOffset < 0 || inputOffset > inputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("inputOffset");
            }

            if (inputCount <= 0 || inputOffset + inputCount > inputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("inputCount");
            }

            if (outputBytes == null)
            {
                throw new ArgumentNullException("outputBytes");
            }

            if (outputOffset < 0 || outputOffset > outputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("outputOffset");
            }

            if (outputCount <= 0 || outputOffset + outputCount > outputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("outputCount");
            }

            var outputHandle = GCHandle.Alloc(outputBytes, GCHandleType.Pinned);
            var inputHandle  = GCHandle.Alloc(inputBytes, GCHandleType.Pinned);

            ErrorCode result;

            lock (_CompressWork)
            {
                if (_Is64Bit == true)
                {
                    result = Native64.NativeCompress(inputHandle.AddrOfPinnedObject() + inputOffset,
                                                     inputCount,
                                                     outputHandle.AddrOfPinnedObject() + outputOffset,
                                                     ref outputCount,
                                                     _CompressWork);
                }
                else
                {
                    result = Native32.NativeCompress(inputHandle.AddrOfPinnedObject() + inputOffset,
                                                     inputCount,
                                                     outputHandle.AddrOfPinnedObject() + outputOffset,
                                                     ref outputCount,
                                                     _CompressWork);
                }
            }

            return(result);
        }
        public static ErrorCode Decompress(byte[] inputBytes,
                                           int inputOffset,
                                           int inputCount,
                                           byte[] outputBytes,
                                           int outputOffset,
                                           ref int outputCount)
        {
            if (inputBytes == null)
            {
                throw new ArgumentNullException("inputBytes");
            }

            if (inputOffset < 0 || inputOffset >= inputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("inputOffset");
            }

            if (inputCount <= 0 || inputOffset + inputCount > inputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("inputCount");
            }

            if (outputBytes == null)
            {
                throw new ArgumentNullException("outputBytes");
            }

            if (outputOffset < 0 || outputOffset >= outputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("outputOffset");
            }

            if (outputCount <= 0 || outputOffset + outputCount > outputBytes.Length)
            {
                throw new ArgumentOutOfRangeException("outputCount");
            }

            var outputHandle = GCHandle.Alloc(outputBytes, GCHandleType.Pinned);
            var inputHandle  = GCHandle.Alloc(inputBytes, GCHandleType.Pinned);

            ErrorCode result;

            if (_Is64Bit == true)
            {
                long dummy = outputCount;
                result = (ErrorCode)Native64.NativeDecompress(inputHandle.AddrOfPinnedObject() + inputOffset,
                                                              inputCount,
                                                              outputHandle.AddrOfPinnedObject() + outputOffset,
                                                              ref dummy);
                if (dummy < 0 || dummy > outputCount)
                {
                    throw new InvalidOperationException("strange output count");
                }
                outputCount = (int)dummy;
            }
            else
            {
                result = (ErrorCode)Native32.NativeDecompress(inputHandle.AddrOfPinnedObject() + inputOffset,
                                                              inputCount,
                                                              outputHandle.AddrOfPinnedObject() + outputOffset,
                                                              ref outputCount);
            }

            inputHandle.Free();
            outputHandle.Free();

            return(result);
        }