Merge pull request #221 from UnityTech/gif

Fix GIF memory overflow problem.

Author: zhuxingwei

Runtime/painting/image_stream.cs

@@ -363,24 +363,15 @@ bool _hasFrameDurationPassed(TimeSpan timestamp) {
         }
 
         void _decodeNextFrameAndSchedule() {
-            this._codec.getNextFrame().Then(frame => {
-                    this._nextFrame = frame;
+            var frame = this._codec.getNextFrame();
+            this._nextFrame = frame;
 
-                    if (this._codec.frameCount == 1) {
-                        this._emitFrame(new ImageInfo(image: this._nextFrame.image, scale: this._scale));
-                        return;
-                    }
+            if (this._codec.frameCount == 1) {
+                this._emitFrame(new ImageInfo(image: this._nextFrame.image, scale: this._scale));
+                return;
+            }
 
-                    SchedulerBinding.instance.scheduleFrameCallback(this._handleAppFrame);
-                },
-                ex => {
-                    this.reportError(
-                        context: "resolving an image frame",
-                        exception: ex,
-                        informationCollector: this._informationCollector,
-                        silent: true
-                    );
-                });
+            SchedulerBinding.instance.scheduleFrameCallback(this._handleAppFrame);
         }
 
         void _emitFrame(ImageInfo imageInfo) {

Runtime/ui/painting/GifDecoder.cs

@@ -558,6 +558,11 @@ void _readHeader() {
                 this._gct = this._readColorTable(this._gctSize);
                 this._bgColor = this._gct[this._bgIndex];
             }
+
+            this._currentFrame = new GifFrame {
+                bytes = new byte[this._width * this._height * sizeof(int)],
+                delay = 0
+            };
         }
 
         /**
@@ -616,9 +621,8 @@ void _readImage() {
 
             this._setPixels(); // transfer pixel data to image
 
-            var bytes = new byte[this._width * this._height * sizeof(int)];
-            Buffer.BlockCopy(this._image, 0, bytes, 0, bytes.Length);
-            this._currentFrame = new GifFrame {bytes = bytes, delay = this._delay};
+            Buffer.BlockCopy(this._image, 0, this._currentFrame.bytes, 0, this._currentFrame.bytes.Length);
+            this._currentFrame.delay = this._delay;
             this._frameCount++;
 
             if (this._transparency) {

Runtime/ui/painting/codec.cs

@@ -12,7 +12,7 @@ public class FrameInfo {
     public interface Codec : IDisposable {
         int frameCount { get; }
         int repetitionCount { get; }
-        IPromise<FrameInfo> getNextFrame();
+        FrameInfo getNextFrame();
     }
 
     public class ImageCodec : Codec {
@@ -31,13 +31,13 @@ public int repetitionCount {
             get { return 0; }
         }
 
-        public IPromise<FrameInfo> getNextFrame() {
+        public FrameInfo getNextFrame() {
             D.assert(this._image != null);
 
-            return Promise<FrameInfo>.Resolved(new FrameInfo {
+            return new FrameInfo {
                 duration = TimeSpan.Zero,
                 image = this._image
-            });
+            };
         }
 
         public void Dispose() {

Runtime/ui/painting/codec_gif.cs

@@ -1,9 +1,7 @@
 using System;
 using System.Collections;
-using System.Collections.Generic;
 using System.IO;
 using RSG;
-using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using UnityEngine;
 
@@ -18,80 +16,75 @@ public class FrameData {
             public GifDecoder.GifFrame gifFrame;
         }
 
-        readonly List<Promise<FrameData>> _frames;
+        volatile byte[] _bytes;
         volatile int _width;
         volatile int _height;
         volatile int _frameCount;
         volatile int _repetitionCount;
         volatile bool _isDone;
         volatile int _frameIndex;
         volatile Texture2D _texture;
-        readonly UIWidgetsCoroutine _coroutine;
+        volatile FrameData _frameData;
+        volatile Image _image;
+        volatile GifDecoder _decoder;
+        volatile MemoryStream _stream;
+        IEnumerator _coroutine;
 
         public GifCodec(byte[] bytes) {
             D.assert(bytes != null);
             D.assert(isGif(bytes));
 
-            this._frames = new List<Promise<FrameData>>();
-            this._width = 0;
-            this._height = 0;
             this._frameCount = 0;
             this._repetitionCount = 0;
             this._isDone = false;
             this._frameIndex = 0;
-
-            this._coroutine = Window.instance.startBackgroundCoroutine(
-                this._startDecoding(bytes, Window.instance));
+            this._bytes = bytes;
+            this._coroutine = this._startDecoding();
+            this._decoder = new GifDecoder();
+            this._stream = new MemoryStream(this._bytes);
+            this._frameData = new FrameData() {
+                frameInfo = new FrameInfo()
+            };
         }
 
-        IEnumerator _startDecoding(byte[] bytes, Window window) {
-            var bytesStream = new MemoryStream(bytes);
+        IEnumerator _startDecoding() {
+            this._stream.Seek(0, SeekOrigin.Begin);
 
-            var gifDecoder = new GifDecoder();
-            if (gifDecoder.read(bytesStream) != GifDecoder.STATUS_OK) {
+            if (this._decoder.read(this._stream) != GifDecoder.STATUS_OK) {
                 throw new Exception("Failed to decode gif.");
             }
 
-            this._width = gifDecoder.frameWidth;
-            this._height = gifDecoder.frameHeight;
+            this._width = this._decoder.frameWidth;
+            this._height = this._decoder.frameHeight;
+
+            if (this._texture == null) {
+                this._texture = new Texture2D(this._width, this._height, TextureFormat.BGRA32, false);
+                this._texture.hideFlags = HideFlags.HideAndDontSave;
+                this._image = new Image(this._texture);
+                this._frameData.frameInfo.image = this._image;
+            }
+            this._frameData.gifFrame = this._decoder.currentFrame;
+            D.assert(this._frameData.gifFrame != null);
 
             int i = 0;
             while (true) {
-                yield return null;
-
-                if (gifDecoder.nextFrame() != GifDecoder.STATUS_OK) {
+                if (this._decoder.nextFrame() != GifDecoder.STATUS_OK) {
                     throw new Exception("Failed to decode gif.");
                 }
 
-                if (gifDecoder.done) {
+                if (this._decoder.done) {
                     break;
                 }
 
-                var frameData = new FrameData {
-                    gifFrame = gifDecoder.currentFrame,
-                };
-
-                Promise<FrameData> frame;
-
-                lock (this._frames) {
-                    if (i < this._frames.Count) {
-                    }
-                    else {
-                        D.assert(this._frames.Count == i);
-                        this._frames.Add(new Promise<FrameData>());
-                    }
-
-                    frame = this._frames[i];
-                }
-
-                window.runInMain(() => { frame.Resolve(frameData); });
 
                 i++;
+
+                yield return null;
             }
 
-            D.assert(gifDecoder.frameCount == i);
-            this._frameCount = gifDecoder.frameCount;
-            this._repetitionCount = gifDecoder.loopCount;
+            D.assert(this._decoder.frameCount == i);
+            this._frameCount = this._decoder.frameCount;
+            this._repetitionCount = this._decoder.loopCount;
             this._isDone = true;
         }
 
@@ -107,54 +100,26 @@ public int repetitionCount {
         void _nextFrame() {
             this._frameIndex++;
 
+            this._coroutine.MoveNext();
+
             if (this._isDone && this._frameIndex >= this._frameCount) {
                 this._frameIndex = 0;
+                this._isDone = false;
+                this._coroutine = this._startDecoding();
+                this._coroutine.MoveNext();
             }
         }
 
-        public IPromise<FrameInfo> getNextFrame() {
-            Promise<FrameData> frame;
-
-            lock (this._frames) {
-                if (this._frameIndex == this._frames.Count) {
-                    this._frames.Add(new Promise<FrameData>());
-                }
-                else {
-                    D.assert(this._frameIndex < this._frames.Count);
-                }
-
-                frame = this._frames[this._frameIndex];
-            }
-
-
-            return frame.Then(frameData => {
-                this._nextFrame();
-
-                if (this._texture == null) {
-                    this._texture = new Texture2D(this._width, this._height, TextureFormat.BGRA32, false);
-                    this._texture.hideFlags = HideFlags.HideAndDontSave;
-                }
-
-                var tex = this._texture;
-                tex.LoadRawTextureData(frameData.gifFrame.bytes);
-                tex.Apply();
-
-                if (frameData.frameInfo != null) {
-                    return frameData.frameInfo;
-                }
-
-                frameData.frameInfo = new FrameInfo {
-                    image = new Image(tex),
-                    duration = TimeSpan.FromMilliseconds(frameData.gifFrame.delay)
-                };
-                // frameData.gifFrame = null; // dispose gifFrame
-
-                return frameData.frameInfo;
-            });
+        public FrameInfo getNextFrame() {
+            this._nextFrame();
+            this._texture.LoadRawTextureData(this._frameData.gifFrame.bytes);
+            this._texture.Apply();
+            this._frameData.frameInfo.duration = TimeSpan.FromMilliseconds(this._frameData.gifFrame.delay);
+            return this._frameData.frameInfo;
         }
 
         public void Dispose() {
-            this._coroutine.stop();
+            this._decoder.Dispose();
         }
     }
 }