react-native-fast-image 8.30.1 → 8.31.0

package/ios/FastImage/FFFAnimatedAVIFCoder.m

@@ -0,0 +1,103 @@
+#import "FFFAnimatedAVIFCoder.h"
+#import <ImageIO/ImageIO.h>
+
+// SDWebImage has no format for AVIF: this is the value SDWebImageAVIFCoder
+// uses, so an image reports the same format with either coder.
+static const SDImageFormat FFFImageFormatAVIF = 15;
+
+// Whether the data is an animated AVIF: a file whose first box is `ftyp`
+// with the `avis` (image sequence) brand, as its major brand or a compatible
+// one. The header comes first, so a partial download can be checked too.
+static BOOL FFFIsAnimatedAVIF(NSData* data) {
+    if (data.length < 16) {
+        return NO;
+    }
+    const uint8_t* bytes = data.bytes;
+    if (memcmp(bytes + 4, "ftyp", 4) != 0) {
+        return NO;
+    }
+    if (memcmp(bytes + 8, "avis", 4) == 0) {
+        return YES;
+    }
+    // The compatible brands, after the major brand and its version.
+    uint32_t size = (uint32_t)bytes[0] << 24 | (uint32_t)bytes[1] << 16 | (uint32_t)bytes[2] << 8 | bytes[3];
+    NSUInteger end = MIN((NSUInteger)size, data.length);
+    for (NSUInteger offset = 16; offset + 4 <= end; offset += 4) {
+        if (memcmp(bytes + offset, "avis", 4) == 0) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+// Whether ImageIO reads AVIF image sequences on this version of iOS.
+static BOOL FFFCanDecodeAVIFSequences(void) {
+    static BOOL supported;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        NSArray* types = CFBridgingRelease(CGImageSourceCopyTypeIdentifiers());
+        supported = [types containsObject: @"public.avis"];
+    });
+    return supported;
+}
+
+@implementation FFFAnimatedAVIFCoder
+
++ (FFFAnimatedAVIFCoder*) sharedCoder {
+    static FFFAnimatedAVIFCoder* coder;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        coder = [FFFAnimatedAVIFCoder new];
+    });
+    return coder;
+}
+
+- (BOOL) canDecodeFromData: (NSData*)data {
+    return FFFIsAnimatedAVIF(data) && FFFCanDecodeAVIFSequences();
+}
+
+- (BOOL) canIncrementalDecodeFromData: (NSData*)data {
+    return [self canDecodeFromData: data];
+}
+
+// Only for decoding.
+- (BOOL) canEncodeToFormat: (SDImageFormat)format {
+    return NO;
+}
+
+#pragma mark - SDImageIOAnimatedCoder
+
++ (SDImageFormat) imageFormat {
+    return FFFImageFormatAVIF;
+}
+
++ (NSString*) imageUTType {
+    return @"public.avis";
+}
+
+// ImageIO's keys for AVIF sequences (kCGImagePropertyAVIS…), as strings so
+// they build with any SDK. LoopCount is the number of plays, 0 for forever,
+// as for GIF and APNG.
++ (NSString*) dictionaryProperty {
+    return @"{AVIS}";
+}
+
++ (NSString*) unclampedDelayTimeProperty {
+    return @"UnclampedDelayTime";
+}
+
++ (NSString*) delayTimeProperty {
+    return @"DelayTime";
+}
+
++ (NSString*) loopCountProperty {
+    return @"LoopCount";
+}
+
+// A sequence without a repetition count plays forever (ImageIO reports
+// LoopCount 0 for one).
++ (NSUInteger) defaultLoopCount {
+    return 0;
+}
+
+@end

package/ios/FastImage/FFFastImageSource.h

@@ -72,6 +72,10 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 // a cache, where the size it was decoded from isn't recorded), or zero.
 - (CGSize)photoPixelSize;
 
+// Whether the data is an image FastImage can show: a format SDWebImage
+// recognizes (an SVG only if its first element is <svg>), or one ImageIO
+// reads that SDWebImage's check doesn't know (AVIF, ICO, ICNS, PSD).
++ (BOOL)isImageData:(NSData *)data;
 // The HTTP cache of `cache: 'web'` images: their own rather than the app's
 // shared NSURLCache, so clearDiskCache can empty it without the app's other
 // responses. 50 MB, as on Android.

package/ios/FastImage/FFFastImageSource.m

@@ -8,7 +8,9 @@
 #import <SDWebImage/SDImageCodersManager.h>
 #import <SDWebImage/SDImageAWebPCoder.h>
 #import "FFFAnimatedWebPCoder.h"
