GLEGram 12.5 — Initial public release

Based on Swiftgram 12.5 (Telegram iOS 12.5).
All GLEGram features ported and organized in GLEGram/ folder.

Features: Ghost Mode, Saved Deleted Messages, Content Protection Bypass,
Font Replacement, Fake Profile, Chat Export, Plugin System, and more.

See CHANGELOG_12.5.md for full details.

submodules/LocalMediaResources/Sources/FetchPhotoLibraryImageResource.swift

@@ -0,0 +1,298 @@
+import SGSimpleSettings
+import Foundation
+import UIKit
+import Photos
+import Postbox
+import SwiftSignalKit
+import ImageCompression
+import Accelerate.vImage
+import CoreImage
+
+private final class RequestId {
+    var id: PHImageRequestID?
+    var invalidated: Bool = false
+}
+
+private func resizedImage(_ image: UIImage, for size: CGSize) -> UIImage? {
+    guard let cgImage = image.cgImage else {
+        return nil
+    }
+    
+    if #available(iOS 14.1, *) {
+        if cgImage.bitsPerComponent == 10, let ciImage = CIImage(image: image, options: [.applyOrientationProperty: true, .toneMapHDRtoSDR: true]) {
+            let scaleX = size.width / ciImage.extent.width
+            
+            let filter = CIFilter(name: "CILanczosScaleTransform")!
+            filter.setValue(ciImage, forKey: kCIInputImageKey)
+            filter.setValue(scaleX, forKey: kCIInputScaleKey)
+            filter.setValue(1.0, forKey: kCIInputAspectRatioKey)
+            
+            guard let outputImage = filter.outputImage else { return nil }
+            
+            let ciContext = CIContext()
+            guard let cgImage = ciContext.createCGImage(outputImage, from: outputImage.extent) else { return nil }
+            
+            return UIImage(cgImage: cgImage)
+        }
+    }
+    var format = vImage_CGImageFormat(bitsPerComponent: 8,
+                                      bitsPerPixel: 32,
+                                      colorSpace: nil,
+                                      bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.first.rawValue),
+                                      version: 0,
+                                      decode: nil,
+                                      renderingIntent: cgImage.renderingIntent)
+
+    var error: vImage_Error
+    var sourceBuffer = vImage_Buffer()
+    defer { sourceBuffer.data?.deallocate() }
+    error = vImageBuffer_InitWithCGImage(&sourceBuffer,
+                                         &format,
+                                         nil,
+                                         cgImage,
+                                         vImage_Flags(kvImageNoFlags))
+    guard error == kvImageNoError else {
+        return nil
+    }
+
+    var destinationBuffer = vImage_Buffer()
+    error = vImageBuffer_Init(&destinationBuffer,
+                              vImagePixelCount(size.height),
+                              vImagePixelCount(size.width),
+                              format.bitsPerPixel,
+                              vImage_Flags(kvImageNoFlags))
+    guard error == kvImageNoError else {
+        return nil
+    }
+
+    error = vImageScale_ARGB8888(&sourceBuffer,
+                                 &destinationBuffer,
+                                 nil,
+                                 vImage_Flags(kvImageHighQualityResampling))
+    guard error == kvImageNoError else {
+        return nil
+    }
+
+    guard let resizedImage =
+        vImageCreateCGImageFromBuffer(&destinationBuffer,
+                                      &format,
+                                      nil,
+                                      nil,
+                                      vImage_Flags(kvImageNoAllocate),
+                                      &error)?.takeRetainedValue(),
+        error == kvImageNoError
+    else {
+        return nil
+    }
+
+    return UIImage(cgImage: resizedImage)
+}
+
+extension UIImage.Orientation {
+    init(_ cgOrientation: CGImagePropertyOrientation) {
+        switch cgOrientation {
+            case .up: self = .up
+            case .upMirrored: self = .upMirrored
+            case .down: self = .down
+            case .downMirrored: self = .downMirrored
+            case .left: self = .left
+            case .leftMirrored: self = .leftMirrored
+            case .right: self = .right
+            case .rightMirrored: self = .rightMirrored
+        }
+    }
+}
+
+private let fetchPhotoWorkers = ThreadPool(threadCount: 3, threadPriority: 0.2)
+
+public func fetchPhotoLibraryResource(localIdentifier: String, width: Int32?, height: Int32?, format: MediaImageFormat?, quality: Int32?, hd: Bool, useExif: Bool) -> Signal<MediaResourceDataFetchResult, MediaResourceDataFetchError> {
+    return Signal { subscriber in
+        let queue = ThreadPoolQueue(threadPool: fetchPhotoWorkers)
+        
+        let fetchResult = PHAsset.fetchAssets(withLocalIdentifiers: [localIdentifier], options: nil)
+        let requestId = Atomic<RequestId>(value: RequestId())
+        if fetchResult.count != 0 {
+            let asset = fetchResult.object(at: 0)
+            let option = PHImageRequestOptions()
+            option.deliveryMode = .highQualityFormat
+            option.isNetworkAccessAllowed = true
+            option.isSynchronous = false
+                        
+            let size: CGSize
+            if let width, let height {
+                size = CGSize(width: CGFloat(width), height: CGFloat(height))
+            } else {
+                if hd {
+                    size = CGSize(width: 2560.0, height: 2560.0)
+                } else {
+                    size = CGSize(width: 1280.0, height: 1280.0)
+                }
+            }
+            
+            var targetSize = PHImageManagerMaximumSize
+            //TODO: figure out how to manually read and resize some weird 10-bit heif photos from third-party cameras
+            if useExif, min(asset.pixelWidth, asset.pixelHeight) > 3800 {
+                func encodeText(string: String, key: Int16) -> String {
+                    let nsString = string as NSString
+                    let result = NSMutableString()
+                    for i in 0 ..< nsString.length {
+                        var c: unichar = nsString.character(at: i)
+                        c = unichar(Int16(c) + key)
+                        result.append(NSString(characters: &c, length: 1) as String)
+                    }
+                    return result as String
+                }
+                if let values = asset.value(forKeyPath: encodeText(string: "jnbhfQspqfsujft", key: -1)) as? [String: Any] {
+                    if let depth = values["Depth"] as? Int, depth == 10 {
+                        targetSize = size
+                    }
+                }
+            }
+            
+            queue.addTask(ThreadPoolTask({ _ in
+                let startTime = CACurrentMediaTime()
+                
+                let semaphore = DispatchSemaphore(value: 0)
+                let requestIdValue = PHImageManager.default().requestImage(for: asset, targetSize: targetSize, contentMode: .aspectFit, options: option, resultHandler: { (image, info) -> Void in
+                    Queue.concurrentDefaultQueue().async {
+                        requestId.with { current -> Void in
+                            if !current.invalidated {
+                                current.id = nil
+                                current.invalidated = true
+                            }
+                        }
+                        if let image = image {
+                            if let info = info, let degraded = info[PHImageResultIsDegradedKey], (degraded as AnyObject).boolValue!{
+
+                            } else {
+#if DEBUG
+                                print("load completion \((CACurrentMediaTime() - startTime) * 1000.0) ms")
+#endif
+                                
+                                let scale = min(1.0, min(size.width / max(1.0, image.size.width), size.height / max(1.0, image.size.height)))
+                                let scaledSize = CGSize(width: floor(image.size.width * scale), height: floor(image.size.height * scale))
+                                let scaledImage = resizedImage(image, for: scaledSize)
+                                
+#if DEBUG
+                                print("scaled completion \((CACurrentMediaTime() - startTime) * 1000.0) ms")
+#endif
+                                
+                                switch format {
+                                case .none, .jpeg:
+                                    let tempFile = TempBox.shared.tempFile(fileName: "file")
+                                    defer {
+                                        TempBox.shared.dispose(tempFile)
+                                    }
+                                    if let scaledImage = scaledImage, let data = compressImageToJPEG(scaledImage, quality: Float(SGSimpleSettings.shared.outgoingPhotoQuality) / 100.0, tempFilePath: tempFile.path) {
+    #if DEBUG
+                                        print("compression completion \((CACurrentMediaTime() - startTime) * 1000.0) ms")
+    #endif
+                                        subscriber.putNext(.dataPart(resourceOffset: 0, data: data, range: 0 ..< Int64(data.count), complete: true))
+                                        subscriber.putCompletion()
+                                    } else {
+                                        subscriber.putCompletion()
+                                    }
+                                case .jxl:
+                                    if let scaledImage = scaledImage, let data = compressImageToJPEGXL(scaledImage, quality: Int(SGSimpleSettings.shared.outgoingPhotoQuality)) {
+    #if DEBUG
+                                        print("jpegxl compression completion \((CACurrentMediaTime() - startTime) * 1000.0) ms")
+    #endif
+                                        subscriber.putNext(.dataPart(resourceOffset: 0, data: data, range: 0 ..< Int64(data.count), complete: true))
+                                        subscriber.putCompletion()
+                                    } else {
+                                        subscriber.putCompletion()
+                                    }
+                                }
+                                semaphore.signal()
+                            }
+                        } else {
+                            semaphore.signal()
+                        }
+                    }
+                })
+                requestId.with { current -> Void in
+                    if !current.invalidated {
+                        current.id = requestIdValue
+                    }
+                }
+                semaphore.wait()
+            }))
+        } else {
+            subscriber.putNext(.reset)
+        }
+        
+        return ActionDisposable {
+            let requestIdValue = requestId.with { current -> PHImageRequestID? in
+                if !current.invalidated {
+                    let value = current.id
+                    current.id = nil
+                    current.invalidated = true
+                    return value
+                } else {
+                    return nil
+                }
+            }
+            if let requestIdValue = requestIdValue {
+                PHImageManager.default().cancelImageRequest(requestIdValue)
+            }
+        }
+    }
+}
+
+public func fetchPhotoLibraryImage(localIdentifier: String, thumbnail: Bool) -> Signal<(UIImage, Bool)?, NoError> {
+    return Signal { subscriber in
+        let fetchResult = PHAsset.fetchAssets(withLocalIdentifiers: [localIdentifier], options: nil)
+        let requestId = Atomic<RequestId>(value: RequestId())
+        if fetchResult.count != 0 {
+            let asset = fetchResult.object(at: 0)
+            let option = PHImageRequestOptions()
+            option.deliveryMode = .highQualityFormat
+            if thumbnail {
+                option.resizeMode = .fast
+            }
+            option.isNetworkAccessAllowed = true
+            option.isSynchronous = false
+            
+            let targetSize: CGSize = thumbnail ? CGSize(width: 128.0, height: 128.0) : PHImageManagerMaximumSize
+            let requestIdValue = PHImageManager.default().requestImage(for: asset, targetSize: targetSize, contentMode: .aspectFill, options: option, resultHandler: { (image, info) -> Void in
+                Queue.concurrentDefaultQueue().async {
+                    requestId.with { current -> Void in
+                        if !current.invalidated {
+                            current.id = nil
+                            current.invalidated = true
+                        }
+                    }
+                    if let image = image {
+                        subscriber.putNext((image, thumbnail))
+                        subscriber.putCompletion()
+                    }
+                }
+            })
+            requestId.with { current -> Void in
+                if !current.invalidated {
+                    current.id = requestIdValue
+                }
+            }
+        } else {
+            subscriber.putNext(nil)
+            subscriber.putCompletion()
+        }
+        
+        return ActionDisposable {
+            let requestIdValue = requestId.with { current -> PHImageRequestID? in
+                if !current.invalidated {
+                    let value = current.id
+                    current.id = nil
+                    current.invalidated = true
+                    return value
+                } else {
+                    return nil
+                }
+            }
+            if let requestIdValue = requestIdValue {
+                PHImageManager.default().cancelImageRequest(requestIdValue)
+            }
+        }
+    }
+}
+

