static void CreateFirstBridge () {
		Bridge b = new Bridge() {
			__test = 0,
			id = "first",
		};
		weak_track_handle = GCHandle.Alloc (b, GCHandleType.WeakTrackResurrection);
	}

	static void CreateSecondBridge () {
		Bridge b = new Bridge() {
			__test = 1,
			id = "second",
		};
		weak_track_handle2 = GCHandle.Alloc (b, GCHandleType.WeakTrackResurrection);
	}

    void Update()
    {
        if (state == 0) {
            AndroidJavaClass UnityOpenCVLoaderJava = new AndroidJavaClass(UNITY_OPENCV_LOADER);
            var b = UnityOpenCVLoaderJava.CallStatic<Boolean>("isSuccess");
            if (b) {
                state = 1;
            }
        } else if (state == 1) {
            if (cameraInstance == IntPtr.Zero) cameraInstance = CreateCameraInstance ();

            if (Open (cameraInstance, 0, width, height)) {
                texture = new Texture2D (width, height, TextureFormat.ARGB32, false);
                pixels = texture.GetPixels32 ();
                pixelsHandle = GCHandle.Alloc (pixels, GCHandleType.Pinned);
                pixelsPtr = pixelsHandle.AddrOfPinnedObject ();
                GetComponent<Renderer>().material.mainTexture = texture;
                state = 2;
            } else {
                state = -1;
            }
        } else if (state == 2) {
            getCameraTexture (cameraInstance, pixelsPtr, width, height);
            texture.SetPixels32 (pixels);
            texture.Apply ();
        }
    }

    // Update is called once per frame
    void Update()
    {
        // off-screen rendering
        var camtex = RenderTexture.GetTemporary (camWidth, camHeight, 24, RenderTextureFormat.Default, RenderTextureReadWrite.Default, 1);
        myCamera.targetTexture = camtex;
        myCamera.Render ();
        RenderTexture.active = camtex;

        tex.ReadPixels (new Rect (0, 0, camtex.width, camtex.height), 0, 0);
        tex.Apply ();

        // Convert texture to ptr
        texturePixels_       = tex.GetPixels32();
        texturePixelsHandle_ = GCHandle.Alloc(texturePixels_, GCHandleType.Pinned);
        texturePixelsPtr_    = texturePixelsHandle_.AddrOfPinnedObject();

        // Show a window
        fullWindow (windowName, displayNum, texturePixelsPtr_, camWidth, camHeight);

        texturePixelsHandle_.Free();

        RenderTexture.active = null;
        RenderTexture.ReleaseTemporary (camtex);
        myCamera.targetTexture = null;
    }

	private static AKRESULT DoLoadBank(string in_bankPath)
	{
		ms_www = new WWW(in_bankPath);
		while( ! ms_www.isDone )
		{
#if ! UNITY_METRO
			System.Threading.Thread.Sleep(WaitMs);
#endif // #if ! UNITY_METRO
		}

		uint in_uInMemoryBankSize = 0;
		try
		{
			ms_pinnedArray = GCHandle.Alloc(ms_www.bytes, GCHandleType.Pinned);
			ms_pInMemoryBankPtr = ms_pinnedArray.AddrOfPinnedObject();
			in_uInMemoryBankSize = (uint)ms_www.bytes.Length;	
		}
		catch
		{
			return AKRESULT.AK_Fail;
		}
		
		AKRESULT result = AkSoundEngine.LoadBank(ms_pInMemoryBankPtr, in_uInMemoryBankSize, out ms_bankID);
		
		return result;
	}

	private void CreateBuffer(int width, int height)
	{
		// Free buffer if it's too small
		if (_frameHandle.IsAllocated && _frameData != null)
		{
			if (_frameData.Length < _frameWidth * _frameHeight)
			{
				FreeBuffer();
			}
		}
		
		if (_frameData == null)
		{
			_frameWidth = width;
			_frameHeight = height;
			_frameData = new Color32[_frameWidth * _frameHeight];
			_frameHandle = GCHandle.Alloc(_frameData, GCHandleType.Pinned);
			_framePointer = _frameHandle.AddrOfPinnedObject();
			
#if TEXTURETEST
			_testTexture = new Texture2D(_frameWidth ,_frameHeight, TextureFormat.ARGB32, false, false);
			_testTexture.Apply(false, false);
#endif
		}
	}

    public static int Main()
    {
        int[] arr = new int[1000];
        GCHandle[] arrhandle = new GCHandle[10000]; // array of handles to the same object
        IntPtr[] oldaddress = new IntPtr[10000];        // store old addresses
        IntPtr[] newaddress = new IntPtr[10000];        // store new addresses

        for (int i = 0; i < 10000; i++)
        {
            arrhandle[i] = GCUtil.Alloc(arr, GCHandleType.Pinned);
            oldaddress[i] = GCUtil.AddrOfPinnedObject(arrhandle[i]);
        }

        GC.Collect();
        GC.WaitForPendingFinalizers();

        for (int i = 0; i < 10000; i++)
        {
            newaddress[i] = GCUtil.AddrOfPinnedObject(arrhandle[i]);
        }

        for (int i = 0; i < 10000; i++)
        {
            if (oldaddress[i] != newaddress[i])
            {
                Console.WriteLine("Test failed");
                return 1;
            }
        }

        Console.WriteLine("Test passed");
        return 100;
    }

        public CreateObj()
        {
            obj = new Dummy();
            Console.WriteLine("Allocating a Weak handle to object..");
            handle = GCHandle.Alloc(obj, GCHandleType.Weak);

            // making a copy of the handle
            copy = handle;
        }

    public static void RegisterCommandCallback(CommandCallbackDelegate fun)
    {
        _gcHandle = GCHandle.Alloc(fun);

        if (IntPtr.Size == 8)
            RegisterCommandCallback_x64(fun);
        else
            RegisterCommandCallback_x86(fun);
    }

    public Matrix(int size)
    {
        if (!_validSizes.Contains(size)) throw new ArgumentOutOfRangeException("size");
        _size = size;
        _data = new int[size * size];

        _dataPtrHandle = GCHandle.Alloc(_data, GCHandleType.Pinned);
        _dataPtr = (int*)_dataPtrHandle.AddrOfPinnedObject().ToPointer();
    }

	// Use this for initialization
	void Start () {
        camera_ = getCamera(device);
        setCameraProp(camera_, width, height, fps);
        texture_ = new Texture2D(width, height, TextureFormat.ARGB32, false);
        pixels_ = texture_.GetPixels32();
        pixels_handle_ = GCHandle.Alloc(pixels_, GCHandleType.Pinned);
        pixels_ptr_ = pixels_handle_.AddrOfPinnedObject();
        GetComponent<Renderer>().material.mainTexture = texture_;
    }

 static void alloc_many()
 {
     int
     small_count
     =
     count
     /
     2;
     GCHandle[]
     more
     =
     new
     GCHandle
     [small_count];
     int
     i;
     for
     (i
     =
     0;
     i
     <
     small_count;
     ++i)
     {
     GCHandleType
     t
     =
     (GCHandleType)
     (i
     &
     3);
     more
     [i]
     =
     GCHandle.Alloc
     (i,
     t);
     }
     for
     (i
     =
     0;
     i
     <
     small_count;
     ++i)
     {
     more
     [i].Free
     ();
     }
     Console.WriteLine
     ("alloc many: {0}",
     small_count);
 }

    private void Cleanup(GCHandle[] argStrHandles, GCHandle argPtrsHandle,
                                       IntPtr gsInstancePtr)
    {
        for (int i = 0; i < argStrHandles.Length; i++)
                argStrHandles[i].Free();

            argPtrsHandle.Free();
            ExitAPI(gsInstancePtr);
            DeleteAPIInstance(gsInstancePtr);
    }

 public IntPtr GetContextHandle()
 {
     if ((_selfGCHandle.IsAllocated == false))
     {
         _selfGCHandle = GCHandle.Alloc(
                             this,
                             GCHandleType.Normal);
     }
     return GCHandle.ToIntPtr(_selfGCHandle);
 }

 private static void deterministicStaticInit()
 {
     __noData = (IntPtr) (-1);
     __defaultCmdSpace = (IntPtr) (-1);
     modFlags = ApiGroup.Off;
     modIdentity = string.Empty;
     ctrlCallback = new CtrlCB(Bid.SetApiGroupBits);
     cookieObject = new BindingCookie();
     hCookie = GCHandle.Alloc(cookieObject, GCHandleType.Pinned);
 }

		/// <summary>
		/// Update the view. This method triggers the view to be rendered to the
		/// underlaying texture.
		/// </summary>
		/// <returns>true if the view was actually updated</returns>
		public bool UpdateView()
		{
			if (View != null)
			{
				m_DataPin = GCHandle.Alloc(m_Data,
					System.Runtime.InteropServices.GCHandleType.Pinned);

				return View.GetAsBitmap(m_DataPin.AddrOfPinnedObject(),
					Width * Height * 4);
			}
			return false;
		}

    // Unity audio callback
    public void OnAudioFilterRead(float[] data, int channels)
    {
        if(dataPtr == IntPtr.Zero)
        {
            dataHandle = GCHandle.Alloc(data,GCHandleType.Pinned);
            dataPtr = dataHandle.AddrOfPinnedObject();
        }

        if (islibpdready) {
            LibPD.Process(numberOfTicks, dataPtr, dataPtr);
        }
    }

    void Initialize()
    {
        GStreamer.GUBUnityDebugLogPFN log_handler = null;
        if (Application.isEditor)
        {
            log_handler = (int level, string message) => Debug.logger.Log((LogType)level, "GUB", message);
        }

        GStreamer.Ref("2", log_handler);
        m_instanceHandle = GCHandle.Alloc(this);
        m_Pipeline = new GstUnityBridgePipeline(name + GetInstanceID(), OnFinish, null, null, (System.IntPtr)m_instanceHandle);
    }

	public static void arwRegisterLogCallback(LogCallback lcb)
	{
		if (lcb != null) {
			logCallback = lcb;
			logCallbackGCH = GCHandle.Alloc(logCallback); // Does not need to be pinned, see http://stackoverflow.com/a/19866119/316487 
		}
		if (Application.platform == RuntimePlatform.IPhonePlayer) ARNativePluginStatic.arwRegisterLogCallback(logCallback);
		else ARNativePlugin.arwRegisterLogCallback(logCallback);
		if (lcb == null) {
			logCallback = null;
			logCallbackGCH.Free();
		}
	}

    public ChannelTexture(int width, int height, TextureFormat format)
    {
        tex = new Texture2D(width, height, format, false);

        tex.wrapMode = TextureWrapMode.Clamp; //important for NPOT

        #if !((UNITY_ANDROID || UNITY_IPHONE) && !UNITY_EDITOR)
        pixels = tex.GetPixels32(0);
        handle = GCHandle.Alloc(pixels, GCHandleType.Pinned);
        #endif

        ReAlloc();
    }