+#import "FFFAnimatedAVIFCoder.h"
 #import <objc/message.h>
+#import <ImageIO/ImageIO.h>
 
 // In FFFastImageView.m.
 FOUNDATION_EXTERN NSString *FFFErrorMessage(NSError *error);
@@ -224,8 +226,7 @@ static BOOL FFFLooksLikeSVG(NSData *data)
  willCacheResponse:(NSCachedURLResponse *)proposedResponse
  completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler
 {
-    SDImageFormat format = [NSData sd_imageFormatForImageData:proposedResponse.data];
-    if (format == SDImageFormatUndefined || (format == SDImageFormatSVG && !FFFLooksLikeSVG(proposedResponse.data))) {
+    if (![FFFastImageSource isImageData:proposedResponse.data]) {
         completionHandler(nil);
         return;
     }
@@ -260,6 +261,21 @@ static id<SDImageCoder> FFFSVGCoder;
         [SDImageCodersManager.sharedManager addCoder:FFFAnimatedWebPCoder.sharedCoder];
     }
 
+    // Animated AVIF: likewise, SDWebImage's own coders only decode an AVIF's
+    // first frame, so ImageIO's animated decoding does (iOS 16 and later).
+    // Not if the app has registered libavif's coder (SDWebImageAVIFCoder).
+    Class avifCoderClass = NSClassFromString(@"SDImageAVIFCoder");
+    BOOL hasAVIFCoder = NO;
+    for (id<SDImageCoder> registered in SDImageCodersManager.sharedManager.coders) {
+        if (avifCoderClass && [registered isKindOfClass:avifCoderClass]) {
+            hasAVIFCoder = YES;
+            break;
+        }
+    }
+    if (!hasAVIFCoder) {
+        [SDImageCodersManager.sharedManager addCoder:FFFAnimatedAVIFCoder.sharedCoder];
+    }
+
     // SVG: registered with SDWebImage's coders, as the pod's setup does (unless
     // the app has already): SDWebImage then picks it for SVG data, including
     // for FastImage's animated and downsampled image classes. Giving the
@@ -396,6 +412,24 @@ static id<SDImageCoder> FFFSVGCoder;
     [[FFFastImageSource webURLCache] removeCachedResponseForRequest:[NSURLRequest requestWithURL:_url]];
 }
 
++ (BOOL)isImageData:(NSData *)data
+{
+    SDImageFormat format = [NSData sd_imageFormatForImageData:data];
+    if (format == SDImageFormatSVG) {
+        return FFFLooksLikeSVG(data);
+    }
+    if (format != SDImageFormatUndefined) {
+        return YES;
+    }
+    CGImageSourceRef source = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL);
+    if (!source) {
+        return NO;
+    }
+    BOOL image = CGImageSourceGetType(source) != NULL && CGImageSourceGetCount(source) > 0;
+    CFRelease(source);
+    return image;
+}
+
 + (NSURLCache *)webURLCache
 {
     static NSURLCache *cache;

package/ios/FastImage/FFFastImageViewManager.m

@@ -6,7 +6,6 @@
 #import <SDWebImage/SDWebImageManager.h>
 #import <SDWebImage/SDWebImageError.h>
 #import <SDWebImage/SDWebImagePrefetcher.h>
-#import <SDWebImage/NSData+ImageContentType.h>
 
 // configureCache's limits, by their names in JS. Each is set in the app's
 // Info.plist (FastImageMaxDiskSize, ...) or changed at runtime, which is saved
@@ -405,7 +404,7 @@ RCT_EXPORT_METHOD(writeToCache:(FFFastImageSource *)source
                 resolve(FFFFailure(@"Can't read the file"));
                 return;
             }
-            if ([NSData sd_imageFormatForImageData:data] == SDImageFormatUndefined) {
+            if (![FFFastImageSource isImageData:data]) {
                 resolve(FFFFailure(@"Not an image"));
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.30.1",
+    "version": "8.31.0",
     "description": "FastImage, performant React Native image component.",
     "keywords": [
         "cache",
@@ -38,7 +38,9 @@
         "RNFastImage.podspec"
     ],
     "scripts": {
-        "build": "rm -rf dist && tsc -p tsconfig.build.json && rolldown -c && for f in index index.cjs index.web index.cjs.web; do cp src/index.js.flow dist/$f.js.flow; done",
+        "build": "bun run build:package && bun run build:docs",
+        "build:package": "rm -rf dist && tsc -p tsconfig.build.json && rolldown -c",
+        "build:docs": "bun run --cwd website build",
         "lint": "oxlint",
         "release": "semantic-release",
         "test": "bun test",