update to swift 4

AImage.swift

@@ -0,0 +1,243 @@
+//
+//  AImage.swift
+//  AImage
+//
+//  Created by wangjwchn on 16/8/22.
+//  Copyright © 2016 JW. All rights reserved.
+//
+
+/********************* Demo *********************
+
+/* Create AImage with URL */
+let image = AImage(url: Bundle.main.url(forResource: "test", withExtension: "gif")!)
+
+/* Create AImageView */
+let imageview = AImageView(frame:CGRect(x: 0.0, y: 50.0, width: 380.0, height: 212.0))
+
+/* Add AImage to AImageView */
+imageview.add(image: image!)
+
+/* Start displaying animated image */
+imageview.play = true
+
+    ...
+    ...
+
+/* Stop displaying animated image */
+imageview.play = false
+
+********************* Demo *********************/
+
+import ImageIO
+import UIKit
+
+public class AImageView: UIView {
+
+    /* Whether the image is displaying or not */
+    public var play: Bool = false
+
+    /* Add an 'AImage' to 'AImageView' */
+    // limit: Memory limit (in MB)
+    public func add(image: AImage, limit: Int = 20){
+        clear()
+        self.aImage = image
+        self.nextFrame = AImageView.cover(self.aImage!.imageSource)
+        if (AImageView.calculateMemory(self.aImage!.imageSource) <= limit) {
+            DispatchQueue.global(qos: DispatchQoS.QoSClass.userInteractive).async {
+                self.prepareCache()
+            }
+        }
+        self.timer = CADisplayLink(target: self.displayLinkProxy, selector: #selector(myDisplayLinkProxyObject.proxyUpdateAnimation))
+        timer?.preferredFramesPerSecond = self.aImage!.framePerSecond
+        timer?.add(to: RunLoop.main, forMode: .commonModes)
+    }
+
+    deinit {
+        timer?.invalidate()
+    }
+
+    private var aImage:AImage?
+    private var indexAt:Int = 0
+    private var timer:CADisplayLink?
+    private var nextFrame:UIImage?
+    private var cache:NSCache<AnyObject, AnyObject> = NSCache()
+    private lazy var displayLinkProxy: myDisplayLinkProxyObject = {
+        return myDisplayLinkProxyObject(listener: self)
+    }()
+
+    private class func cover(_ source: CGImageSource) -> UIImage {
+        return UIImage(cgImage: CGImageSourceCreateImageAtIndex(source,0,nil)!)
+    }
+
+    private class func calculateMemory(_ source: CGImageSource) -> Int {
+        let imageCount = CGImageSourceGetCount(source)
+        let image = cover(source)
+        return Int(image.size.height * image.size.width * 4) * imageCount / (1000 * 1000)
+    }
+
+    private func clear(){
+        self.indexAt = 0
+        self.cache.removeAllObjects()
+        self.play = false
+        if self.timer != nil {
+            timer?.invalidate()
+            self.timer = nil
+        }
+    }
+
+    private func prepareCache() {
+        for i in 0..<self.aImage!.displayIndex.count {
+            let key = self.aImage!.displayIndex[i]
+            if (self.cache.object(forKey: key as NSNumber) == nil) {
+                let image = decodeImage(source: self.aImage!.imageSource, index: key)
+                self.cache.setObject(image,forKey:key as NSNumber)
+            }
+        }
+    }
+
+    private func decodeImage(source: CGImageSource,index: Int) -> UIImage {
+        let image = UIImage(cgImage: CGImageSourceCreateImageAtIndex(source,index,nil)!)
+        UIGraphicsBeginImageContext(CGSize(width: image.size.width, height: image.size.height))
+        image.draw(in: CGRect(x: 0, y: 0,width: image.size.width, height: image.size.height))
+        let rawImage = UIGraphicsGetImageFromCurrentImageContext()
+        UIGraphicsEndImageContext()
+        return rawImage!
+    }
+
+    internal func timerFired() {
+        self.layer.contents = self.nextFrame?.cgImage
+        let nextAt = ((self.indexAt)+1)%(self.aImage!.displayIndex.count)
+        if (self.aImage!.displayIndex [nextAt] != self.aImage!.displayIndex [(self.indexAt)]) {
+            DispatchQueue.global(qos: DispatchQoS.QoSClass.userInteractive).async {
+                let key = self.aImage!.displayIndex[nextAt]
+                self.nextFrame = self.cache.object(forKey: key as AnyObject) as? UIImage
+                if (self.nextFrame == nil){
+                    self.nextFrame = self.decodeImage(source: self.aImage!.imageSource, index: key)
+                }
+            }
+        }
+        if (self.play == true){
+            self.indexAt = nextAt
+            if (self.indexAt == self.aImage!.displayIndex.count - 1) {
+                self.aImage!.loopCount -= 1
+                if (self.aImage!.loopCount == 0) {
+                    self.play = false
+                }
+            }
+        }
+    }
+}
+
+public class AImage {
+
+    fileprivate let imageSource: CGImageSource
+    fileprivate var framePerSecond:Int
+    fileprivate var displayIndex:[Int]
+    fileprivate var loopCount:Int
+
+    /* Create an 'AImage' from URL */
+    //quality: display quality, 1 is best, 0 is worst
+    //loop: display time, -1 means forever
+    convenience init?(url: URL, quality: Float = 1.0, loop: Int = -1) {
+        guard let src = CGImageSourceCreateWithURL(url as CFURL, nil) else {
+            return nil
+        }
+        self.init(source: src, quality, loop)
+    }
+
+    /* Create an 'AImage' from Data */
+    //quality: display quality, 1 is best, 0 is worst
+    //loop: display time, -1 means forever
+    convenience init?(data: Data, quality: Float = 1.0, loop: Int = -1) {
+        guard let src = CGImageSourceCreateWithData(data as CFData, nil) else {
+            return nil
+        }
+        self.init(source: src, quality, loop)
+    }
+
+    private init(source: CGImageSource, _ quality: Float, _ loop: Int) {
+        self.imageSource = source
+        var frameDelays = AImage.calcuDelayTimes(imageSource:source)
+        (self.framePerSecond,self.displayIndex) = AImage.calculateFrameDelay(&frameDelays, quality)
+        self.loopCount = loop
+    }
+
+    private class func calcuDelayTimes(imageSource: CGImageSource) -> [Float] {
+
+        let frameCount = CGImageSourceGetCount(imageSource)
+        var imageProperties = [CFDictionary]()
+        for i in 0..<frameCount {
+            imageProperties.append(CGImageSourceCopyPropertiesAtIndex(imageSource, i, nil)!)
+        }
+
+        var frameProperties = [CFDictionary]()
+        if (CFDictionaryContainsKey(imageProperties[1],
+            Unmanaged.passUnretained(kCGImagePropertyGIFDictionary).toOpaque())) {
+            frameProperties = imageProperties.map() {
+                unsafeBitCast(CFDictionaryGetValue($0, Unmanaged.passUnretained(kCGImagePropertyGIFDictionary).toOpaque()), to: CFDictionary.self)
+            }//gif
+        } else if (CFDictionaryContainsKey(imageProperties[1],
+            Unmanaged.passUnretained(kCGImagePropertyPNGDictionary).toOpaque())) {
+            frameProperties = imageProperties.map() {
+                unsafeBitCast(CFDictionaryGetValue($0,
+                   Unmanaged.passUnretained(kCGImagePropertyPNGDictionary).toOpaque()),to: CFDictionary.self)
+            }//apng
+        } else {
+            fatalError("Illegal image type.")
+        }
+
+        let frameDelays: [Float] = frameProperties.map() {
+            var delayObject: AnyObject = unsafeBitCast(CFDictionaryGetValue($0, Unmanaged.passUnretained(kCGImagePropertyGIFUnclampedDelayTime).toOpaque()), to: AnyObject.self)
+            if (delayObject.floatValue == 0.0){
+                delayObject = unsafeBitCast(CFDictionaryGetValue($0, Unmanaged.passUnretained(kCGImagePropertyGIFDelayTime).toOpaque()), to: AnyObject.self)
+            }
+            return delayObject as! Float
+        }
+        return frameDelays
+    }
+
+    private class func calculateFrameDelay(_ delays: inout [Float],_ quality: Float) -> (Int,[Int]) {
+
+        let framePerSecondChoices = [1,2,3,4,5,6,10,12,15,20,30,60]
+        let displayRefreshDelayTime = framePerSecondChoices.map{ 1.0 / Float($0) }
+        for i in 1..<delays.count {
+            delays[i] += delays[i-1]
+        }
+
+        var order: [Int] = [Int]()
+        var fps: Int = framePerSecondChoices.last!
+        for i in 0..<framePerSecondChoices.count {
+            let displayPosition = delays.map{ Int($0 / displayRefreshDelayTime[i]) }
+            var framelosecount = 0
+            for j in 1..<displayPosition.count {
+                if (displayPosition[j] == displayPosition[j-1])
+                {framelosecount += 1}
+            }
+            if (Float(framelosecount) <= Float(displayPosition.count) * (1 - quality) || i == displayRefreshDelayTime.count - 1) {
+                fps = framePerSecondChoices[i]
+                var indexOfold = 0, indexOfnew = 1
+                while (indexOfnew <= displayPosition.last!) {
+                    if (indexOfnew <= displayPosition[indexOfold]) {
+                        order.append(indexOfold)
+                        indexOfnew += 1
+                    } else {
+                        indexOfold += 1
+                    }
+                }
+                break
+            }
+        }
+        return (fps,order)
+    }
+}
+
+// Use a proxy object to break the CADisplayLink retain cycle
+fileprivate class myDisplayLinkProxyObject {
+    weak var myListener: AImageView?
+    init(listener: AImageView) {
+        myListener = listener
+    }
+    @objc func proxyUpdateAnimation(link: CADisplayLink) {
+        myListener?.timerFired()
+    }
+}