Support libavif v0.6.0(decoder)

Author: ledyba-z

Cartfile

@@ -1,2 +1,2 @@
 github "SDWebImage/SDWebImage" ~> 5.0
-github "SDWebImage/libavif-Xcode" ~> 0.5
+github "SDWebImage/libavif-Xcode" ~> 0.6

Package.swift

@@ -18,7 +18,7 @@ let package = Package(
         // Dependencies declare other packages that this package depends on.
         // .package(url: /* package url */, from: "1.0.0"),
         .package(url: "https://github.com/SDWebImage/SDWebImage.git", from: "5.1.0"),
-        .package(url: "https://github.com/SDWebImage/libavif-Xcode.git", from: "0.5.0")
+        .package(url: "https://github.com/SDWebImage/libavif-Xcode.git", from: "0.6.0")
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.

SDWebImageAVIFCoder.podspec

@@ -36,5 +36,5 @@ Which is built based on the open-sourced libavif codec.
   s.source_files = 'SDWebImageAVIFCoder/Classes/**/*', 'SDWebImageAVIFCoder/Module/SDWebImageAVIFCoder.h'
 
   s.dependency 'SDWebImage', '~> 5.0'
-  s.dependency 'libavif', '~> 0.5'
+  s.dependency 'libavif', '~> 0.6'
 end

SDWebImageAVIFCoder/Classes/SDImageAVIFCoder.m

@@ -53,7 +53,16 @@ static void SetupConversionInfo(avifImage * avif,
                                 avifReformatState* state,
                                 vImage_YpCbCrToARGBMatrix* matrix,
                                 vImage_YpCbCrPixelRange* pixelRange) {
-    avifPrepareReformatState(avif, state);
+    avifRGBImage emptyRGBImage = {
+        .width = avif->width,
+        .height = avif->height,
+        .depth = avif->depth,
+        .format = AVIF_RGB_FORMAT_ARGB,
+
+        .pixels = NULL,
+        .rowBytes = 0,
+    };
+    avifPrepareReformatState(avif, &emptyRGBImage, state);
 
     // Setup Matrix
     matrix->Yp = 1.0f;
@@ -144,6 +153,7 @@ static CGImageRef CreateImage8(avifImage * avif) {
     uint8_t* argbBufferData = NULL;
     uint8_t* dummyCbData = NULL;
     uint8_t* dummyCrData = NULL;
+    uint8_t* scaledAlphaBufferData = NULL;
 
     vImage_Error err = kvImageNoError;
 
@@ -413,12 +423,52 @@ static CGImageRef CreateImage8(avifImage * avif) {
     }
 
     if(hasAlpha) { // alpha
-        vImage_Buffer alphaBuffer = {
-            .data = avif->alphaPlane,
-            .width = avif->width,
-            .height = avif->height,
-            .rowBytes = avif->alphaRowBytes,
-        };
+        vImage_Buffer alphaBuffer = {0};
+        if(avif->alphaRange == AVIF_RANGE_LIMITED) {
+            float* floatAlphaBufferData = NULL;
+            floatAlphaBufferData = calloc(avif->width * avif->height, sizeof(float));
+            scaledAlphaBufferData = calloc(avif->width * avif->height, sizeof(uint8_t));
+            if(floatAlphaBufferData == NULL || scaledAlphaBufferData == NULL) {
+                err = kvImageMemoryAllocationError;
+                goto end_prepare_alpha;
+            }
+            vImage_Buffer origAlphaBuffer = {
+                .data = avif->alphaPlane,
+                .width = avif->width,
+                .height = avif->height,
+                .rowBytes = avif->alphaRowBytes,
+            };
+            vImage_Buffer floatAlphaBuffer = {
+                .data = floatAlphaBufferData,
+                .width = avif->width,
+                .height = avif->height,
+                .rowBytes = avif->width * sizeof(float),
+            };
+            alphaBuffer.width = avif->width;
+            alphaBuffer.height = avif->height;
+            alphaBuffer.data = scaledAlphaBufferData;
+            alphaBuffer.rowBytes = avif->width * sizeof(uint8_t);
+            err = vImageConvert_Planar8toPlanarF(&origAlphaBuffer, &floatAlphaBuffer, 255.0f, 0.0f, kvImageNoFlags);
+            if(err != kvImageNoError) {
+               NSLog(@"Failed to convert alpha planes from uint8 to float: %ld", err);
+                goto end_prepare_alpha;
+            }
+            err = vImageConvert_PlanarFtoPlanar8(&floatAlphaBuffer, &alphaBuffer, 235.0f, 16.0f, kvImageNoFlags);
+            if(err != kvImageNoError) {
+                NSLog(@"Failed to convert alpha planes from float to uint8: %ld", err);
+                goto end_prepare_alpha;
+            }
+        end_prepare_alpha:
+            free(floatAlphaBufferData);
+            if(err != kvImageNoError) {
+                goto end_alpha;
+            }
+        } else {
+            alphaBuffer.width = avif->width;
+            alphaBuffer.height = avif->height;
+            alphaBuffer.data = avif->alphaPlane;
+            alphaBuffer.rowBytes = avif->alphaRowBytes;
+        }
         if(monochrome) { // alpha_mono
             uint8_t* tmpBufferData = NULL;
             uint8_t* monoBufferData = NULL;
@@ -515,6 +565,7 @@ static CGImageRef CreateImage8(avifImage * avif) {
     free(argbBufferData);
     free(dummyCbData);
     free(dummyCrData);
+    free(scaledAlphaBufferData);
     return result;
 }
 
@@ -665,18 +716,32 @@ static CGImageRef CreateImage16U(avifImage * avif) {
             .height = avif->height,
             .rowBytes = avif->width * sizeof(uint16_t),
         };
+        float offset = 0.0f;
+        float rangeMax = 0.0f;
+        if(avif->depth == 10) {
+            if(avif->alphaRange == AVIF_RANGE_LIMITED) {
+                offset = 64.0f;
+                rangeMax = 940.0f;
+            } else {
+                offset = 0.0f;
+                rangeMax = 1023.0f;
+            }
+        } else if(avif->depth == 12) {
+            if(avif->alphaRange == AVIF_RANGE_LIMITED) {
+                offset = 256.0f;
+                rangeMax = 3760.0f;
+            } else {
+                offset = 0.0f;
+                rangeMax = 4095.0f;
+            }
+        }
+        float const scale = (float)(rangeMax - offset) / 65535.0f;
         err = vImageConvert_16UToF(&origAlpha, &floatAlphaBuffer, 0.0f, 1.0f, kvImageNoFlags);
         if(err != kvImageNoError) {
             NSLog(@"Failed to convert alpha planes from uint16 to float: %ld", err);
             goto end_prepare_alpha;
         }
-        float scale = 1.0f;
-        if(avif->depth == 10) {
-            scale = (float)((1 << 10) - 1) / 65535.0f;
-        } else if(avif->depth == 12) {
-            scale = (float)((1 << 12) - 1) / 65535.0f;
-        }
-        err = vImageConvert_FTo16U(&floatAlphaBuffer, &scaledAlphaBuffer, 0.0f, scale, kvImageNoFlags);
+        err = vImageConvert_FTo16U(&floatAlphaBuffer, &scaledAlphaBuffer, offset, scale, kvImageNoFlags);
         if(err != kvImageNoError) {
             NSLog(@"Failed to convert alpha planes from uint16 to float: %ld", err);
             goto end_prepare_alpha;