submodules/LocalMediaResources/Sources/MediaResources.swift

@@ -0,0 +1,499 @@
+import Foundation
+import UIKit
+import Postbox
+import TelegramCore
+import PersistentStringHash
+
+public final class VideoMediaResourceAdjustments: PostboxCoding, Equatable {
+    public let data: MemoryBuffer
+    public let digest: MemoryBuffer
+    public let isStory: Bool
+    
+    public init(data: MemoryBuffer, digest: MemoryBuffer, isStory: Bool = false) {
+        self.data = data
+        self.digest = digest
+        self.isStory = isStory
+    }
+    
+    public init(decoder: PostboxDecoder) {
+        self.data = decoder.decodeBytesForKey("d")!
+        self.digest = decoder.decodeBytesForKey("h")!
+        self.isStory = decoder.decodeBoolForKey("s", orElse: false)
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeBytes(self.data, forKey: "d")
+        encoder.encodeBytes(self.digest, forKey: "h")
+        encoder.encodeBool(self.isStory, forKey: "s")
+    }
+    
+    public static func ==(lhs: VideoMediaResourceAdjustments, rhs: VideoMediaResourceAdjustments) -> Bool {
+        return lhs.data == rhs.data && lhs.digest == rhs.digest && lhs.isStory == rhs.isStory
+    }
+}
+
+public struct VideoLibraryMediaResourceId {
+    public let localIdentifier: String
+    public let adjustmentsDigest: MemoryBuffer?
+    
+    public var uniqueId: String {
+        if let adjustmentsDigest = self.adjustmentsDigest {
+            return "vi-\(self.localIdentifier.replacingOccurrences(of: "/", with: "_"))-\(adjustmentsDigest.description)"
+        } else {
+            return "vi-\(self.localIdentifier.replacingOccurrences(of: "/", with: "_"))"
+        }
+    }
+    
+    public var hashValue: Int {
+        return self.localIdentifier.hashValue
+    }
+}
+
+public enum VideoLibraryMediaResourceConversion: PostboxCoding, Equatable {
+    case passthrough
+    case compress(VideoMediaResourceAdjustments?)
+    
+    public init(decoder: PostboxDecoder) {
+        switch decoder.decodeInt32ForKey("v", orElse: 0) {
+            case 0:
+                self = .passthrough
+            case 1:
+                self = .compress(decoder.decodeObjectForKey("adj", decoder: { VideoMediaResourceAdjustments(decoder: $0) }) as? VideoMediaResourceAdjustments)
+            default:
+                self = .compress(nil)
+        }
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        switch self {
+            case .passthrough:
+                encoder.encodeInt32(0, forKey: "v")
+            case let .compress(adjustments):
+                encoder.encodeInt32(1, forKey: "v")
+                if let adjustments = adjustments {
+                    encoder.encodeObject(adjustments, forKey: "adj")
+                } else {
+                    encoder.encodeNil(forKey: "adj")
+                }
+        }
+    }
+    
+    public static func ==(lhs: VideoLibraryMediaResourceConversion, rhs: VideoLibraryMediaResourceConversion) -> Bool {
+        switch lhs {
+            case .passthrough:
+                if case .passthrough = rhs {
+                    return true
+                } else {
+                    return false
+                }
+            case let .compress(lhsAdjustments):
+                if case let .compress(rhsAdjustments) = rhs, lhsAdjustments == rhsAdjustments {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+}
+
+public final class VideoLibraryMediaResource: TelegramMediaResource {
+    public let localIdentifier: String
+    public let conversion: VideoLibraryMediaResourceConversion
+    
+    public var size: Int64? {
+        return nil
+    }
+    
+    public var headerSize: Int32 {
+        return 32 * 1024
+    }
+    
+    public init(localIdentifier: String, conversion: VideoLibraryMediaResourceConversion) {
+        self.localIdentifier = localIdentifier
+        self.conversion = conversion
+    }
+    
+    public required init(decoder: PostboxDecoder) {
+        self.localIdentifier = decoder.decodeStringForKey("i", orElse: "")
+        self.conversion = (decoder.decodeObjectForKey("conv", decoder: { VideoLibraryMediaResourceConversion(decoder: $0) }) as? VideoLibraryMediaResourceConversion) ?? .compress(nil)
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeString(self.localIdentifier, forKey: "i")
+        encoder.encodeObject(self.conversion, forKey: "conv")
+    }
+    
+    public var id: MediaResourceId {
+        var adjustmentsDigest: MemoryBuffer?
+        switch self.conversion {
+            case .passthrough:
+                break
+            case let .compress(adjustments):
+                adjustmentsDigest = adjustments?.digest
+        }
+        return MediaResourceId(VideoLibraryMediaResourceId(localIdentifier: self.localIdentifier, adjustmentsDigest: adjustmentsDigest).uniqueId)
+    }
+    
+    public func isEqual(to: MediaResource) -> Bool {
+        if let to = to as? VideoLibraryMediaResource {
+            return self.localIdentifier == to.localIdentifier && self.conversion == to.conversion
+        } else {
+            return false
+        }
+    }
+}
+
+public struct LocalFileVideoMediaResourceId {
+    public let randomId: Int64
+    
+    public var uniqueId: String {
+        return "lvi-\(self.randomId)"
+    }
+    
+    public var hashValue: Int {
+        return self.randomId.hashValue
+    }
+}
+
+public final class LocalFileVideoMediaResource: TelegramMediaResource {
+    public var size: Int64? {
+        return nil
+    }
+    
+    public let randomId: Int64
+    public let paths: [String]
+    public let adjustments: VideoMediaResourceAdjustments?
+    
+    public var headerSize: Int32 {
+        return 32 * 1024
+    }
+    
+    public init(randomId: Int64, path: String, adjustments: VideoMediaResourceAdjustments?) {
+        self.randomId = randomId
+        self.paths = [path]
+        self.adjustments = adjustments
+    }
+    
+    public init(randomId: Int64, paths: [String], adjustments: VideoMediaResourceAdjustments?) {
+        self.randomId = randomId
+        self.paths = paths
+        self.adjustments = adjustments
+    }
+    
+    public required init(decoder: PostboxDecoder) {
+        self.randomId = decoder.decodeInt64ForKey("i", orElse: 0)
+        let paths = decoder.decodeStringArrayForKey("ps")
+        if !paths.isEmpty {
+            self.paths = paths
+        } else {
+            self.paths = [decoder.decodeStringForKey("p", orElse: "")]
+        }
+        self.adjustments = decoder.decodeObjectForKey("a", decoder: { VideoMediaResourceAdjustments(decoder: $0) }) as? VideoMediaResourceAdjustments
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeInt64(self.randomId, forKey: "i")
+        encoder.encodeStringArray(self.paths, forKey: "ps")
+        if let adjustments = self.adjustments {
+            encoder.encodeObject(adjustments, forKey: "a")
+        } else {
+            encoder.encodeNil(forKey: "a")
+        }
+    }
+    
+    public var id: MediaResourceId {
+        return MediaResourceId(LocalFileVideoMediaResourceId(randomId: self.randomId).uniqueId)
+    }
+    
+    public func isEqual(to: MediaResource) -> Bool {
+        if let to = to as? LocalFileVideoMediaResource {
+            return self.randomId == to.randomId && self.paths == to.paths && self.adjustments == to.adjustments
+        } else {
+            return false
+        }
+    }
+}
+
+public struct LocalFileAudioMediaResourceId {
+    public let randomId: Int64
+    
+    public var uniqueId: String {
+        return "lad-\(self.randomId)"
+    }
+    
+    public var hashValue: Int {
+        return self.randomId.hashValue
+    }
+}
+
+public final class LocalFileAudioMediaResource: TelegramMediaResource {
+    public var size: Int64? {
+        return nil
+    }
+    
+    public let randomId: Int64
+    public let path: String
+    public let trimRange: Range<Double>?
+    
+    public var headerSize: Int32 {
+        return 32 * 1024
+    }
+    
+    public init(randomId: Int64, path: String, trimRange: Range<Double>?) {
+        self.randomId = randomId
+        self.path = path
+        self.trimRange = trimRange
+    }
+    
+    public required init(decoder: PostboxDecoder) {
+        self.randomId = decoder.decodeInt64ForKey("i", orElse: 0)
+        self.path = decoder.decodeStringForKey("p", orElse: "")
+        
+        if let trimLowerBound = decoder.decodeOptionalDoubleForKey("tl"), let trimUpperBound = decoder.decodeOptionalDoubleForKey("tu") {
+            self.trimRange = trimLowerBound ..< trimUpperBound
+        } else {
+            self.trimRange = nil
+        }
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeInt64(self.randomId, forKey: "i")
+        encoder.encodeString(self.path, forKey: "p")
+        
+        if let trimRange = self.trimRange {
+            encoder.encodeDouble(trimRange.lowerBound, forKey: "tl")
+            encoder.encodeDouble(trimRange.upperBound, forKey: "tu")
+        } else {
+            encoder.encodeNil(forKey: "tl")
+            encoder.encodeNil(forKey: "tu")
+        }
+    }
+    
+    public var id: MediaResourceId {
+        return MediaResourceId(LocalFileAudioMediaResourceId(randomId: self.randomId).uniqueId)
+    }
+    
+    public func isEqual(to: MediaResource) -> Bool {
+        if let to = to as? LocalFileAudioMediaResource {
+            return self.randomId == to.randomId && self.path == to.path && self.trimRange == to.trimRange
+        } else {
+            return false
+        }
+    }
+}
+
+public struct PhotoLibraryMediaResourceId {
+    public let localIdentifier: String
+    public let resourceId: Int64
+    
+    public var uniqueId: String {
+        if self.resourceId != 0 {
+            return "ph-\(self.localIdentifier.replacingOccurrences(of: "/", with: "_"))-\(self.resourceId)"
+        } else {
+            return "ph-\(self.localIdentifier.replacingOccurrences(of: "/", with: "_"))"
+        }
+    }
+    
+    public var hashValue: Int {
+        return self.localIdentifier.hashValue
+    }
+}
+
+public enum MediaImageFormat: Int32 {
+    case jpeg
+    case jxl
+}
+
+public class PhotoLibraryMediaResource: TelegramMediaResource {
+    public var size: Int64? {
+        return nil
+    }
+    
+    public let localIdentifier: String
+    public let uniqueId: Int64
+    public let width: Int32?
+    public let height: Int32?
+    public let format: MediaImageFormat?
+    public let quality: Int32?
+    public let forceHd: Bool
+    
+    public init(localIdentifier: String, uniqueId: Int64, width: Int32? = nil, height: Int32? = nil, format: MediaImageFormat? = nil, quality: Int32? = nil, forceHd: Bool = false) {
+        self.localIdentifier = localIdentifier
+        self.uniqueId = uniqueId
+        self.width = width
+        self.height = height
+        self.format = format
+        self.quality = quality
+        self.forceHd = forceHd
+    }
+    
+    public required init(decoder: PostboxDecoder) {
+        self.localIdentifier = decoder.decodeStringForKey("i", orElse: "")
+        self.uniqueId = decoder.decodeInt64ForKey("uid", orElse: 0)
+        self.width = decoder.decodeOptionalInt32ForKey("w")
+        self.height = decoder.decodeOptionalInt32ForKey("h")
+        self.format = decoder.decodeOptionalInt32ForKey("f").flatMap(MediaImageFormat.init(rawValue:))
+        self.quality = decoder.decodeOptionalInt32ForKey("q")
+        self.forceHd = decoder.decodeBoolForKey("hd", orElse: false)
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeString(self.localIdentifier, forKey: "i")
+        encoder.encodeInt64(self.uniqueId, forKey: "uid")
+        if let width = self.width {
+            encoder.encodeInt32(width, forKey: "w")
+        } else {
+            encoder.encodeNil(forKey: "w")
+        }
+        if let height = self.height {
+            encoder.encodeInt32(height, forKey: "h")
+        } else {
+            encoder.encodeNil(forKey: "h")
+        }
+        if let format = self.format {
+            encoder.encodeInt32(format.rawValue, forKey: "f")
+        } else {
+            encoder.encodeNil(forKey: "f")
+        }
+        if let quality = self.quality {
+            encoder.encodeInt32(quality, forKey: "q")
+        } else {
+            encoder.encodeNil(forKey: "q")
+        }
+        encoder.encodeBool(self.forceHd, forKey: "hd")
+    }
+    
+    public var id: MediaResourceId {
+        return MediaResourceId(PhotoLibraryMediaResourceId(localIdentifier: self.localIdentifier, resourceId: self.uniqueId).uniqueId)
+    }
+    
+    public func isEqual(to: MediaResource) -> Bool {
+        if let to = to as? PhotoLibraryMediaResource {
+            if self.localIdentifier != to.localIdentifier {
+                return false
+            }
+            if self.uniqueId != to.uniqueId {
+                return false
+            }
+            if self.width != to.width {
+                return false
+            }
+            if self.height != to.height {
+                return false
+            }
+            if self.format != to.format {
+                return false
+            }
+            if self.quality != to.quality {
+                return false
+            }
+            if self.forceHd != to.forceHd {
+                return false
+            }
+            return true
+        } else {
+            return false
+        }
+    }
+}
+
+public struct LocalFileGifMediaResourceId {
+    public let randomId: Int64
+    
+    public var uniqueId: String {
+        return "lgi-\(self.randomId)"
+    }
+    
+    public var hashValue: Int {
+        return self.randomId.hashValue
+    }
+}
+
+public final class LocalFileGifMediaResource: TelegramMediaResource {
+    public var size: Int64? {
+        return nil
+    }
+    
+    public let randomId: Int64
+    public let path: String
+    
+    public var headerSize: Int32 {
+        return 32 * 1024
+    }
+    
+    public init(randomId: Int64, path: String) {
+        self.randomId = randomId
+        self.path = path
+    }
+    
+    public required init(decoder: PostboxDecoder) {
+        self.randomId = decoder.decodeInt64ForKey("i", orElse: 0)
+        self.path = decoder.decodeStringForKey("p", orElse: "")
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeInt64(self.randomId, forKey: "i")
+        encoder.encodeString(self.path, forKey: "p")
+    }
+    
+    public var id: MediaResourceId {
+        return MediaResourceId(LocalFileGifMediaResourceId(randomId: self.randomId).uniqueId)
+    }
+    
+    public func isEqual(to: MediaResource) -> Bool {
+        if let to = to as? LocalFileGifMediaResource {
+            return self.randomId == to.randomId && self.path == to.path
+        } else {
+            return false
+        }
+    }
+}
+
+
+public struct BundleResourceId {
+    public let nameHash: Int64
+    
+    public var uniqueId: String {
+        return "bundle-\(nameHash)"
+    }
+    
+    public var hashValue: Int {
+        return self.nameHash.hashValue
+    }
+}
+
+public class BundleResource: TelegramMediaResource {
+    public var size: Int64? {
+        return nil
+    }
+    
+    public let nameHash: Int64
+    public let path: String
+    
+    public init(name: String, path: String) {
+        self.nameHash = Int64(bitPattern: name.persistentHashValue)
+        self.path = path
+    }
+    
+    public required init(decoder: PostboxDecoder) {
+        self.nameHash = decoder.decodeInt64ForKey("h", orElse: 0)
+        self.path = decoder.decodeStringForKey("p", orElse: "")
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeInt64(self.nameHash, forKey: "h")
+        encoder.encodeString(self.path, forKey: "p")
+    }
+    
+    public var id: MediaResourceId {
+        return MediaResourceId(BundleResourceId(nameHash: self.nameHash).uniqueId)
+    }
+    
+    public func isEqual(to: MediaResource) -> Bool {
+        if let to = to as? BundleResource {
+            return self.nameHash == to.nameHash
+        } else {
+            return false
+        }
+    }
+}