//
|
// YYImageCoder.m
|
// YYImage <https://github.com/ibireme/YYImage>
|
//
|
// Created by ibireme on 15/5/13.
|
// Copyright (c) 2015 ibireme.
|
//
|
// This source code is licensed under the MIT-style license found in the
|
// LICENSE file in the root directory of this source tree.
|
//
|
|
#import "YYImageCoder.h"
|
#import "YYImage.h"
|
#import <CoreFoundation/CoreFoundation.h>
|
#import <ImageIO/ImageIO.h>
|
#import <Accelerate/Accelerate.h>
|
#import <QuartzCore/QuartzCore.h>
|
#import <MobileCoreServices/MobileCoreServices.h>
|
#import <AssetsLibrary/AssetsLibrary.h>
|
#import <objc/runtime.h>
|
#import <pthread.h>
|
#import <zlib.h>
|
|
|
|
#ifndef YYIMAGE_WEBP_ENABLED
|
#if __has_include(<webp/decode.h>) && __has_include(<webp/encode.h>) && \
|
__has_include(<webp/demux.h>) && __has_include(<webp/mux.h>)
|
#define YYIMAGE_WEBP_ENABLED 1
|
#import <webp/decode.h>
|
#import <webp/encode.h>
|
#import <webp/demux.h>
|
#import <webp/mux.h>
|
#elif __has_include("webp/decode.h") && __has_include("webp/encode.h") && \
|
__has_include("webp/demux.h") && __has_include("webp/mux.h")
|
#define YYIMAGE_WEBP_ENABLED 1
|
#import "webp/decode.h"
|
#import "webp/encode.h"
|
#import "webp/demux.h"
|
#import "webp/mux.h"
|
#else
|
#define YYIMAGE_WEBP_ENABLED 0
|
#endif
|
#endif
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
#pragma mark - Utility (for little endian platform)
|
|
#define YY_FOUR_CC(c1,c2,c3,c4) ((uint32_t)(((c4) << 24) | ((c3) << 16) | ((c2) << 8) | (c1)))
|
#define YY_TWO_CC(c1,c2) ((uint16_t)(((c2) << 8) | (c1)))
|
|
static inline uint16_t yy_swap_endian_uint16(uint16_t value) {
|
return
|
(uint16_t) ((value & 0x00FF) << 8) |
|
(uint16_t) ((value & 0xFF00) >> 8) ;
|
}
|
|
static inline uint32_t yy_swap_endian_uint32(uint32_t value) {
|
return
|
(uint32_t)((value & 0x000000FFU) << 24) |
|
(uint32_t)((value & 0x0000FF00U) << 8) |
|
(uint32_t)((value & 0x00FF0000U) >> 8) |
|
(uint32_t)((value & 0xFF000000U) >> 24) ;
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
#pragma mark - APNG
|
|
/*
|
PNG spec: http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html
|
APNG spec: https://wiki.mozilla.org/APNG_Specification
|
|
===============================================================================
|
PNG format:
|
header (8): 89 50 4e 47 0d 0a 1a 0a
|
chunk, chunk, chunk, ...
|
|
===============================================================================
|
chunk format:
|
length (4): uint32_t big endian
|
fourcc (4): chunk type code
|
data (length): data
|
crc32 (4): uint32_t big endian crc32(fourcc + data)
|
|
===============================================================================
|
PNG chunk define:
|
|
IHDR (Image Header) required, must appear first, 13 bytes
|
width (4) pixel count, should not be zero
|
height (4) pixel count, should not be zero
|
bit depth (1) expected: 1, 2, 4, 8, 16
|
color type (1) 1<<0 (palette used), 1<<1 (color used), 1<<2 (alpha channel used)
|
compression method (1) 0 (deflate/inflate)
|
filter method (1) 0 (adaptive filtering with five basic filter types)
|
interlace method (1) 0 (no interlace) or 1 (Adam7 interlace)
|
|
IDAT (Image Data) required, must appear consecutively if there's multiple 'IDAT' chunk
|
|
IEND (End) required, must appear last, 0 bytes
|
|
===============================================================================
|
APNG chunk define:
|
|
acTL (Animation Control) required, must appear before 'IDAT', 8 bytes
|
num frames (4) number of frames
|
num plays (4) number of times to loop, 0 indicates infinite looping
|
|
fcTL (Frame Control) required, must appear before the 'IDAT' or 'fdAT' chunks of the frame to which it applies, 26 bytes
|
sequence number (4) sequence number of the animation chunk, starting from 0
|
width (4) width of the following frame
|
height (4) height of the following frame
|
x offset (4) x position at which to render the following frame
|
y offset (4) y position at which to render the following frame
|
delay num (2) frame delay fraction numerator
|
delay den (2) frame delay fraction denominator
|
dispose op (1) type of frame area disposal to be done after rendering this frame (0:none, 1:background 2:previous)
|
blend op (1) type of frame area rendering for this frame (0:source, 1:over)
|
|
fdAT (Frame Data) required
|
sequence number (4) sequence number of the animation chunk
|
frame data (x) frame data for this frame (same as 'IDAT')
|
|
===============================================================================
|
`dispose_op` specifies how the output buffer should be changed at the end of the delay
|
(before rendering the next frame).
|
|
* NONE: no disposal is done on this frame before rendering the next; the contents
|
of the output buffer are left as is.
|
* BACKGROUND: the frame's region of the output buffer is to be cleared to fully
|
transparent black before rendering the next frame.
|
* PREVIOUS: the frame's region of the output buffer is to be reverted to the previous
|
contents before rendering the next frame.
|
|
`blend_op` specifies whether the frame is to be alpha blended into the current output buffer
|
content, or whether it should completely replace its region in the output buffer.
|
|
* SOURCE: all color components of the frame, including alpha, overwrite the current contents
|
of the frame's output buffer region.
|
* OVER: the frame should be composited onto the output buffer based on its alpha,
|
using a simple OVER operation as described in the "Alpha Channel Processing" section
|
of the PNG specification
|
*/
|
|
typedef enum {
|
YY_PNG_ALPHA_TYPE_PALEETE = 1 << 0,
|
YY_PNG_ALPHA_TYPE_COLOR = 1 << 1,
|
YY_PNG_ALPHA_TYPE_ALPHA = 1 << 2,
|
} yy_png_alpha_type;
|
|
typedef enum {
|
YY_PNG_DISPOSE_OP_NONE = 0,
|
YY_PNG_DISPOSE_OP_BACKGROUND = 1,
|
YY_PNG_DISPOSE_OP_PREVIOUS = 2,
|
} yy_png_dispose_op;
|
|
typedef enum {
|
YY_PNG_BLEND_OP_SOURCE = 0,
|
YY_PNG_BLEND_OP_OVER = 1,
|
} yy_png_blend_op;
|
|
typedef struct {
|
uint32_t width; ///< pixel count, should not be zero
|
uint32_t height; ///< pixel count, should not be zero
|
uint8_t bit_depth; ///< expected: 1, 2, 4, 8, 16
|
uint8_t color_type; ///< see yy_png_alpha_type
|
uint8_t compression_method; ///< 0 (deflate/inflate)
|
uint8_t filter_method; ///< 0 (adaptive filtering with five basic filter types)
|
uint8_t interlace_method; ///< 0 (no interlace) or 1 (Adam7 interlace)
|
} yy_png_chunk_IHDR;
|
|
typedef struct {
|
uint32_t sequence_number; ///< sequence number of the animation chunk, starting from 0
|
uint32_t width; ///< width of the following frame
|
uint32_t height; ///< height of the following frame
|
uint32_t x_offset; ///< x position at which to render the following frame
|
uint32_t y_offset; ///< y position at which to render the following frame
|
uint16_t delay_num; ///< frame delay fraction numerator
|
uint16_t delay_den; ///< frame delay fraction denominator
|
uint8_t dispose_op; ///< see yy_png_dispose_op
|
uint8_t blend_op; ///< see yy_png_blend_op
|
} yy_png_chunk_fcTL;
|
|
typedef struct {
|
uint32_t offset; ///< chunk offset in PNG data
|
uint32_t fourcc; ///< chunk fourcc
|
uint32_t length; ///< chunk data length
|
uint32_t crc32; ///< chunk crc32
|
} yy_png_chunk_info;
|
|
typedef struct {
|
uint32_t chunk_index; ///< the first `fdAT`/`IDAT` chunk index
|
uint32_t chunk_num; ///< the `fdAT`/`IDAT` chunk count
|
uint32_t chunk_size; ///< the `fdAT`/`IDAT` chunk bytes
|
yy_png_chunk_fcTL frame_control;
|
} yy_png_frame_info;
|
|
typedef struct {
|
yy_png_chunk_IHDR header; ///< png header
|
yy_png_chunk_info *chunks; ///< chunks
|
uint32_t chunk_num; ///< count of chunks
|
|
yy_png_frame_info *apng_frames; ///< frame info, NULL if not apng
|
uint32_t apng_frame_num; ///< 0 if not apng
|
uint32_t apng_loop_num; ///< 0 indicates infinite looping
|
|
uint32_t *apng_shared_chunk_indexs; ///< shared chunk index
|
uint32_t apng_shared_chunk_num; ///< shared chunk count
|
uint32_t apng_shared_chunk_size; ///< shared chunk bytes
|
uint32_t apng_shared_insert_index; ///< shared chunk insert index
|
bool apng_first_frame_is_cover; ///< the first frame is same as png (cover)
|
} yy_png_info;
|
|
static void yy_png_chunk_IHDR_read(yy_png_chunk_IHDR *IHDR, const uint8_t *data) {
|
IHDR->width = yy_swap_endian_uint32(*((uint32_t *)(data)));
|
IHDR->height = yy_swap_endian_uint32(*((uint32_t *)(data + 4)));
|
IHDR->bit_depth = data[8];
|
IHDR->color_type = data[9];
|
IHDR->compression_method = data[10];
|
IHDR->filter_method = data[11];
|
IHDR->interlace_method = data[12];
|
}
|
|
static void yy_png_chunk_IHDR_write(yy_png_chunk_IHDR *IHDR, uint8_t *data) {
|
*((uint32_t *)(data)) = yy_swap_endian_uint32(IHDR->width);
|
*((uint32_t *)(data + 4)) = yy_swap_endian_uint32(IHDR->height);
|
data[8] = IHDR->bit_depth;
|
data[9] = IHDR->color_type;
|
data[10] = IHDR->compression_method;
|
data[11] = IHDR->filter_method;
|
data[12] = IHDR->interlace_method;
|
}
|
|
static void yy_png_chunk_fcTL_read(yy_png_chunk_fcTL *fcTL, const uint8_t *data) {
|
fcTL->sequence_number = yy_swap_endian_uint32(*((uint32_t *)(data)));
|
fcTL->width = yy_swap_endian_uint32(*((uint32_t *)(data + 4)));
|
fcTL->height = yy_swap_endian_uint32(*((uint32_t *)(data + 8)));
|
fcTL->x_offset = yy_swap_endian_uint32(*((uint32_t *)(data + 12)));
|
fcTL->y_offset = yy_swap_endian_uint32(*((uint32_t *)(data + 16)));
|
fcTL->delay_num = yy_swap_endian_uint16(*((uint16_t *)(data + 20)));
|
fcTL->delay_den = yy_swap_endian_uint16(*((uint16_t *)(data + 22)));
|
fcTL->dispose_op = data[24];
|
fcTL->blend_op = data[25];
|
}
|
|
static void yy_png_chunk_fcTL_write(yy_png_chunk_fcTL *fcTL, uint8_t *data) {
|
*((uint32_t *)(data)) = yy_swap_endian_uint32(fcTL->sequence_number);
|
*((uint32_t *)(data + 4)) = yy_swap_endian_uint32(fcTL->width);
|
*((uint32_t *)(data + 8)) = yy_swap_endian_uint32(fcTL->height);
|
*((uint32_t *)(data + 12)) = yy_swap_endian_uint32(fcTL->x_offset);
|
*((uint32_t *)(data + 16)) = yy_swap_endian_uint32(fcTL->y_offset);
|
*((uint16_t *)(data + 20)) = yy_swap_endian_uint16(fcTL->delay_num);
|
*((uint16_t *)(data + 22)) = yy_swap_endian_uint16(fcTL->delay_den);
|
data[24] = fcTL->dispose_op;
|
data[25] = fcTL->blend_op;
|
}
|
|
// convert double value to fraction
|
static void yy_png_delay_to_fraction(double duration, uint16_t *num, uint16_t *den) {
|
if (duration >= 0xFF) {
|
*num = 0xFF;
|
*den = 1;
|
} else if (duration <= 1.0 / (double)0xFF) {
|
*num = 1;
|
*den = 0xFF;
|
} else {
|
// Use continued fraction to calculate the num and den.
|
long MAX = 10;
|
double eps = (0.5 / (double)0xFF);
|
long p[MAX], q[MAX], a[MAX], i, numl = 0, denl = 0;
|
// The first two convergents are 0/1 and 1/0
|
p[0] = 0; q[0] = 1;
|
p[1] = 1; q[1] = 0;
|
// The rest of the convergents (and continued fraction)
|
for (i = 2; i < MAX; i++) {
|
a[i] = lrint(floor(duration));
|
p[i] = a[i] * p[i - 1] + p[i - 2];
|
q[i] = a[i] * q[i - 1] + q[i - 2];
|
if (p[i] <= 0xFF && q[i] <= 0xFF) { // uint16_t
|
numl = p[i];
|
denl = q[i];
|
} else break;
|
if (fabs(duration - a[i]) < eps) break;
|
duration = 1.0 / (duration - a[i]);
|
}
|
|
if (numl != 0 && denl != 0) {
|
*num = numl;
|
*den = denl;
|
} else {
|
*num = 1;
|
*den = 100;
|
}
|
}
|
}
|
|
// convert fraction to double value
|
static double yy_png_delay_to_seconds(uint16_t num, uint16_t den) {
|
if (den == 0) {
|
return num / 100.0;
|
} else {
|
return (double)num / (double)den;
|
}
|
}
|
|
static bool yy_png_validate_animation_chunk_order(yy_png_chunk_info *chunks, /* input */
|
uint32_t chunk_num, /* input */
|
uint32_t *first_idat_index, /* output */
|
bool *first_frame_is_cover /* output */) {
|
/*
|
PNG at least contains 3 chunks: IHDR, IDAT, IEND.
|
`IHDR` must appear first.
|
`IDAT` must appear consecutively.
|
`IEND` must appear end.
|
|
APNG must contains one `acTL` and at least one 'fcTL' and `fdAT`.
|
`fdAT` must appear consecutively.
|
`fcTL` must appear before `IDAT` or `fdAT`.
|
*/
|
if (chunk_num <= 2) return false;
|
if (chunks->fourcc != YY_FOUR_CC('I', 'H', 'D', 'R')) return false;
|
if ((chunks + chunk_num - 1)->fourcc != YY_FOUR_CC('I', 'E', 'N', 'D')) return false;
|
|
uint32_t prev_fourcc = 0;
|
uint32_t IHDR_num = 0;
|
uint32_t IDAT_num = 0;
|
uint32_t acTL_num = 0;
|
uint32_t fcTL_num = 0;
|
uint32_t first_IDAT = 0;
|
bool first_frame_cover = false;
|
for (uint32_t i = 0; i < chunk_num; i++) {
|
yy_png_chunk_info *chunk = chunks + i;
|
switch (chunk->fourcc) {
|
case YY_FOUR_CC('I', 'H', 'D', 'R'): { // png header
|
if (i != 0) return false;
|
if (IHDR_num > 0) return false;
|
IHDR_num++;
|
} break;
|
case YY_FOUR_CC('I', 'D', 'A', 'T'): { // png data
|
if (prev_fourcc != YY_FOUR_CC('I', 'D', 'A', 'T')) {
|
if (IDAT_num == 0)
|
first_IDAT = i;
|
else
|
return false;
|
}
|
IDAT_num++;
|
} break;
|
case YY_FOUR_CC('a', 'c', 'T', 'L'): { // apng control
|
if (acTL_num > 0) return false;
|
acTL_num++;
|
} break;
|
case YY_FOUR_CC('f', 'c', 'T', 'L'): { // apng frame control
|
if (i + 1 == chunk_num) return false;
|
if ((chunk + 1)->fourcc != YY_FOUR_CC('f', 'd', 'A', 'T') &&
|
(chunk + 1)->fourcc != YY_FOUR_CC('I', 'D', 'A', 'T')) {
|
return false;
|
}
|
if (fcTL_num == 0) {
|
if ((chunk + 1)->fourcc == YY_FOUR_CC('I', 'D', 'A', 'T')) {
|
first_frame_cover = true;
|
}
|
}
|
fcTL_num++;
|
} break;
|
case YY_FOUR_CC('f', 'd', 'A', 'T'): { // apng data
|
if (prev_fourcc != YY_FOUR_CC('f', 'd', 'A', 'T') && prev_fourcc != YY_FOUR_CC('f', 'c', 'T', 'L')) {
|
return false;
|
}
|
} break;
|
}
|
prev_fourcc = chunk->fourcc;
|
}
|
if (IHDR_num != 1) return false;
|
if (IDAT_num == 0) return false;
|
if (acTL_num != 1) return false;
|
if (fcTL_num < acTL_num) return false;
|
*first_idat_index = first_IDAT;
|
*first_frame_is_cover = first_frame_cover;
|
return true;
|
}
|
|
static void yy_png_info_release(yy_png_info *info) {
|
if (info) {
|
if (info->chunks) free(info->chunks);
|
if (info->apng_frames) free(info->apng_frames);
|
if (info->apng_shared_chunk_indexs) free(info->apng_shared_chunk_indexs);
|
free(info);
|
}
|
}
|
|
/**
|
Create a png info from a png file. See struct png_info for more information.
|
|
@param data png/apng file data.
|
@param length the data's length in bytes.
|
@return A png info object, you may call yy_png_info_release() to release it.
|
Returns NULL if an error occurs.
|
*/
|
static yy_png_info *yy_png_info_create(const uint8_t *data, uint32_t length) {
|
if (length < 32) return NULL;
|
if (*((uint32_t *)data) != YY_FOUR_CC(0x89, 0x50, 0x4E, 0x47)) return NULL;
|
if (*((uint32_t *)(data + 4)) != YY_FOUR_CC(0x0D, 0x0A, 0x1A, 0x0A)) return NULL;
|
|
uint32_t chunk_realloc_num = 16;
|
yy_png_chunk_info *chunks = malloc(sizeof(yy_png_chunk_info) * chunk_realloc_num);
|
if (!chunks) return NULL;
|
|
// parse png chunks
|
uint32_t offset = 8;
|
uint32_t chunk_num = 0;
|
uint32_t chunk_capacity = chunk_realloc_num;
|
uint32_t apng_loop_num = 0;
|
int32_t apng_sequence_index = -1;
|
int32_t apng_frame_index = 0;
|
int32_t apng_frame_number = -1;
|
bool apng_chunk_error = false;
|
do {
|
if (chunk_num >= chunk_capacity) {
|
yy_png_chunk_info *new_chunks = realloc(chunks, sizeof(yy_png_chunk_info) * (chunk_capacity + chunk_realloc_num));
|
if (!new_chunks) {
|
free(chunks);
|
return NULL;
|
}
|
chunks = new_chunks;
|
chunk_capacity += chunk_realloc_num;
|
}
|
yy_png_chunk_info *chunk = chunks + chunk_num;
|
const uint8_t *chunk_data = data + offset;
|
chunk->offset = offset;
|
chunk->length = yy_swap_endian_uint32(*((uint32_t *)chunk_data));
|
if ((uint64_t)chunk->offset + (uint64_t)chunk->length + 12 > length) {
|
free(chunks);
|
return NULL;
|
}
|
|
chunk->fourcc = *((uint32_t *)(chunk_data + 4));
|
if ((uint64_t)chunk->offset + 4 + chunk->length + 4 > (uint64_t)length) break;
|
chunk->crc32 = yy_swap_endian_uint32(*((uint32_t *)(chunk_data + 8 + chunk->length)));
|
chunk_num++;
|
offset += 12 + chunk->length;
|
|
switch (chunk->fourcc) {
|
case YY_FOUR_CC('a', 'c', 'T', 'L') : {
|
if (chunk->length == 8) {
|
apng_frame_number = yy_swap_endian_uint32(*((uint32_t *)(chunk_data + 8)));
|
apng_loop_num = yy_swap_endian_uint32(*((uint32_t *)(chunk_data + 12)));
|
} else {
|
apng_chunk_error = true;
|
}
|
} break;
|
case YY_FOUR_CC('f', 'c', 'T', 'L') :
|
case YY_FOUR_CC('f', 'd', 'A', 'T') : {
|
if (chunk->fourcc == YY_FOUR_CC('f', 'c', 'T', 'L')) {
|
if (chunk->length != 26) {
|
apng_chunk_error = true;
|
} else {
|
apng_frame_index++;
|
}
|
}
|
if (chunk->length > 4) {
|
uint32_t sequence = yy_swap_endian_uint32(*((uint32_t *)(chunk_data + 8)));
|
if (apng_sequence_index + 1 == sequence) {
|
apng_sequence_index++;
|
} else {
|
apng_chunk_error = true;
|
}
|
} else {
|
apng_chunk_error = true;
|
}
|
} break;
|
case YY_FOUR_CC('I', 'E', 'N', 'D') : {
|
offset = length; // end, break do-while loop
|
} break;
|
}
|
} while (offset + 12 <= length);
|
|
if (chunk_num < 3 ||
|
chunks->fourcc != YY_FOUR_CC('I', 'H', 'D', 'R') ||
|
chunks->length != 13) {
|
free(chunks);
|
return NULL;
|
}
|
|
// png info
|
yy_png_info *info = calloc(1, sizeof(yy_png_info));
|
if (!info) {
|
free(chunks);
|
return NULL;
|
}
|
info->chunks = chunks;
|
info->chunk_num = chunk_num;
|
yy_png_chunk_IHDR_read(&info->header, data + chunks->offset + 8);
|
|
// apng info
|
if (!apng_chunk_error && apng_frame_number == apng_frame_index && apng_frame_number >= 1) {
|
bool first_frame_is_cover = false;
|
uint32_t first_IDAT_index = 0;
|
if (!yy_png_validate_animation_chunk_order(info->chunks, info->chunk_num, &first_IDAT_index, &first_frame_is_cover)) {
|
return info; // ignore apng chunk
|
}
|
|
info->apng_loop_num = apng_loop_num;
|
info->apng_frame_num = apng_frame_number;
|
info->apng_first_frame_is_cover = first_frame_is_cover;
|
info->apng_shared_insert_index = first_IDAT_index;
|
info->apng_frames = calloc(apng_frame_number, sizeof(yy_png_frame_info));
|
if (!info->apng_frames) {
|
yy_png_info_release(info);
|
return NULL;
|
}
|
info->apng_shared_chunk_indexs = calloc(info->chunk_num, sizeof(uint32_t));
|
if (!info->apng_shared_chunk_indexs) {
|
yy_png_info_release(info);
|
return NULL;
|
}
|
|
int32_t frame_index = -1;
|
uint32_t *shared_chunk_index = info->apng_shared_chunk_indexs;
|
for (int32_t i = 0; i < info->chunk_num; i++) {
|
yy_png_chunk_info *chunk = info->chunks + i;
|
switch (chunk->fourcc) {
|
case YY_FOUR_CC('I', 'D', 'A', 'T'): {
|
if (info->apng_shared_insert_index == 0) {
|
info->apng_shared_insert_index = i;
|
}
|
if (first_frame_is_cover) {
|
yy_png_frame_info *frame = info->apng_frames + frame_index;
|
frame->chunk_num++;
|
frame->chunk_size += chunk->length + 12;
|
}
|
} break;
|
case YY_FOUR_CC('a', 'c', 'T', 'L'): {
|
} break;
|
case YY_FOUR_CC('f', 'c', 'T', 'L'): {
|
frame_index++;
|
yy_png_frame_info *frame = info->apng_frames + frame_index;
|
frame->chunk_index = i + 1;
|
yy_png_chunk_fcTL_read(&frame->frame_control, data + chunk->offset + 8);
|
} break;
|
case YY_FOUR_CC('f', 'd', 'A', 'T'): {
|
yy_png_frame_info *frame = info->apng_frames + frame_index;
|
frame->chunk_num++;
|
frame->chunk_size += chunk->length + 12;
|
} break;
|
default: {
|
*shared_chunk_index = i;
|
shared_chunk_index++;
|
info->apng_shared_chunk_size += chunk->length + 12;
|
info->apng_shared_chunk_num++;
|
} break;
|
}
|
}
|
}
|
return info;
|
}
|
|
/**
|
Copy a png frame data from an apng file.
|
|
@param data apng file data
|
@param info png info
|
@param index frame index (zero-based)
|
@param size output, the size of the frame data
|
@return A frame data (single-frame png file), call free() to release the data.
|
Returns NULL if an error occurs.
|
*/
|
static uint8_t *yy_png_copy_frame_data_at_index(const uint8_t *data,
|
const yy_png_info *info,
|
const uint32_t index,
|
uint32_t *size) {
|
if (index >= info->apng_frame_num) return NULL;
|
|
yy_png_frame_info *frame_info = info->apng_frames + index;
|
uint32_t frame_remux_size = 8 /* PNG Header */ + info->apng_shared_chunk_size + frame_info->chunk_size;
|
if (!(info->apng_first_frame_is_cover && index == 0)) {
|
frame_remux_size -= frame_info->chunk_num * 4; // remove fdAT sequence number
|
}
|
uint8_t *frame_data = malloc(frame_remux_size);
|
if (!frame_data) return NULL;
|
*size = frame_remux_size;
|
|
uint32_t data_offset = 0;
|
bool inserted = false;
|
memcpy(frame_data, data, 8); // PNG File Header
|
data_offset += 8;
|
for (uint32_t i = 0; i < info->apng_shared_chunk_num; i++) {
|
uint32_t shared_chunk_index = info->apng_shared_chunk_indexs[i];
|
yy_png_chunk_info *shared_chunk_info = info->chunks + shared_chunk_index;
|
|
if (shared_chunk_index >= info->apng_shared_insert_index && !inserted) { // replace IDAT with fdAT
|
inserted = true;
|
for (uint32_t c = 0; c < frame_info->chunk_num; c++) {
|
yy_png_chunk_info *insert_chunk_info = info->chunks + frame_info->chunk_index + c;
|
if (insert_chunk_info->fourcc == YY_FOUR_CC('f', 'd', 'A', 'T')) {
|
*((uint32_t *)(frame_data + data_offset)) = yy_swap_endian_uint32(insert_chunk_info->length - 4);
|
*((uint32_t *)(frame_data + data_offset + 4)) = YY_FOUR_CC('I', 'D', 'A', 'T');
|
memcpy(frame_data + data_offset + 8, data + insert_chunk_info->offset + 12, insert_chunk_info->length - 4);
|
uint32_t crc = (uint32_t)crc32(0, frame_data + data_offset + 4, insert_chunk_info->length);
|
*((uint32_t *)(frame_data + data_offset + insert_chunk_info->length + 4)) = yy_swap_endian_uint32(crc);
|
data_offset += insert_chunk_info->length + 8;
|
} else { // IDAT
|
memcpy(frame_data + data_offset, data + insert_chunk_info->offset, insert_chunk_info->length + 12);
|
data_offset += insert_chunk_info->length + 12;
|
}
|
}
|
}
|
|
if (shared_chunk_info->fourcc == YY_FOUR_CC('I', 'H', 'D', 'R')) {
|
uint8_t tmp[25] = {0};
|
memcpy(tmp, data + shared_chunk_info->offset, 25);
|
yy_png_chunk_IHDR IHDR = info->header;
|
IHDR.width = frame_info->frame_control.width;
|
IHDR.height = frame_info->frame_control.height;
|
yy_png_chunk_IHDR_write(&IHDR, tmp + 8);
|
*((uint32_t *)(tmp + 21)) = yy_swap_endian_uint32((uint32_t)crc32(0, tmp + 4, 17));
|
memcpy(frame_data + data_offset, tmp, 25);
|
data_offset += 25;
|
} else {
|
memcpy(frame_data + data_offset, data + shared_chunk_info->offset, shared_chunk_info->length + 12);
|
data_offset += shared_chunk_info->length + 12;
|
}
|
}
|
return frame_data;
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
#pragma mark - Helper
|
|
/// Returns byte-aligned size.
|
static inline size_t YYImageByteAlign(size_t size, size_t alignment) {
|
return ((size + (alignment - 1)) / alignment) * alignment;
|
}
|
|
/// Convert degree to radians
|
static inline CGFloat YYImageDegreesToRadians(CGFloat degrees) {
|
return degrees * M_PI / 180;
|
}
|
|
CGColorSpaceRef YYCGColorSpaceGetDeviceRGB() {
|
static CGColorSpaceRef space;
|
static dispatch_once_t onceToken;
|
dispatch_once(&onceToken, ^{
|
space = CGColorSpaceCreateDeviceRGB();
|
});
|
return space;
|
}
|
|
CGColorSpaceRef YYCGColorSpaceGetDeviceGray() {
|
static CGColorSpaceRef space;
|
static dispatch_once_t onceToken;
|
dispatch_once(&onceToken, ^{
|
space = CGColorSpaceCreateDeviceGray();
|
});
|
return space;
|
}
|
|
BOOL YYCGColorSpaceIsDeviceRGB(CGColorSpaceRef space) {
|
return space && CFEqual(space, YYCGColorSpaceGetDeviceRGB());
|
}
|
|
BOOL YYCGColorSpaceIsDeviceGray(CGColorSpaceRef space) {
|
return space && CFEqual(space, YYCGColorSpaceGetDeviceGray());
|
}
|
|
/**
|
A callback used in CGDataProviderCreateWithData() to release data.
|
|
Example:
|
|
void *data = malloc(size);
|
CGDataProviderRef provider = CGDataProviderCreateWithData(data, data, size, YYCGDataProviderReleaseDataCallback);
|
*/
|
static void YYCGDataProviderReleaseDataCallback(void *info, const void *data, size_t size) {
|
if (info) free(info);
|
}
|
|
/**
|
Decode an image to bitmap buffer with the specified format.
|
|
@param srcImage Source image.
|
@param dest Destination buffer. It should be zero before call this method.
|
If decode succeed, you should release the dest->data using free().
|
@param destFormat Destination bitmap format.
|
|
@return Whether succeed.
|
|
@warning This method support iOS7.0 and later. If call it on iOS6, it just returns NO.
|
CG_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
|
*/
|
static BOOL YYCGImageDecodeToBitmapBufferWithAnyFormat(CGImageRef srcImage, vImage_Buffer *dest, vImage_CGImageFormat *destFormat) {
|
if (!srcImage || (((long)vImageConvert_AnyToAny) + 1 == 1) || !destFormat || !dest) return NO;
|
size_t width = CGImageGetWidth(srcImage);
|
size_t height = CGImageGetHeight(srcImage);
|
if (width == 0 || height == 0) return NO;
|
dest->data = NULL;
|
|
vImage_Error error = kvImageNoError;
|
CFDataRef srcData = NULL;
|
vImageConverterRef convertor = NULL;
|
vImage_CGImageFormat srcFormat = {0};
|
srcFormat.bitsPerComponent = (uint32_t)CGImageGetBitsPerComponent(srcImage);
|
srcFormat.bitsPerPixel = (uint32_t)CGImageGetBitsPerPixel(srcImage);
|
srcFormat.colorSpace = CGImageGetColorSpace(srcImage);
|
srcFormat.bitmapInfo = CGImageGetBitmapInfo(srcImage) | CGImageGetAlphaInfo(srcImage);
|
|
convertor = vImageConverter_CreateWithCGImageFormat(&srcFormat, destFormat, NULL, kvImageNoFlags, NULL);
|
if (!convertor) goto fail;
|
|
CGDataProviderRef srcProvider = CGImageGetDataProvider(srcImage);
|
srcData = srcProvider ? CGDataProviderCopyData(srcProvider) : NULL; // decode
|
size_t srcLength = srcData ? CFDataGetLength(srcData) : 0;
|
const void *srcBytes = srcData ? CFDataGetBytePtr(srcData) : NULL;
|
if (srcLength == 0 || !srcBytes) goto fail;
|
|
vImage_Buffer src = {0};
|
src.data = (void *)srcBytes;
|
src.width = width;
|
src.height = height;
|
src.rowBytes = CGImageGetBytesPerRow(srcImage);
|
|
error = vImageBuffer_Init(dest, height, width, 32, kvImageNoFlags);
|
if (error != kvImageNoError) goto fail;
|
|
error = vImageConvert_AnyToAny(convertor, &src, dest, NULL, kvImageNoFlags); // convert
|
if (error != kvImageNoError) goto fail;
|
|
CFRelease(convertor);
|
CFRelease(srcData);
|
return YES;
|
|
fail:
|
if (convertor) CFRelease(convertor);
|
if (srcData) CFRelease(srcData);
|
if (dest->data) free(dest->data);
|
dest->data = NULL;
|
return NO;
|
}
|
|
/**
|
Decode an image to bitmap buffer with the 32bit format (such as ARGB8888).
|
|
@param srcImage Source image.
|
@param dest Destination buffer. It should be zero before call this method.
|
If decode succeed, you should release the dest->data using free().
|
@param bitmapInfo Destination bitmap format.
|
|
@return Whether succeed.
|
*/
|
static BOOL YYCGImageDecodeToBitmapBufferWith32BitFormat(CGImageRef srcImage, vImage_Buffer *dest, CGBitmapInfo bitmapInfo) {
|
if (!srcImage || !dest) return NO;
|
size_t width = CGImageGetWidth(srcImage);
|
size_t height = CGImageGetHeight(srcImage);
|
if (width == 0 || height == 0) return NO;
|
|
BOOL hasAlpha = NO;
|
BOOL alphaFirst = NO;
|
BOOL alphaPremultiplied = NO;
|
BOOL byteOrderNormal = NO;
|
|
switch (bitmapInfo & kCGBitmapAlphaInfoMask) {
|
case kCGImageAlphaPremultipliedLast: {
|
hasAlpha = YES;
|
alphaPremultiplied = YES;
|
} break;
|
case kCGImageAlphaPremultipliedFirst: {
|
hasAlpha = YES;
|
alphaPremultiplied = YES;
|
alphaFirst = YES;
|
} break;
|
case kCGImageAlphaLast: {
|
hasAlpha = YES;
|
} break;
|
case kCGImageAlphaFirst: {
|
hasAlpha = YES;
|
alphaFirst = YES;
|
} break;
|
case kCGImageAlphaNoneSkipLast: {
|
} break;
|
case kCGImageAlphaNoneSkipFirst: {
|
alphaFirst = YES;
|
} break;
|
default: {
|
return NO;
|
} break;
|
}
|
|
switch (bitmapInfo & kCGBitmapByteOrderMask) {
|
case kCGBitmapByteOrderDefault: {
|
byteOrderNormal = YES;
|
} break;
|
case kCGBitmapByteOrder32Little: {
|
} break;
|
case kCGBitmapByteOrder32Big: {
|
byteOrderNormal = YES;
|
} break;
|
default: {
|
return NO;
|
} break;
|
}
|
|
/*
|
Try convert with vImageConvert_AnyToAny() (avaliable since iOS 7.0).
|
If fail, try decode with CGContextDrawImage().
|
CGBitmapContext use a premultiplied alpha format, unpremultiply may lose precision.
|
*/
|
vImage_CGImageFormat destFormat = {0};
|
destFormat.bitsPerComponent = 8;
|
destFormat.bitsPerPixel = 32;
|
destFormat.colorSpace = YYCGColorSpaceGetDeviceRGB();
|
destFormat.bitmapInfo = bitmapInfo;
|
dest->data = NULL;
|
if (YYCGImageDecodeToBitmapBufferWithAnyFormat(srcImage, dest, &destFormat)) return YES;
|
|
CGBitmapInfo contextBitmapInfo = bitmapInfo & kCGBitmapByteOrderMask;
|
if (!hasAlpha || alphaPremultiplied) {
|
contextBitmapInfo |= (bitmapInfo & kCGBitmapAlphaInfoMask);
|
} else {
|
contextBitmapInfo |= alphaFirst ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaPremultipliedLast;
|
}
|
CGContextRef context = CGBitmapContextCreate(NULL, width, height, 8, 0, YYCGColorSpaceGetDeviceRGB(), contextBitmapInfo);
|
if (!context) goto fail;
|
|
CGContextDrawImage(context, CGRectMake(0, 0, width, height), srcImage); // decode and convert
|
size_t bytesPerRow = CGBitmapContextGetBytesPerRow(context);
|
size_t length = height * bytesPerRow;
|
void *data = CGBitmapContextGetData(context);
|
if (length == 0 || !data) goto fail;
|
|
dest->data = malloc(length);
|
dest->width = width;
|
dest->height = height;
|
dest->rowBytes = bytesPerRow;
|
if (!dest->data) goto fail;
|
|
if (hasAlpha && !alphaPremultiplied) {
|
vImage_Buffer tmpSrc = {0};
|
tmpSrc.data = data;
|
tmpSrc.width = width;
|
tmpSrc.height = height;
|
tmpSrc.rowBytes = bytesPerRow;
|
vImage_Error error;
|
if (alphaFirst && byteOrderNormal) {
|
error = vImageUnpremultiplyData_ARGB8888(&tmpSrc, dest, kvImageNoFlags);
|
} else {
|
error = vImageUnpremultiplyData_RGBA8888(&tmpSrc, dest, kvImageNoFlags);
|
}
|
if (error != kvImageNoError) goto fail;
|
} else {
|
memcpy(dest->data, data, length);
|
}
|
|
CFRelease(context);
|
return YES;
|
|
fail:
|
if (context) CFRelease(context);
|
if (dest->data) free(dest->data);
|
dest->data = NULL;
|
return NO;
|
return NO;
|
}
|
|
CGImageRef YYCGImageCreateDecodedCopy(CGImageRef imageRef, BOOL decodeForDisplay) {
|
if (!imageRef) return NULL;
|
size_t width = CGImageGetWidth(imageRef);
|
size_t height = CGImageGetHeight(imageRef);
|
if (width == 0 || height == 0) return NULL;
|
|
if (decodeForDisplay) { //decode with redraw (may lose some precision)
|
CGImageAlphaInfo alphaInfo = CGImageGetAlphaInfo(imageRef) & kCGBitmapAlphaInfoMask;
|
BOOL hasAlpha = NO;
|
if (alphaInfo == kCGImageAlphaPremultipliedLast ||
|
alphaInfo == kCGImageAlphaPremultipliedFirst ||
|
alphaInfo == kCGImageAlphaLast ||
|
alphaInfo == kCGImageAlphaFirst) {
|
hasAlpha = YES;
|
}
|
// BGRA8888 (premultiplied) or BGRX8888
|
// same as UIGraphicsBeginImageContext() and -[UIView drawRect:]
|
CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Host;
|
bitmapInfo |= hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst;
|
CGContextRef context = CGBitmapContextCreate(NULL, width, height, 8, 0, YYCGColorSpaceGetDeviceRGB(), bitmapInfo);
|
if (!context) return NULL;
|
CGContextDrawImage(context, CGRectMake(0, 0, width, height), imageRef); // decode
|
CGImageRef newImage = CGBitmapContextCreateImage(context);
|
CFRelease(context);
|
return newImage;
|
|
} else {
|
CGColorSpaceRef space = CGImageGetColorSpace(imageRef);
|
size_t bitsPerComponent = CGImageGetBitsPerComponent(imageRef);
|
size_t bitsPerPixel = CGImageGetBitsPerPixel(imageRef);
|
size_t bytesPerRow = CGImageGetBytesPerRow(imageRef);
|
CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);
|
if (bytesPerRow == 0 || width == 0 || height == 0) return NULL;
|
|
CGDataProviderRef dataProvider = CGImageGetDataProvider(imageRef);
|
if (!dataProvider) return NULL;
|
CFDataRef data = CGDataProviderCopyData(dataProvider); // decode
|
if (!data) return NULL;
|
|
CGDataProviderRef newProvider = CGDataProviderCreateWithCFData(data);
|
CFRelease(data);
|
if (!newProvider) return NULL;
|
|
CGImageRef newImage = CGImageCreate(width, height, bitsPerComponent, bitsPerPixel, bytesPerRow, space, bitmapInfo, newProvider, NULL, false, kCGRenderingIntentDefault);
|
CFRelease(newProvider);
|
return newImage;
|
}
|
}
|
|
CGImageRef YYCGImageCreateAffineTransformCopy(CGImageRef imageRef, CGAffineTransform transform, CGSize destSize, CGBitmapInfo destBitmapInfo) {
|
if (!imageRef) return NULL;
|
size_t srcWidth = CGImageGetWidth(imageRef);
|
size_t srcHeight = CGImageGetHeight(imageRef);
|
size_t destWidth = round(destSize.width);
|
size_t destHeight = round(destSize.height);
|
if (srcWidth == 0 || srcHeight == 0 || destWidth == 0 || destHeight == 0) return NULL;
|
|
CGDataProviderRef tmpProvider = NULL, destProvider = NULL;
|
CGImageRef tmpImage = NULL, destImage = NULL;
|
vImage_Buffer src = {0}, tmp = {0}, dest = {0};
|
if(!YYCGImageDecodeToBitmapBufferWith32BitFormat(imageRef, &src, kCGImageAlphaFirst | kCGBitmapByteOrderDefault)) return NULL;
|
|
size_t destBytesPerRow = YYImageByteAlign(destWidth * 4, 32);
|
tmp.data = malloc(destHeight * destBytesPerRow);
|
if (!tmp.data) goto fail;
|
|
tmp.width = destWidth;
|
tmp.height = destHeight;
|
tmp.rowBytes = destBytesPerRow;
|
vImage_CGAffineTransform vTransform = *((vImage_CGAffineTransform *)&transform);
|
uint8_t backColor[4] = {0};
|
vImage_Error error = vImageAffineWarpCG_ARGB8888(&src, &tmp, NULL, &vTransform, backColor, kvImageBackgroundColorFill);
|
if (error != kvImageNoError) goto fail;
|
free(src.data);
|
src.data = NULL;
|
|
tmpProvider = CGDataProviderCreateWithData(tmp.data, tmp.data, destHeight * destBytesPerRow, YYCGDataProviderReleaseDataCallback);
|
if (!tmpProvider) goto fail;
|
tmp.data = NULL; // hold by provider
|
tmpImage = CGImageCreate(destWidth, destHeight, 8, 32, destBytesPerRow, YYCGColorSpaceGetDeviceRGB(), kCGImageAlphaFirst | kCGBitmapByteOrderDefault, tmpProvider, NULL, false, kCGRenderingIntentDefault);
|
if (!tmpImage) goto fail;
|
CFRelease(tmpProvider);
|
tmpProvider = NULL;
|
|
if ((destBitmapInfo & kCGBitmapAlphaInfoMask) == kCGImageAlphaFirst &&
|
(destBitmapInfo & kCGBitmapByteOrderMask) != kCGBitmapByteOrder32Little) {
|
return tmpImage;
|
}
|
|
if (!YYCGImageDecodeToBitmapBufferWith32BitFormat(tmpImage, &dest, destBitmapInfo)) goto fail;
|
CFRelease(tmpImage);
|
tmpImage = NULL;
|
|
destProvider = CGDataProviderCreateWithData(dest.data, dest.data, destHeight * destBytesPerRow, YYCGDataProviderReleaseDataCallback);
|
if (!destProvider) goto fail;
|
dest.data = NULL; // hold by provider
|
destImage = CGImageCreate(destWidth, destHeight, 8, 32, destBytesPerRow, YYCGColorSpaceGetDeviceRGB(), destBitmapInfo, destProvider, NULL, false, kCGRenderingIntentDefault);
|
if (!destImage) goto fail;
|
CFRelease(destProvider);
|
destProvider = NULL;
|
|
return destImage;
|
|
fail:
|
if (src.data) free(src.data);
|
if (tmp.data) free(tmp.data);
|
if (dest.data) free(dest.data);
|
if (tmpProvider) CFRelease(tmpProvider);
|
if (tmpImage) CFRelease(tmpImage);
|
if (destProvider) CFRelease(destProvider);
|
return NULL;
|
}
|
|
UIImageOrientation YYUIImageOrientationFromEXIFValue(NSInteger value) {
|
switch (value) {
|
case kCGImagePropertyOrientationUp: return UIImageOrientationUp;
|
case kCGImagePropertyOrientationDown: return UIImageOrientationDown;
|
case kCGImagePropertyOrientationLeft: return UIImageOrientationLeft;
|
case kCGImagePropertyOrientationRight: return UIImageOrientationRight;
|
case kCGImagePropertyOrientationUpMirrored: return UIImageOrientationUpMirrored;
|
case kCGImagePropertyOrientationDownMirrored: return UIImageOrientationDownMirrored;
|
case kCGImagePropertyOrientationLeftMirrored: return UIImageOrientationLeftMirrored;
|
case kCGImagePropertyOrientationRightMirrored: return UIImageOrientationRightMirrored;
|
default: return UIImageOrientationUp;
|
}
|
}
|
|
NSInteger YYUIImageOrientationToEXIFValue(UIImageOrientation orientation) {
|
switch (orientation) {
|
case UIImageOrientationUp: return kCGImagePropertyOrientationUp;
|
case UIImageOrientationDown: return kCGImagePropertyOrientationDown;
|
case UIImageOrientationLeft: return kCGImagePropertyOrientationLeft;
|
case UIImageOrientationRight: return kCGImagePropertyOrientationRight;
|
case UIImageOrientationUpMirrored: return kCGImagePropertyOrientationUpMirrored;
|
case UIImageOrientationDownMirrored: return kCGImagePropertyOrientationDownMirrored;
|
case UIImageOrientationLeftMirrored: return kCGImagePropertyOrientationLeftMirrored;
|
case UIImageOrientationRightMirrored: return kCGImagePropertyOrientationRightMirrored;
|
default: return kCGImagePropertyOrientationUp;
|
}
|
}
|
|
CGImageRef YYCGImageCreateCopyWithOrientation(CGImageRef imageRef, UIImageOrientation orientation, CGBitmapInfo destBitmapInfo) {
|
if (!imageRef) return NULL;
|
if (orientation == UIImageOrientationUp) return (CGImageRef)CFRetain(imageRef);
|
|
size_t width = CGImageGetWidth(imageRef);
|
size_t height = CGImageGetHeight(imageRef);
|
|
CGAffineTransform transform = CGAffineTransformIdentity;
|
BOOL swapWidthAndHeight = NO;
|
switch (orientation) {
|
case UIImageOrientationDown: {
|
transform = CGAffineTransformMakeRotation(YYImageDegreesToRadians(180));
|
transform = CGAffineTransformTranslate(transform, -(CGFloat)width, -(CGFloat)height);
|
} break;
|
case UIImageOrientationLeft: {
|
transform = CGAffineTransformMakeRotation(YYImageDegreesToRadians(90));
|
transform = CGAffineTransformTranslate(transform, -(CGFloat)0, -(CGFloat)height);
|
swapWidthAndHeight = YES;
|
} break;
|
case UIImageOrientationRight: {
|
transform = CGAffineTransformMakeRotation(YYImageDegreesToRadians(-90));
|
transform = CGAffineTransformTranslate(transform, -(CGFloat)width, (CGFloat)0);
|
swapWidthAndHeight = YES;
|
} break;
|
case UIImageOrientationUpMirrored: {
|
transform = CGAffineTransformTranslate(transform, (CGFloat)width, 0);
|
transform = CGAffineTransformScale(transform, -1, 1);
|
} break;
|
case UIImageOrientationDownMirrored: {
|
transform = CGAffineTransformTranslate(transform, 0, (CGFloat)height);
|
transform = CGAffineTransformScale(transform, 1, -1);
|
} break;
|
case UIImageOrientationLeftMirrored: {
|
transform = CGAffineTransformMakeRotation(YYImageDegreesToRadians(-90));
|
transform = CGAffineTransformScale(transform, 1, -1);
|
transform = CGAffineTransformTranslate(transform, -(CGFloat)width, -(CGFloat)height);
|
swapWidthAndHeight = YES;
|
} break;
|
case UIImageOrientationRightMirrored: {
|
transform = CGAffineTransformMakeRotation(YYImageDegreesToRadians(90));
|
transform = CGAffineTransformScale(transform, 1, -1);
|
swapWidthAndHeight = YES;
|
} break;
|
default: break;
|
}
|
if (CGAffineTransformIsIdentity(transform)) return (CGImageRef)CFRetain(imageRef);
|
|
CGSize destSize = {width, height};
|
if (swapWidthAndHeight) {
|
destSize.width = height;
|
destSize.height = width;
|
}
|
|
return YYCGImageCreateAffineTransformCopy(imageRef, transform, destSize, destBitmapInfo);
|
}
|
|
YYImageType YYImageDetectType(CFDataRef data) {
|
if (!data) return YYImageTypeUnknown;
|
uint64_t length = CFDataGetLength(data);
|
if (length < 16) return YYImageTypeUnknown;
|
|
const char *bytes = (char *)CFDataGetBytePtr(data);
|
|
uint32_t magic4 = *((uint32_t *)bytes);
|
switch (magic4) {
|
case YY_FOUR_CC(0x4D, 0x4D, 0x00, 0x2A): { // big endian TIFF
|
return YYImageTypeTIFF;
|
} break;
|
|
case YY_FOUR_CC(0x49, 0x49, 0x2A, 0x00): { // little endian TIFF
|
return YYImageTypeTIFF;
|
} break;
|
|
case YY_FOUR_CC(0x00, 0x00, 0x01, 0x00): { // ICO
|
return YYImageTypeICO;
|
} break;
|
|
case YY_FOUR_CC(0x00, 0x00, 0x02, 0x00): { // CUR
|
return YYImageTypeICO;
|
} break;
|
|
case YY_FOUR_CC('i', 'c', 'n', 's'): { // ICNS
|
return YYImageTypeICNS;
|
} break;
|
|
case YY_FOUR_CC('G', 'I', 'F', '8'): { // GIF
|
return YYImageTypeGIF;
|
} break;
|
|
case YY_FOUR_CC(0x89, 'P', 'N', 'G'): { // PNG
|
uint32_t tmp = *((uint32_t *)(bytes + 4));
|
if (tmp == YY_FOUR_CC('\r', '\n', 0x1A, '\n')) {
|
return YYImageTypePNG;
|
}
|
} break;
|
|
case YY_FOUR_CC('R', 'I', 'F', 'F'): { // WebP
|
uint32_t tmp = *((uint32_t *)(bytes + 8));
|
if (tmp == YY_FOUR_CC('W', 'E', 'B', 'P')) {
|
return YYImageTypeWebP;
|
}
|
} break;
|
/*
|
case YY_FOUR_CC('B', 'P', 'G', 0xFB): { // BPG
|
return YYImageTypeBPG;
|
} break;
|
*/
|
}
|
|
uint16_t magic2 = *((uint16_t *)bytes);
|
switch (magic2) {
|
case YY_TWO_CC('B', 'A'):
|
case YY_TWO_CC('B', 'M'):
|
case YY_TWO_CC('I', 'C'):
|
case YY_TWO_CC('P', 'I'):
|
case YY_TWO_CC('C', 'I'):
|
case YY_TWO_CC('C', 'P'): { // BMP
|
return YYImageTypeBMP;
|
}
|
case YY_TWO_CC(0xFF, 0x4F): { // JPEG2000
|
return YYImageTypeJPEG2000;
|
}
|
}
|
|
// JPG FF D8 FF
|
if (memcmp(bytes,"\377\330\377",3) == 0) return YYImageTypeJPEG;
|
|
// JP2
|
if (memcmp(bytes + 4, "\152\120\040\040\015", 5) == 0) return YYImageTypeJPEG2000;
|
|
return YYImageTypeUnknown;
|
}
|
|
CFStringRef YYImageTypeToUTType(YYImageType type) {
|
switch (type) {
|
case YYImageTypeJPEG: return kUTTypeJPEG;
|
case YYImageTypeJPEG2000: return kUTTypeJPEG2000;
|
case YYImageTypeTIFF: return kUTTypeTIFF;
|
case YYImageTypeBMP: return kUTTypeBMP;
|
case YYImageTypeICO: return kUTTypeICO;
|
case YYImageTypeICNS: return kUTTypeAppleICNS;
|
case YYImageTypeGIF: return kUTTypeGIF;
|
case YYImageTypePNG: return kUTTypePNG;
|
default: return NULL;
|
}
|
}
|
|
YYImageType YYImageTypeFromUTType(CFStringRef uti) {
|
static NSDictionary *dic;
|
static dispatch_once_t onceToken;
|
dispatch_once(&onceToken, ^{
|
dic = @{(id)kUTTypeJPEG : @(YYImageTypeJPEG),
|
(id)kUTTypeJPEG2000 : @(YYImageTypeJPEG2000),
|
(id)kUTTypeTIFF : @(YYImageTypeTIFF),
|
(id)kUTTypeBMP : @(YYImageTypeBMP),
|
(id)kUTTypeICO : @(YYImageTypeICO),
|
(id)kUTTypeAppleICNS : @(YYImageTypeICNS),
|
(id)kUTTypeGIF : @(YYImageTypeGIF),
|
(id)kUTTypePNG : @(YYImageTypePNG)};
|
});
|
if (!uti) return YYImageTypeUnknown;
|
NSNumber *num = dic[(__bridge __strong id)(uti)];
|
return num.unsignedIntegerValue;
|
}
|
|
NSString *YYImageTypeGetExtension(YYImageType type) {
|
switch (type) {
|
case YYImageTypeJPEG: return @"jpg";
|
case YYImageTypeJPEG2000: return @"jp2";
|
case YYImageTypeTIFF: return @"tiff";
|
case YYImageTypeBMP: return @"bmp";
|
case YYImageTypeICO: return @"ico";
|
case YYImageTypeICNS: return @"icns";
|
case YYImageTypeGIF: return @"gif";
|
case YYImageTypePNG: return @"png";
|
case YYImageTypeWebP: return @"webp";
|
default: return nil;
|
}
|
}
|
|
CFDataRef YYCGImageCreateEncodedData(CGImageRef imageRef, YYImageType type, CGFloat quality) {
|
if (!imageRef) return nil;
|
quality = quality < 0 ? 0 : quality > 1 ? 1 : quality;
|
|
if (type == YYImageTypeWebP) {
|
#if YYIMAGE_WEBP_ENABLED
|
if (quality == 1) {
|
return YYCGImageCreateEncodedWebPData(imageRef, YES, quality, 4, YYImagePresetDefault);
|
} else {
|
return YYCGImageCreateEncodedWebPData(imageRef, NO, quality, 4, YYImagePresetDefault);
|
}
|
#else
|
return NULL;
|
#endif
|
}
|
|
CFStringRef uti = YYImageTypeToUTType(type);
|
if (!uti) return nil;
|
|
CFMutableDataRef data = CFDataCreateMutable(CFAllocatorGetDefault(), 0);
|
if (!data) return NULL;
|
CGImageDestinationRef dest = CGImageDestinationCreateWithData(data, uti, 1, NULL);
|
if (!dest) {
|
CFRelease(data);
|
return NULL;
|
}
|
NSDictionary *options = @{(id)kCGImageDestinationLossyCompressionQuality : @(quality) };
|
CGImageDestinationAddImage(dest, imageRef, (CFDictionaryRef)options);
|
if (!CGImageDestinationFinalize(dest)) {
|
CFRelease(data);
|
CFRelease(dest);
|
return nil;
|
}
|
CFRelease(dest);
|
|
if (CFDataGetLength(data) == 0) {
|
CFRelease(data);
|
return NULL;
|
}
|
return data;
|
}
|
|
#if YYIMAGE_WEBP_ENABLED
|
|
BOOL YYImageWebPAvailable() {
|
return YES;
|
}
|
|
CFDataRef YYCGImageCreateEncodedWebPData(CGImageRef imageRef, BOOL lossless, CGFloat quality, int compressLevel, YYImagePreset preset) {
|
if (!imageRef) return nil;
|
size_t width = CGImageGetWidth(imageRef);
|
size_t height = CGImageGetHeight(imageRef);
|
if (width == 0 || width > WEBP_MAX_DIMENSION) return nil;
|
if (height == 0 || height > WEBP_MAX_DIMENSION) return nil;
|
|
vImage_Buffer buffer = {0};
|
if(!YYCGImageDecodeToBitmapBufferWith32BitFormat(imageRef, &buffer, kCGImageAlphaLast | kCGBitmapByteOrderDefault)) return nil;
|
|
WebPConfig config = {0};
|
WebPPicture picture = {0};
|
WebPMemoryWriter writer = {0};
|
CFDataRef webpData = NULL;
|
BOOL pictureNeedFree = NO;
|
|
quality = quality < 0 ? 0 : quality > 1 ? 1 : quality;
|
preset = preset > YYImagePresetText ? YYImagePresetDefault : preset;
|
compressLevel = compressLevel < 0 ? 0 : compressLevel > 6 ? 6 : compressLevel;
|
if (!WebPConfigPreset(&config, (WebPPreset)preset, quality)) goto fail;
|
|
config.quality = round(quality * 100.0);
|
config.lossless = lossless;
|
config.method = compressLevel;
|
switch ((WebPPreset)preset) {
|
case WEBP_PRESET_DEFAULT: {
|
config.image_hint = WEBP_HINT_DEFAULT;
|
} break;
|
case WEBP_PRESET_PICTURE: {
|
config.image_hint = WEBP_HINT_PICTURE;
|
} break;
|
case WEBP_PRESET_PHOTO: {
|
config.image_hint = WEBP_HINT_PHOTO;
|
} break;
|
case WEBP_PRESET_DRAWING:
|
case WEBP_PRESET_ICON:
|
case WEBP_PRESET_TEXT: {
|
config.image_hint = WEBP_HINT_GRAPH;
|
} break;
|
}
|
if (!WebPValidateConfig(&config)) goto fail;
|
|
if (!WebPPictureInit(&picture)) goto fail;
|
pictureNeedFree = YES;
|
picture.width = (int)buffer.width;
|
picture.height = (int)buffer.height;
|
picture.use_argb = lossless;
|
if(!WebPPictureImportRGBA(&picture, buffer.data, (int)buffer.rowBytes)) goto fail;
|
|
WebPMemoryWriterInit(&writer);
|
picture.writer = WebPMemoryWrite;
|
picture.custom_ptr = &writer;
|
if(!WebPEncode(&config, &picture)) goto fail;
|
|
webpData = CFDataCreate(CFAllocatorGetDefault(), writer.mem, writer.size);
|
free(writer.mem);
|
WebPPictureFree(&picture);
|
free(buffer.data);
|
return webpData;
|
|
fail:
|
if (buffer.data) free(buffer.data);
|
if (pictureNeedFree) WebPPictureFree(&picture);
|
return nil;
|
}
|
|
NSUInteger YYImageGetWebPFrameCount(CFDataRef webpData) {
|
if (!webpData || CFDataGetLength(webpData) == 0) return 0;
|
|
WebPData data = {CFDataGetBytePtr(webpData), CFDataGetLength(webpData)};
|
WebPDemuxer *demuxer = WebPDemux(&data);
|
if (!demuxer) return 0;
|
NSUInteger webpFrameCount = WebPDemuxGetI(demuxer, WEBP_FF_FRAME_COUNT);
|
WebPDemuxDelete(demuxer);
|
return webpFrameCount;
|
}
|
|
CGImageRef YYCGImageCreateWithWebPData(CFDataRef webpData,
|
BOOL decodeForDisplay,
|
BOOL useThreads,
|
BOOL bypassFiltering,
|
BOOL noFancyUpsampling) {
|
/*
|
Call WebPDecode() on a multi-frame webp data will get an error (VP8_STATUS_UNSUPPORTED_FEATURE).
|
Use WebPDemuxer to unpack it first.
|
*/
|
WebPData data = {0};
|
WebPDemuxer *demuxer = NULL;
|
|
int frameCount = 0, canvasWidth = 0, canvasHeight = 0;
|
WebPIterator iter = {0};
|
BOOL iterInited = NO;
|
const uint8_t *payload = NULL;
|
size_t payloadSize = 0;
|
WebPDecoderConfig config = {0};
|
|
BOOL hasAlpha = NO;
|
size_t bitsPerComponent = 0, bitsPerPixel = 0, bytesPerRow = 0, destLength = 0;
|
CGBitmapInfo bitmapInfo = 0;
|
WEBP_CSP_MODE colorspace = 0;
|
void *destBytes = NULL;
|
CGDataProviderRef provider = NULL;
|
CGImageRef imageRef = NULL;
|
|
if (!webpData || CFDataGetLength(webpData) == 0) return NULL;
|
data.bytes = CFDataGetBytePtr(webpData);
|
data.size = CFDataGetLength(webpData);
|
demuxer = WebPDemux(&data);
|
if (!demuxer) goto fail;
|
|
frameCount = WebPDemuxGetI(demuxer, WEBP_FF_FRAME_COUNT);
|
if (frameCount == 0) {
|
goto fail;
|
|
} else if (frameCount == 1) { // single-frame
|
payload = data.bytes;
|
payloadSize = data.size;
|
if (!WebPInitDecoderConfig(&config)) goto fail;
|
if (WebPGetFeatures(payload , payloadSize, &config.input) != VP8_STATUS_OK) goto fail;
|
canvasWidth = config.input.width;
|
canvasHeight = config.input.height;
|
|
} else { // multi-frame
|
canvasWidth = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_WIDTH);
|
canvasHeight = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_HEIGHT);
|
if (canvasWidth < 1 || canvasHeight < 1) goto fail;
|
|
if (!WebPDemuxGetFrame(demuxer, 1, &iter)) goto fail;
|
iterInited = YES;
|
|
if (iter.width > canvasWidth || iter.height > canvasHeight) goto fail;
|
payload = iter.fragment.bytes;
|
payloadSize = iter.fragment.size;
|
|
if (!WebPInitDecoderConfig(&config)) goto fail;
|
if (WebPGetFeatures(payload , payloadSize, &config.input) != VP8_STATUS_OK) goto fail;
|
}
|
if (payload == NULL || payloadSize == 0) goto fail;
|
|
hasAlpha = config.input.has_alpha;
|
bitsPerComponent = 8;
|
bitsPerPixel = 32;
|
bytesPerRow = YYImageByteAlign(bitsPerPixel / 8 * canvasWidth, 32);
|
destLength = bytesPerRow * canvasHeight;
|
if (decodeForDisplay) {
|
bitmapInfo = kCGBitmapByteOrder32Host;
|
bitmapInfo |= hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst;
|
colorspace = MODE_bgrA; // small endian
|
} else {
|
bitmapInfo = kCGBitmapByteOrderDefault;
|
bitmapInfo |= hasAlpha ? kCGImageAlphaLast : kCGImageAlphaNoneSkipLast;
|
colorspace = MODE_RGBA;
|
}
|
destBytes = calloc(1, destLength);
|
if (!destBytes) goto fail;
|
|
config.options.use_threads = useThreads; //speed up 23%
|
config.options.bypass_filtering = bypassFiltering; //speed up 11%, cause some banding
|
config.options.no_fancy_upsampling = noFancyUpsampling; //speed down 16%, lose some details
|
config.output.colorspace = colorspace;
|
config.output.is_external_memory = 1;
|
config.output.u.RGBA.rgba = destBytes;
|
config.output.u.RGBA.stride = (int)bytesPerRow;
|
config.output.u.RGBA.size = destLength;
|
|
VP8StatusCode result = WebPDecode(payload, payloadSize, &config);
|
if ((result != VP8_STATUS_OK) && (result != VP8_STATUS_NOT_ENOUGH_DATA)) goto fail;
|
|
if (iter.x_offset != 0 || iter.y_offset != 0) {
|
void *tmp = calloc(1, destLength);
|
if (tmp) {
|
vImage_Buffer src = {destBytes, canvasHeight, canvasWidth, bytesPerRow};
|
vImage_Buffer dest = {tmp, canvasHeight, canvasWidth, bytesPerRow};
|
vImage_CGAffineTransform transform = {1, 0, 0, 1, iter.x_offset, -iter.y_offset};
|
uint8_t backColor[4] = {0};
|
vImageAffineWarpCG_ARGB8888(&src, &dest, NULL, &transform, backColor, kvImageBackgroundColorFill);
|
memcpy(destBytes, tmp, destLength);
|
free(tmp);
|
}
|
}
|
|
provider = CGDataProviderCreateWithData(destBytes, destBytes, destLength, YYCGDataProviderReleaseDataCallback);
|
if (!provider) goto fail;
|
destBytes = NULL; // hold by provider
|
|
imageRef = CGImageCreate(canvasWidth, canvasHeight, bitsPerComponent, bitsPerPixel, bytesPerRow, YYCGColorSpaceGetDeviceRGB(), bitmapInfo, provider, NULL, false, kCGRenderingIntentDefault);
|
|
CFRelease(provider);
|
if (iterInited) WebPDemuxReleaseIterator(&iter);
|
WebPDemuxDelete(demuxer);
|
|
return imageRef;
|
|
fail:
|
if (destBytes) free(destBytes);
|
if (provider) CFRelease(provider);
|
if (iterInited) WebPDemuxReleaseIterator(&iter);
|
if (demuxer) WebPDemuxDelete(demuxer);
|
return NULL;
|
}
|
|
#else
|
|
BOOL YYImageWebPAvailable() {
|
return NO;
|
}
|
|
CFDataRef YYCGImageCreateEncodedWebPData(CGImageRef imageRef, BOOL lossless, CGFloat quality, int compressLevel, YYImagePreset preset) {
|
NSLog(@"WebP decoder is disabled");
|
return NULL;
|
}
|
|
NSUInteger YYImageGetWebPFrameCount(CFDataRef webpData) {
|
NSLog(@"WebP decoder is disabled");
|
return 0;
|
}
|
|
CGImageRef YYCGImageCreateWithWebPData(CFDataRef webpData,
|
BOOL decodeForDisplay,
|
BOOL useThreads,
|
BOOL bypassFiltering,
|
BOOL noFancyUpsampling) {
|
NSLog(@"WebP decoder is disabled");
|
return NULL;
|
}
|
|
#endif
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
#pragma mark - Decoder
|
|
@implementation YYImageFrame
|
+ (instancetype)frameWithImage:(UIImage *)image {
|
YYImageFrame *frame = [self new];
|
frame.image = image;
|
return frame;
|
}
|
- (id)copyWithZone:(NSZone *)zone {
|
YYImageFrame *frame = [self.class new];
|
frame.index = _index;
|
frame.width = _width;
|
frame.height = _height;
|
frame.offsetX = _offsetX;
|
frame.offsetY = _offsetY;
|
frame.duration = _duration;
|
frame.dispose = _dispose;
|
frame.blend = _blend;
|
frame.image = _image.copy;
|
return frame;
|
}
|
@end
|
|
// Internal frame object.
|
@interface _YYImageDecoderFrame : YYImageFrame
|
@property (nonatomic, assign) BOOL hasAlpha; ///< Whether frame has alpha.
|
@property (nonatomic, assign) BOOL isFullSize; ///< Whether frame fill the canvas.
|
@property (nonatomic, assign) NSUInteger blendFromIndex; ///< Blend from frame index to current frame.
|
@end
|
|
@implementation _YYImageDecoderFrame
|
- (id)copyWithZone:(NSZone *)zone {
|
_YYImageDecoderFrame *frame = [super copyWithZone:zone];
|
frame.hasAlpha = _hasAlpha;
|
frame.isFullSize = _isFullSize;
|
frame.blendFromIndex = _blendFromIndex;
|
return frame;
|
}
|
@end
|
|
|
@implementation YYImageDecoder {
|
pthread_mutex_t _lock; // recursive lock
|
|
BOOL _sourceTypeDetected;
|
CGImageSourceRef _source;
|
yy_png_info *_apngSource;
|
#if YYIMAGE_WEBP_ENABLED
|
WebPDemuxer *_webpSource;
|
#endif
|
|
UIImageOrientation _orientation;
|
dispatch_semaphore_t _framesLock;
|
NSArray *_frames; ///< Array<GGImageDecoderFrame>, without image
|
BOOL _needBlend;
|
NSUInteger _blendFrameIndex;
|
CGContextRef _blendCanvas;
|
}
|
|
- (void)dealloc {
|
if (_source) CFRelease(_source);
|
if (_apngSource) yy_png_info_release(_apngSource);
|
#if YYIMAGE_WEBP_ENABLED
|
if (_webpSource) WebPDemuxDelete(_webpSource);
|
#endif
|
if (_blendCanvas) CFRelease(_blendCanvas);
|
pthread_mutex_destroy(&_lock);
|
}
|
|
+ (instancetype)decoderWithData:(NSData *)data scale:(CGFloat)scale {
|
if (!data) return nil;
|
YYImageDecoder *decoder = [[YYImageDecoder alloc] initWithScale:scale];
|
[decoder updateData:data final:YES];
|
if (decoder.frameCount == 0) return nil;
|
return decoder;
|
}
|
|
- (instancetype)init {
|
return [self initWithScale:[UIScreen mainScreen].scale];
|
}
|
|
- (instancetype)initWithScale:(CGFloat)scale {
|
self = [super init];
|
if (scale <= 0) scale = 1;
|
_scale = scale;
|
_framesLock = dispatch_semaphore_create(1);
|
|
pthread_mutexattr_t attr;
|
pthread_mutexattr_init (&attr);
|
pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
|
pthread_mutex_init (&_lock, &attr);
|
pthread_mutexattr_destroy (&attr);
|
|
return self;
|
}
|
|
- (BOOL)updateData:(NSData *)data final:(BOOL)final {
|
BOOL result = NO;
|
pthread_mutex_lock(&_lock);
|
result = [self _updateData:data final:final];
|
pthread_mutex_unlock(&_lock);
|
return result;
|
}
|
|
- (YYImageFrame *)frameAtIndex:(NSUInteger)index decodeForDisplay:(BOOL)decodeForDisplay {
|
YYImageFrame *result = nil;
|
pthread_mutex_lock(&_lock);
|
result = [self _frameAtIndex:index decodeForDisplay:decodeForDisplay];
|
pthread_mutex_unlock(&_lock);
|
return result;
|
}
|
|
- (NSTimeInterval)frameDurationAtIndex:(NSUInteger)index {
|
NSTimeInterval result = 0;
|
dispatch_semaphore_wait(_framesLock, DISPATCH_TIME_FOREVER);
|
if (index < _frames.count) {
|
result = ((_YYImageDecoderFrame *)_frames[index]).duration;
|
}
|
dispatch_semaphore_signal(_framesLock);
|
return result;
|
}
|
|
- (NSDictionary *)framePropertiesAtIndex:(NSUInteger)index {
|
NSDictionary *result = nil;
|
pthread_mutex_lock(&_lock);
|
result = [self _framePropertiesAtIndex:index];
|
pthread_mutex_unlock(&_lock);
|
return result;
|
}
|
|
- (NSDictionary *)imageProperties {
|
NSDictionary *result = nil;
|
pthread_mutex_lock(&_lock);
|
result = [self _imageProperties];
|
pthread_mutex_unlock(&_lock);
|
return result;
|
}
|
|
#pragma private (wrap)
|
|
- (BOOL)_updateData:(NSData *)data final:(BOOL)final {
|
if (_finalized) return NO;
|
if (data.length < _data.length) return NO;
|
_finalized = final;
|
_data = data;
|
|
YYImageType type = YYImageDetectType((__bridge CFDataRef)data);
|
if (_sourceTypeDetected) {
|
if (_type != type) {
|
return NO;
|
} else {
|
[self _updateSource];
|
}
|
} else {
|
if (_data.length > 16) {
|
_type = type;
|
_sourceTypeDetected = YES;
|
[self _updateSource];
|
}
|
}
|
return YES;
|
}
|
|
- (YYImageFrame *)_frameAtIndex:(NSUInteger)index decodeForDisplay:(BOOL)decodeForDisplay {
|
if (index >= _frames.count) return 0;
|
_YYImageDecoderFrame *frame = [(_YYImageDecoderFrame *)_frames[index] copy];
|
BOOL decoded = NO;
|
BOOL extendToCanvas = NO;
|
if (_type != YYImageTypeICO && decodeForDisplay) { // ICO contains multi-size frame and should not extend to canvas.
|
extendToCanvas = YES;
|
}
|
|
if (!_needBlend) {
|
CGImageRef imageRef = [self _newUnblendedImageAtIndex:index extendToCanvas:extendToCanvas decoded:&decoded];
|
if (!imageRef) return nil;
|
if (decodeForDisplay && !decoded) {
|
CGImageRef imageRefDecoded = YYCGImageCreateDecodedCopy(imageRef, YES);
|
if (imageRefDecoded) {
|
CFRelease(imageRef);
|
imageRef = imageRefDecoded;
|
decoded = YES;
|
}
|
}
|
UIImage *image = [UIImage imageWithCGImage:imageRef scale:_scale orientation:_orientation];
|
CFRelease(imageRef);
|
if (!image) return nil;
|
image.yy_isDecodedForDisplay = decoded;
|
frame.image = image;
|
return frame;
|
}
|
|
// blend
|
if (![self _createBlendContextIfNeeded]) return nil;
|
CGImageRef imageRef = NULL;
|
|
if (_blendFrameIndex + 1 == frame.index) {
|
imageRef = [self _newBlendedImageWithFrame:frame];
|
_blendFrameIndex = index;
|
} else { // should draw canvas from previous frame
|
_blendFrameIndex = NSNotFound;
|
CGContextClearRect(_blendCanvas, CGRectMake(0, 0, _width, _height));
|
|
if (frame.blendFromIndex == frame.index) {
|
CGImageRef unblendedImage = [self _newUnblendedImageAtIndex:index extendToCanvas:NO decoded:NULL];
|
if (unblendedImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendedImage);
|
CFRelease(unblendedImage);
|
}
|
imageRef = CGBitmapContextCreateImage(_blendCanvas);
|
if (frame.dispose == YYImageDisposeBackground) {
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
}
|
_blendFrameIndex = index;
|
} else { // canvas is not ready
|
for (uint32_t i = (uint32_t)frame.blendFromIndex; i <= (uint32_t)frame.index; i++) {
|
if (i == frame.index) {
|
if (!imageRef) imageRef = [self _newBlendedImageWithFrame:frame];
|
} else {
|
[self _blendImageWithFrame:_frames[i]];
|
}
|
}
|
_blendFrameIndex = index;
|
}
|
}
|
|
if (!imageRef) return nil;
|
UIImage *image = [UIImage imageWithCGImage:imageRef scale:_scale orientation:_orientation];
|
CFRelease(imageRef);
|
if (!image) return nil;
|
|
image.yy_isDecodedForDisplay = YES;
|
frame.image = image;
|
if (extendToCanvas) {
|
frame.width = _width;
|
frame.height = _height;
|
frame.offsetX = 0;
|
frame.offsetY = 0;
|
frame.dispose = YYImageDisposeNone;
|
frame.blend = YYImageBlendNone;
|
}
|
return frame;
|
}
|
|
- (NSDictionary *)_framePropertiesAtIndex:(NSUInteger)index {
|
if (index >= _frames.count) return nil;
|
if (!_source) return nil;
|
CFDictionaryRef properties = CGImageSourceCopyPropertiesAtIndex(_source, index, NULL);
|
if (!properties) return nil;
|
return CFBridgingRelease(properties);
|
}
|
|
- (NSDictionary *)_imageProperties {
|
if (!_source) return nil;
|
CFDictionaryRef properties = CGImageSourceCopyProperties(_source, NULL);
|
if (!properties) return nil;
|
return CFBridgingRelease(properties);
|
}
|
|
#pragma private
|
|
- (void)_updateSource {
|
switch (_type) {
|
case YYImageTypeWebP: {
|
[self _updateSourceWebP];
|
} break;
|
|
case YYImageTypePNG: {
|
[self _updateSourceAPNG];
|
} break;
|
|
default: {
|
[self _updateSourceImageIO];
|
} break;
|
}
|
}
|
|
- (void)_updateSourceWebP {
|
#if YYIMAGE_WEBP_ENABLED
|
_width = 0;
|
_height = 0;
|
_loopCount = 0;
|
if (_webpSource) WebPDemuxDelete(_webpSource);
|
_webpSource = NULL;
|
dispatch_semaphore_wait(_framesLock, DISPATCH_TIME_FOREVER);
|
_frames = nil;
|
dispatch_semaphore_signal(_framesLock);
|
|
/*
|
https://developers.google.com/speed/webp/docs/api
|
The documentation said we can use WebPIDecoder to decode webp progressively,
|
but currently it can only returns an empty image (not same as progressive jpegs),
|
so we don't use progressive decoding.
|
|
When using WebPDecode() to decode multi-frame webp, we will get the error
|
"VP8_STATUS_UNSUPPORTED_FEATURE", so we first use WebPDemuxer to unpack it.
|
*/
|
|
WebPData webPData = {0};
|
webPData.bytes = _data.bytes;
|
webPData.size = _data.length;
|
WebPDemuxer *demuxer = WebPDemux(&webPData);
|
if (!demuxer) return;
|
|
uint32_t webpFrameCount = WebPDemuxGetI(demuxer, WEBP_FF_FRAME_COUNT);
|
uint32_t webpLoopCount = WebPDemuxGetI(demuxer, WEBP_FF_LOOP_COUNT);
|
uint32_t canvasWidth = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_WIDTH);
|
uint32_t canvasHeight = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_HEIGHT);
|
if (webpFrameCount == 0 || canvasWidth < 1 || canvasHeight < 1) {
|
WebPDemuxDelete(demuxer);
|
return;
|
}
|
|
NSMutableArray *frames = [NSMutableArray new];
|
BOOL needBlend = NO;
|
uint32_t iterIndex = 0;
|
uint32_t lastBlendIndex = 0;
|
WebPIterator iter = {0};
|
if (WebPDemuxGetFrame(demuxer, 1, &iter)) { // one-based index...
|
do {
|
_YYImageDecoderFrame *frame = [_YYImageDecoderFrame new];
|
[frames addObject:frame];
|
if (iter.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
|
frame.dispose = YYImageDisposeBackground;
|
}
|
if (iter.blend_method == WEBP_MUX_BLEND) {
|
frame.blend = YYImageBlendOver;
|
}
|
|
int canvasWidth = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_WIDTH);
|
int canvasHeight = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_HEIGHT);
|
frame.index = iterIndex;
|
frame.duration = iter.duration / 1000.0;
|
frame.width = iter.width;
|
frame.height = iter.height;
|
frame.hasAlpha = iter.has_alpha;
|
frame.blend = iter.blend_method == WEBP_MUX_BLEND;
|
frame.offsetX = iter.x_offset;
|
frame.offsetY = canvasHeight - iter.y_offset - iter.height;
|
|
BOOL sizeEqualsToCanvas = (iter.width == canvasWidth && iter.height == canvasHeight);
|
BOOL offsetIsZero = (iter.x_offset == 0 && iter.y_offset == 0);
|
frame.isFullSize = (sizeEqualsToCanvas && offsetIsZero);
|
|
if ((!frame.blend || !frame.hasAlpha) && frame.isFullSize) {
|
frame.blendFromIndex = lastBlendIndex = iterIndex;
|
} else {
|
if (frame.dispose && frame.isFullSize) {
|
frame.blendFromIndex = lastBlendIndex;
|
lastBlendIndex = iterIndex + 1;
|
} else {
|
frame.blendFromIndex = lastBlendIndex;
|
}
|
}
|
if (frame.index != frame.blendFromIndex) needBlend = YES;
|
iterIndex++;
|
} while (WebPDemuxNextFrame(&iter));
|
WebPDemuxReleaseIterator(&iter);
|
}
|
if (frames.count != webpFrameCount) {
|
WebPDemuxDelete(demuxer);
|
return;
|
}
|
|
_width = canvasWidth;
|
_height = canvasHeight;
|
_frameCount = frames.count;
|
_loopCount = webpLoopCount;
|
_needBlend = needBlend;
|
_webpSource = demuxer;
|
dispatch_semaphore_wait(_framesLock, DISPATCH_TIME_FOREVER);
|
_frames = frames;
|
dispatch_semaphore_signal(_framesLock);
|
#else
|
static const char *func = __FUNCTION__;
|
static const int line = __LINE__;
|
static dispatch_once_t onceToken;
|
dispatch_once(&onceToken, ^{
|
NSLog(@"[%s: %d] WebP is not available, check the documentation to see how to install WebP component: https://github.com/ibireme/YYImage#installation", func, line);
|
});
|
#endif
|
}
|
|
- (void)_updateSourceAPNG {
|
/*
|
APNG extends PNG format to support animation, it was supported by ImageIO
|
since iOS 8.
|
|
We use a custom APNG decoder to make APNG available in old system, so we
|
ignore the ImageIO's APNG frame info. Typically the custom decoder is a bit
|
faster than ImageIO.
|
*/
|
|
yy_png_info_release(_apngSource);
|
_apngSource = nil;
|
|
[self _updateSourceImageIO]; // decode first frame
|
if (_frameCount == 0) return; // png decode failed
|
if (!_finalized) return; // ignore multi-frame before finalized
|
|
yy_png_info *apng = yy_png_info_create(_data.bytes, (uint32_t)_data.length);
|
if (!apng) return; // apng decode failed
|
if (apng->apng_frame_num == 0 ||
|
(apng->apng_frame_num == 1 && apng->apng_first_frame_is_cover)) {
|
yy_png_info_release(apng);
|
return; // no animation
|
}
|
if (_source) { // apng decode succeed, no longer need image souce
|
CFRelease(_source);
|
_source = NULL;
|
}
|
|
uint32_t canvasWidth = apng->header.width;
|
uint32_t canvasHeight = apng->header.height;
|
NSMutableArray *frames = [NSMutableArray new];
|
BOOL needBlend = NO;
|
uint32_t lastBlendIndex = 0;
|
for (uint32_t i = 0; i < apng->apng_frame_num; i++) {
|
_YYImageDecoderFrame *frame = [_YYImageDecoderFrame new];
|
[frames addObject:frame];
|
|
yy_png_frame_info *fi = apng->apng_frames + i;
|
frame.index = i;
|
frame.duration = yy_png_delay_to_seconds(fi->frame_control.delay_num, fi->frame_control.delay_den);
|
frame.hasAlpha = YES;
|
frame.width = fi->frame_control.width;
|
frame.height = fi->frame_control.height;
|
frame.offsetX = fi->frame_control.x_offset;
|
frame.offsetY = canvasHeight - fi->frame_control.y_offset - fi->frame_control.height;
|
|
BOOL sizeEqualsToCanvas = (frame.width == canvasWidth && frame.height == canvasHeight);
|
BOOL offsetIsZero = (fi->frame_control.x_offset == 0 && fi->frame_control.y_offset == 0);
|
frame.isFullSize = (sizeEqualsToCanvas && offsetIsZero);
|
|
switch (fi->frame_control.dispose_op) {
|
case YY_PNG_DISPOSE_OP_BACKGROUND: {
|
frame.dispose = YYImageDisposeBackground;
|
} break;
|
case YY_PNG_DISPOSE_OP_PREVIOUS: {
|
frame.dispose = YYImageDisposePrevious;
|
} break;
|
default: {
|
frame.dispose = YYImageDisposeNone;
|
} break;
|
}
|
switch (fi->frame_control.blend_op) {
|
case YY_PNG_BLEND_OP_OVER: {
|
frame.blend = YYImageBlendOver;
|
} break;
|
|
default: {
|
frame.blend = YYImageBlendNone;
|
} break;
|
}
|
|
if (frame.blend == YYImageBlendNone && frame.isFullSize) {
|
frame.blendFromIndex = i;
|
if (frame.dispose != YYImageDisposePrevious) lastBlendIndex = i;
|
} else {
|
if (frame.dispose == YYImageDisposeBackground && frame.isFullSize) {
|
frame.blendFromIndex = lastBlendIndex;
|
lastBlendIndex = i + 1;
|
} else {
|
frame.blendFromIndex = lastBlendIndex;
|
}
|
}
|
if (frame.index != frame.blendFromIndex) needBlend = YES;
|
}
|
|
_width = canvasWidth;
|
_height = canvasHeight;
|
_frameCount = frames.count;
|
_loopCount = apng->apng_loop_num;
|
_needBlend = needBlend;
|
_apngSource = apng;
|
dispatch_semaphore_wait(_framesLock, DISPATCH_TIME_FOREVER);
|
_frames = frames;
|
dispatch_semaphore_signal(_framesLock);
|
}
|
|
- (void)_updateSourceImageIO {
|
_width = 0;
|
_height = 0;
|
_orientation = UIImageOrientationUp;
|
_loopCount = 0;
|
dispatch_semaphore_wait(_framesLock, DISPATCH_TIME_FOREVER);
|
_frames = nil;
|
dispatch_semaphore_signal(_framesLock);
|
|
if (!_source) {
|
if (_finalized) {
|
_source = CGImageSourceCreateWithData((__bridge CFDataRef)_data, NULL);
|
} else {
|
_source = CGImageSourceCreateIncremental(NULL);
|
if (_source) CGImageSourceUpdateData(_source, (__bridge CFDataRef)_data, false);
|
}
|
} else {
|
CGImageSourceUpdateData(_source, (__bridge CFDataRef)_data, _finalized);
|
}
|
if (!_source) return;
|
|
_frameCount = CGImageSourceGetCount(_source);
|
if (_frameCount == 0) return;
|
|
if (!_finalized) { // ignore multi-frame before finalized
|
_frameCount = 1;
|
} else {
|
if (_type == YYImageTypePNG) { // use custom apng decoder and ignore multi-frame
|
_frameCount = 1;
|
}
|
if (_type == YYImageTypeGIF) { // get gif loop count
|
CFDictionaryRef properties = CGImageSourceCopyProperties(_source, NULL);
|
if (properties) {
|
CFDictionaryRef gif = CFDictionaryGetValue(properties, kCGImagePropertyGIFDictionary);
|
if (gif) {
|
CFTypeRef loop = CFDictionaryGetValue(gif, kCGImagePropertyGIFLoopCount);
|
if (loop) CFNumberGetValue(loop, kCFNumberNSIntegerType, &_loopCount);
|
}
|
CFRelease(properties);
|
}
|
}
|
}
|
|
/*
|
ICO, GIF, APNG may contains multi-frame.
|
*/
|
NSMutableArray *frames = [NSMutableArray new];
|
for (NSUInteger i = 0; i < _frameCount; i++) {
|
_YYImageDecoderFrame *frame = [_YYImageDecoderFrame new];
|
frame.index = i;
|
frame.blendFromIndex = i;
|
frame.hasAlpha = YES;
|
frame.isFullSize = YES;
|
[frames addObject:frame];
|
|
CFDictionaryRef properties = CGImageSourceCopyPropertiesAtIndex(_source, i, NULL);
|
if (properties) {
|
NSTimeInterval duration = 0;
|
NSInteger orientationValue = 0, width = 0, height = 0;
|
CFTypeRef value = NULL;
|
|
value = CFDictionaryGetValue(properties, kCGImagePropertyPixelWidth);
|
if (value) CFNumberGetValue(value, kCFNumberNSIntegerType, &width);
|
value = CFDictionaryGetValue(properties, kCGImagePropertyPixelHeight);
|
if (value) CFNumberGetValue(value, kCFNumberNSIntegerType, &height);
|
if (_type == YYImageTypeGIF) {
|
CFDictionaryRef gif = CFDictionaryGetValue(properties, kCGImagePropertyGIFDictionary);
|
if (gif) {
|
// Use the unclamped frame delay if it exists.
|
value = CFDictionaryGetValue(gif, kCGImagePropertyGIFUnclampedDelayTime);
|
if (!value) {
|
// Fall back to the clamped frame delay if the unclamped frame delay does not exist.
|
value = CFDictionaryGetValue(gif, kCGImagePropertyGIFDelayTime);
|
}
|
if (value) CFNumberGetValue(value, kCFNumberDoubleType, &duration);
|
}
|
}
|
|
frame.width = width;
|
frame.height = height;
|
frame.duration = duration;
|
|
if (i == 0 && _width + _height == 0) { // init first frame
|
_width = width;
|
_height = height;
|
value = CFDictionaryGetValue(properties, kCGImagePropertyOrientation);
|
if (value) {
|
CFNumberGetValue(value, kCFNumberNSIntegerType, &orientationValue);
|
_orientation = YYUIImageOrientationFromEXIFValue(orientationValue);
|
}
|
}
|
CFRelease(properties);
|
}
|
}
|
dispatch_semaphore_wait(_framesLock, DISPATCH_TIME_FOREVER);
|
_frames = frames;
|
dispatch_semaphore_signal(_framesLock);
|
}
|
|
- (CGImageRef)_newUnblendedImageAtIndex:(NSUInteger)index
|
extendToCanvas:(BOOL)extendToCanvas
|
decoded:(BOOL *)decoded CF_RETURNS_RETAINED {
|
|
if (!_finalized && index > 0) return NULL;
|
if (_frames.count <= index) return NULL;
|
_YYImageDecoderFrame *frame = _frames[index];
|
|
if (_source) {
|
CGImageRef imageRef = CGImageSourceCreateImageAtIndex(_source, index, (CFDictionaryRef)@{(id)kCGImageSourceShouldCache:@(YES)});
|
if (imageRef && extendToCanvas) {
|
size_t width = CGImageGetWidth(imageRef);
|
size_t height = CGImageGetHeight(imageRef);
|
if (width == _width && height == _height) {
|
CGImageRef imageRefExtended = YYCGImageCreateDecodedCopy(imageRef, YES);
|
if (imageRefExtended) {
|
CFRelease(imageRef);
|
imageRef = imageRefExtended;
|
if (decoded) *decoded = YES;
|
}
|
} else {
|
CGContextRef context = CGBitmapContextCreate(NULL, _width, _height, 8, 0, YYCGColorSpaceGetDeviceRGB(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
|
if (context) {
|
CGContextDrawImage(context, CGRectMake(0, _height - height, width, height), imageRef);
|
CGImageRef imageRefExtended = CGBitmapContextCreateImage(context);
|
CFRelease(context);
|
if (imageRefExtended) {
|
CFRelease(imageRef);
|
imageRef = imageRefExtended;
|
if (decoded) *decoded = YES;
|
}
|
}
|
}
|
}
|
return imageRef;
|
}
|
|
if (_apngSource) {
|
uint32_t size = 0;
|
uint8_t *bytes = yy_png_copy_frame_data_at_index(_data.bytes, _apngSource, (uint32_t)index, &size);
|
if (!bytes) return NULL;
|
CGDataProviderRef provider = CGDataProviderCreateWithData(bytes, bytes, size, YYCGDataProviderReleaseDataCallback);
|
if (!provider) {
|
free(bytes);
|
return NULL;
|
}
|
bytes = NULL; // hold by provider
|
|
CGImageSourceRef source = CGImageSourceCreateWithDataProvider(provider, NULL);
|
if (!source) {
|
CFRelease(provider);
|
return NULL;
|
}
|
CFRelease(provider);
|
|
if(CGImageSourceGetCount(source) < 1) {
|
CFRelease(source);
|
return NULL;
|
}
|
|
CGImageRef imageRef = CGImageSourceCreateImageAtIndex(source, 0, (CFDictionaryRef)@{(id)kCGImageSourceShouldCache:@(YES)});
|
CFRelease(source);
|
if (!imageRef) return NULL;
|
if (extendToCanvas) {
|
CGContextRef context = CGBitmapContextCreate(NULL, _width, _height, 8, 0, YYCGColorSpaceGetDeviceRGB(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst); //bgrA
|
if (context) {
|
CGContextDrawImage(context, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), imageRef);
|
CFRelease(imageRef);
|
imageRef = CGBitmapContextCreateImage(context);
|
CFRelease(context);
|
if (decoded) *decoded = YES;
|
}
|
}
|
return imageRef;
|
}
|
|
#if YYIMAGE_WEBP_ENABLED
|
if (_webpSource) {
|
WebPIterator iter;
|
if (!WebPDemuxGetFrame(_webpSource, (int)(index + 1), &iter)) return NULL; // demux webp frame data
|
// frame numbers are one-based in webp -----------^
|
|
int frameWidth = iter.width;
|
int frameHeight = iter.height;
|
if (frameWidth < 1 || frameHeight < 1) return NULL;
|
|
int width = extendToCanvas ? (int)_width : frameWidth;
|
int height = extendToCanvas ? (int)_height : frameHeight;
|
if (width > _width || height > _height) return NULL;
|
|
const uint8_t *payload = iter.fragment.bytes;
|
size_t payloadSize = iter.fragment.size;
|
|
WebPDecoderConfig config;
|
if (!WebPInitDecoderConfig(&config)) {
|
WebPDemuxReleaseIterator(&iter);
|
return NULL;
|
}
|
if (WebPGetFeatures(payload , payloadSize, &config.input) != VP8_STATUS_OK) {
|
WebPDemuxReleaseIterator(&iter);
|
return NULL;
|
}
|
|
size_t bitsPerComponent = 8;
|
size_t bitsPerPixel = 32;
|
size_t bytesPerRow = YYImageByteAlign(bitsPerPixel / 8 * width, 32);
|
size_t length = bytesPerRow * height;
|
CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst; //bgrA
|
|
void *pixels = calloc(1, length);
|
if (!pixels) {
|
WebPDemuxReleaseIterator(&iter);
|
return NULL;
|
}
|
|
config.output.colorspace = MODE_bgrA;
|
config.output.is_external_memory = 1;
|
config.output.u.RGBA.rgba = pixels;
|
config.output.u.RGBA.stride = (int)bytesPerRow;
|
config.output.u.RGBA.size = length;
|
VP8StatusCode result = WebPDecode(payload, payloadSize, &config); // decode
|
if ((result != VP8_STATUS_OK) && (result != VP8_STATUS_NOT_ENOUGH_DATA)) {
|
WebPDemuxReleaseIterator(&iter);
|
free(pixels);
|
return NULL;
|
}
|
WebPDemuxReleaseIterator(&iter);
|
|
if (extendToCanvas && (iter.x_offset != 0 || iter.y_offset != 0)) {
|
void *tmp = calloc(1, length);
|
if (tmp) {
|
vImage_Buffer src = {pixels, height, width, bytesPerRow};
|
vImage_Buffer dest = {tmp, height, width, bytesPerRow};
|
vImage_CGAffineTransform transform = {1, 0, 0, 1, iter.x_offset, -iter.y_offset};
|
uint8_t backColor[4] = {0};
|
vImage_Error error = vImageAffineWarpCG_ARGB8888(&src, &dest, NULL, &transform, backColor, kvImageBackgroundColorFill);
|
if (error == kvImageNoError) {
|
memcpy(pixels, tmp, length);
|
}
|
free(tmp);
|
}
|
}
|
|
CGDataProviderRef provider = CGDataProviderCreateWithData(pixels, pixels, length, YYCGDataProviderReleaseDataCallback);
|
if (!provider) {
|
free(pixels);
|
return NULL;
|
}
|
pixels = NULL; // hold by provider
|
|
CGImageRef image = CGImageCreate(width, height, bitsPerComponent, bitsPerPixel, bytesPerRow, YYCGColorSpaceGetDeviceRGB(), bitmapInfo, provider, NULL, false, kCGRenderingIntentDefault);
|
CFRelease(provider);
|
if (decoded) *decoded = YES;
|
return image;
|
}
|
#endif
|
|
return NULL;
|
}
|
|
- (BOOL)_createBlendContextIfNeeded {
|
if (!_blendCanvas) {
|
_blendFrameIndex = NSNotFound;
|
_blendCanvas = CGBitmapContextCreate(NULL, _width, _height, 8, 0, YYCGColorSpaceGetDeviceRGB(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
|
}
|
BOOL suc = _blendCanvas != NULL;
|
return suc;
|
}
|
|
- (void)_blendImageWithFrame:(_YYImageDecoderFrame *)frame {
|
if (frame.dispose == YYImageDisposePrevious) {
|
// nothing
|
} else if (frame.dispose == YYImageDisposeBackground) {
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
} else { // no dispose
|
if (frame.blend == YYImageBlendOver) {
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
} else {
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
}
|
}
|
}
|
|
- (CGImageRef)_newBlendedImageWithFrame:(_YYImageDecoderFrame *)frame CF_RETURNS_RETAINED{
|
CGImageRef imageRef = NULL;
|
if (frame.dispose == YYImageDisposePrevious) {
|
if (frame.blend == YYImageBlendOver) {
|
CGImageRef previousImage = CGBitmapContextCreateImage(_blendCanvas);
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
imageRef = CGBitmapContextCreateImage(_blendCanvas);
|
CGContextClearRect(_blendCanvas, CGRectMake(0, 0, _width, _height));
|
if (previousImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(0, 0, _width, _height), previousImage);
|
CFRelease(previousImage);
|
}
|
} else {
|
CGImageRef previousImage = CGBitmapContextCreateImage(_blendCanvas);
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
imageRef = CGBitmapContextCreateImage(_blendCanvas);
|
CGContextClearRect(_blendCanvas, CGRectMake(0, 0, _width, _height));
|
if (previousImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(0, 0, _width, _height), previousImage);
|
CFRelease(previousImage);
|
}
|
}
|
} else if (frame.dispose == YYImageDisposeBackground) {
|
if (frame.blend == YYImageBlendOver) {
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
imageRef = CGBitmapContextCreateImage(_blendCanvas);
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
} else {
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
imageRef = CGBitmapContextCreateImage(_blendCanvas);
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
}
|
} else { // no dispose
|
if (frame.blend == YYImageBlendOver) {
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
imageRef = CGBitmapContextCreateImage(_blendCanvas);
|
} else {
|
CGImageRef unblendImage = [self _newUnblendedImageAtIndex:frame.index extendToCanvas:NO decoded:NULL];
|
if (unblendImage) {
|
CGContextClearRect(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height));
|
CGContextDrawImage(_blendCanvas, CGRectMake(frame.offsetX, frame.offsetY, frame.width, frame.height), unblendImage);
|
CFRelease(unblendImage);
|
}
|
imageRef = CGBitmapContextCreateImage(_blendCanvas);
|
}
|
}
|
return imageRef;
|
}
|
|
@end
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
#pragma mark - Encoder
|
|
@implementation YYImageEncoder {
|
NSMutableArray *_images;
|
NSMutableArray *_durations;
|
}
|
|
- (instancetype)init {
|
@throw [NSException exceptionWithName:@"YYImageEncoder init error" reason:@"YYImageEncoder must be initialized with a type. Use 'initWithType:' instead." userInfo:nil];
|
return [self initWithType:YYImageTypeUnknown];
|
}
|
|
- (instancetype)initWithType:(YYImageType)type {
|
if (type == YYImageTypeUnknown || type >= YYImageTypeOther) {
|
NSLog(@"[%s: %d] Unsupported image type:%d",__FUNCTION__, __LINE__, (int)type);
|
return nil;
|
}
|
|
#if !YYIMAGE_WEBP_ENABLED
|
if (type == YYImageTypeWebP) {
|
NSLog(@"[%s: %d] WebP is not available, check the documentation to see how to install WebP component: https://github.com/ibireme/YYImage#installation", __FUNCTION__, __LINE__);
|
return nil;
|
}
|
#endif
|
|
self = [super init];
|
if (!self) return nil;
|
_type = type;
|
_images = [NSMutableArray new];
|
_durations = [NSMutableArray new];
|
|
switch (type) {
|
case YYImageTypeJPEG:
|
case YYImageTypeJPEG2000: {
|
_quality = 0.9;
|
} break;
|
case YYImageTypeTIFF:
|
case YYImageTypeBMP:
|
case YYImageTypeGIF:
|
case YYImageTypeICO:
|
case YYImageTypeICNS:
|
case YYImageTypePNG: {
|
_quality = 1;
|
_lossless = YES;
|
} break;
|
case YYImageTypeWebP: {
|
_quality = 0.8;
|
} break;
|
default:
|
break;
|
}
|
|
return self;
|
}
|
|
- (void)setQuality:(CGFloat)quality {
|
_quality = quality < 0 ? 0 : quality > 1 ? 1 : quality;
|
}
|
|
- (void)addImage:(UIImage *)image duration:(NSTimeInterval)duration {
|
if (!image.CGImage) return;
|
duration = duration < 0 ? 0 : duration;
|
[_images addObject:image];
|
[_durations addObject:@(duration)];
|
}
|
|
- (void)addImageWithData:(NSData *)data duration:(NSTimeInterval)duration {
|
if (data.length == 0) return;
|
duration = duration < 0 ? 0 : duration;
|
[_images addObject:data];
|
[_durations addObject:@(duration)];
|
}
|
|
- (void)addImageWithFile:(NSString *)path duration:(NSTimeInterval)duration {
|
if (path.length == 0) return;
|
duration = duration < 0 ? 0 : duration;
|
NSURL *url = [NSURL URLWithString:path];
|
if (!url) return;
|
[_images addObject:url];
|
[_durations addObject:@(duration)];
|
}
|
|
- (BOOL)_imageIOAvaliable {
|
switch (_type) {
|
case YYImageTypeJPEG:
|
case YYImageTypeJPEG2000:
|
case YYImageTypeTIFF:
|
case YYImageTypeBMP:
|
case YYImageTypeICO:
|
case YYImageTypeICNS:
|
case YYImageTypeGIF: {
|
return _images.count > 0;
|
} break;
|
case YYImageTypePNG: {
|
return _images.count == 1;
|
} break;
|
case YYImageTypeWebP: {
|
return NO;
|
} break;
|
default: return NO;
|
}
|
}
|
|
- (CGImageDestinationRef)_newImageDestination:(id)dest imageCount:(NSUInteger)count CF_RETURNS_RETAINED {
|
if (!dest) return nil;
|
CGImageDestinationRef destination = NULL;
|
if ([dest isKindOfClass:[NSString class]]) {
|
NSURL *url = [[NSURL alloc] initFileURLWithPath:dest];
|
if (url) {
|
destination = CGImageDestinationCreateWithURL((CFURLRef)url, YYImageTypeToUTType(_type), count, NULL);
|
}
|
} else if ([dest isKindOfClass:[NSMutableData class]]) {
|
destination = CGImageDestinationCreateWithData((CFMutableDataRef)dest, YYImageTypeToUTType(_type), count, NULL);
|
}
|
return destination;
|
}
|
|
- (void)_encodeImageWithDestination:(CGImageDestinationRef)destination imageCount:(NSUInteger)count {
|
if (_type == YYImageTypeGIF) {
|
NSDictionary *gifProperty = @{(__bridge id)kCGImagePropertyGIFDictionary:
|
@{(__bridge id)kCGImagePropertyGIFLoopCount: @(_loopCount)}};
|
CGImageDestinationSetProperties(destination, (__bridge CFDictionaryRef)gifProperty);
|
}
|
|
for (int i = 0; i < count; i++) {
|
@autoreleasepool {
|
id imageSrc = _images[i];
|
NSDictionary *frameProperty = NULL;
|
if (_type == YYImageTypeGIF && count > 1) {
|
frameProperty = @{(NSString *)kCGImagePropertyGIFDictionary : @{(NSString *) kCGImagePropertyGIFDelayTime:_durations[i]}};
|
} else {
|
frameProperty = @{(id)kCGImageDestinationLossyCompressionQuality : @(_quality)};
|
}
|
|
if ([imageSrc isKindOfClass:[UIImage class]]) {
|
UIImage *image = imageSrc;
|
if (image.imageOrientation != UIImageOrientationUp && image.CGImage) {
|
CGBitmapInfo info = CGImageGetBitmapInfo(image.CGImage) | CGImageGetAlphaInfo(image.CGImage);
|
CGImageRef rotated = YYCGImageCreateCopyWithOrientation(image.CGImage, image.imageOrientation, info);
|
if (rotated) {
|
image = [UIImage imageWithCGImage:rotated];
|
CFRelease(rotated);
|
}
|
}
|
if (image.CGImage) CGImageDestinationAddImage(destination, ((UIImage *)imageSrc).CGImage, (CFDictionaryRef)frameProperty);
|
} else if ([imageSrc isKindOfClass:[NSURL class]]) {
|
CGImageSourceRef source = CGImageSourceCreateWithURL((CFURLRef)imageSrc, NULL);
|
if (source) {
|
CGImageDestinationAddImageFromSource(destination, source, 0, (CFDictionaryRef)frameProperty);
|
CFRelease(source);
|
}
|
} else if ([imageSrc isKindOfClass:[NSData class]]) {
|
CGImageSourceRef source = CGImageSourceCreateWithData((CFDataRef)imageSrc, NULL);
|
if (source) {
|
CGImageDestinationAddImageFromSource(destination, source, 0, (CFDictionaryRef)frameProperty);
|
CFRelease(source);
|
}
|
}
|
}
|
}
|
}
|
|
- (CGImageRef)_newCGImageFromIndex:(NSUInteger)index decoded:(BOOL)decoded CF_RETURNS_RETAINED {
|
UIImage *image = nil;
|
id imageSrc= _images[index];
|
if ([imageSrc isKindOfClass:[UIImage class]]) {
|
image = imageSrc;
|
} else if ([imageSrc isKindOfClass:[NSURL class]]) {
|
image = [UIImage imageWithContentsOfFile:((NSURL *)imageSrc).absoluteString];
|
} else if ([imageSrc isKindOfClass:[NSData class]]) {
|
image = [UIImage imageWithData:imageSrc];
|
}
|
if (!image) return NULL;
|
CGImageRef imageRef = image.CGImage;
|
if (!imageRef) return NULL;
|
if (image.imageOrientation != UIImageOrientationUp) {
|
return YYCGImageCreateCopyWithOrientation(imageRef, image.imageOrientation, kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
|
}
|
if (decoded) {
|
return YYCGImageCreateDecodedCopy(imageRef, YES);
|
}
|
return (CGImageRef)CFRetain(imageRef);
|
}
|
|
- (NSData *)_encodeWithImageIO {
|
NSMutableData *data = [NSMutableData new];
|
NSUInteger count = _type == YYImageTypeGIF ? _images.count : 1;
|
CGImageDestinationRef destination = [self _newImageDestination:data imageCount:count];
|
BOOL suc = NO;
|
if (destination) {
|
[self _encodeImageWithDestination:destination imageCount:count];
|
suc = CGImageDestinationFinalize(destination);
|
CFRelease(destination);
|
}
|
if (suc && data.length > 0) {
|
return data;
|
} else {
|
return nil;
|
}
|
}
|
|
- (BOOL)_encodeWithImageIO:(NSString *)path {
|
NSUInteger count = _type == YYImageTypeGIF ? _images.count : 1;
|
CGImageDestinationRef destination = [self _newImageDestination:path imageCount:count];
|
BOOL suc = NO;
|
if (destination) {
|
[self _encodeImageWithDestination:destination imageCount:count];
|
suc = CGImageDestinationFinalize(destination);
|
CFRelease(destination);
|
}
|
return suc;
|
}
|
|
- (NSData *)_encodeAPNG {
|
// encode APNG (ImageIO doesn't support APNG encoding, so we use a custom encoder)
|
NSMutableArray *pngDatas = [NSMutableArray new];
|
NSMutableArray *pngSizes = [NSMutableArray new];
|
NSUInteger canvasWidth = 0, canvasHeight = 0;
|
for (int i = 0; i < _images.count; i++) {
|
CGImageRef decoded = [self _newCGImageFromIndex:i decoded:YES];
|
if (!decoded) return nil;
|
CGSize size = CGSizeMake(CGImageGetWidth(decoded), CGImageGetHeight(decoded));
|
[pngSizes addObject:[NSValue valueWithCGSize:size]];
|
if (canvasWidth < size.width) canvasWidth = size.width;
|
if (canvasHeight < size.height) canvasHeight = size.height;
|
CFDataRef frameData = YYCGImageCreateEncodedData(decoded, YYImageTypePNG, 1);
|
CFRelease(decoded);
|
if (!frameData) return nil;
|
[pngDatas addObject:(__bridge id)(frameData)];
|
CFRelease(frameData);
|
if (size.width < 1 || size.height < 1) return nil;
|
}
|
CGSize firstFrameSize = [(NSValue *)[pngSizes firstObject] CGSizeValue];
|
if (firstFrameSize.width < canvasWidth || firstFrameSize.height < canvasHeight) {
|
CGImageRef decoded = [self _newCGImageFromIndex:0 decoded:YES];
|
if (!decoded) return nil;
|
CGContextRef context = CGBitmapContextCreate(NULL, canvasWidth, canvasHeight, 8,
|
0, YYCGColorSpaceGetDeviceRGB(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
|
if (!context) {
|
CFRelease(decoded);
|
return nil;
|
}
|
CGContextDrawImage(context, CGRectMake(0, canvasHeight - firstFrameSize.height, firstFrameSize.width, firstFrameSize.height), decoded);
|
CFRelease(decoded);
|
CGImageRef extendedImage = CGBitmapContextCreateImage(context);
|
CFRelease(context);
|
if (!extendedImage) return nil;
|
CFDataRef frameData = YYCGImageCreateEncodedData(extendedImage, YYImageTypePNG, 1);
|
if (!frameData) {
|
CFRelease(extendedImage);
|
return nil;
|
}
|
pngDatas[0] = (__bridge id)(frameData);
|
CFRelease(frameData);
|
}
|
|
NSData *firstFrameData = pngDatas[0];
|
yy_png_info *info = yy_png_info_create(firstFrameData.bytes, (uint32_t)firstFrameData.length);
|
if (!info) return nil;
|
NSMutableData *result = [NSMutableData new];
|
BOOL insertBefore = NO, insertAfter = NO;
|
uint32_t apngSequenceIndex = 0;
|
|
uint32_t png_header[2];
|
png_header[0] = YY_FOUR_CC(0x89, 0x50, 0x4E, 0x47);
|
png_header[1] = YY_FOUR_CC(0x0D, 0x0A, 0x1A, 0x0A);
|
|
[result appendBytes:png_header length:8];
|
|
for (int i = 0; i < info->chunk_num; i++) {
|
yy_png_chunk_info *chunk = info->chunks + i;
|
|
if (!insertBefore && chunk->fourcc == YY_FOUR_CC('I', 'D', 'A', 'T')) {
|
insertBefore = YES;
|
// insert acTL (APNG Control)
|
uint32_t acTL[5] = {0};
|
acTL[0] = yy_swap_endian_uint32(8); //length
|
acTL[1] = YY_FOUR_CC('a', 'c', 'T', 'L'); // fourcc
|
acTL[2] = yy_swap_endian_uint32((uint32_t)pngDatas.count); // num frames
|
acTL[3] = yy_swap_endian_uint32((uint32_t)_loopCount); // num plays
|
acTL[4] = yy_swap_endian_uint32((uint32_t)crc32(0, (const Bytef *)(acTL + 1), 12)); //crc32
|
[result appendBytes:acTL length:20];
|
|
// insert fcTL (first frame control)
|
yy_png_chunk_fcTL chunk_fcTL = {0};
|
chunk_fcTL.sequence_number = apngSequenceIndex;
|
chunk_fcTL.width = (uint32_t)firstFrameSize.width;
|
chunk_fcTL.height = (uint32_t)firstFrameSize.height;
|
yy_png_delay_to_fraction([(NSNumber *)_durations[0] doubleValue], &chunk_fcTL.delay_num, &chunk_fcTL.delay_den);
|
chunk_fcTL.delay_num = chunk_fcTL.delay_num;
|
chunk_fcTL.delay_den = chunk_fcTL.delay_den;
|
chunk_fcTL.dispose_op = YY_PNG_DISPOSE_OP_BACKGROUND;
|
chunk_fcTL.blend_op = YY_PNG_BLEND_OP_SOURCE;
|
|
uint8_t fcTL[38] = {0};
|
*((uint32_t *)fcTL) = yy_swap_endian_uint32(26); //length
|
*((uint32_t *)(fcTL + 4)) = YY_FOUR_CC('f', 'c', 'T', 'L'); // fourcc
|
yy_png_chunk_fcTL_write(&chunk_fcTL, fcTL + 8);
|
*((uint32_t *)(fcTL + 34)) = yy_swap_endian_uint32((uint32_t)crc32(0, (const Bytef *)(fcTL + 4), 30));
|
[result appendBytes:fcTL length:38];
|
|
apngSequenceIndex++;
|
}
|
|
if (!insertAfter && insertBefore && chunk->fourcc != YY_FOUR_CC('I', 'D', 'A', 'T')) {
|
insertAfter = YES;
|
// insert fcTL and fdAT (APNG frame control and data)
|
|
for (int i = 1; i < pngDatas.count; i++) {
|
NSData *frameData = pngDatas[i];
|
yy_png_info *frame = yy_png_info_create(frameData.bytes, (uint32_t)frameData.length);
|
if (!frame) {
|
yy_png_info_release(info);
|
return nil;
|
}
|
|
// insert fcTL (first frame control)
|
yy_png_chunk_fcTL chunk_fcTL = {0};
|
chunk_fcTL.sequence_number = apngSequenceIndex;
|
chunk_fcTL.width = frame->header.width;
|
chunk_fcTL.height = frame->header.height;
|
yy_png_delay_to_fraction([(NSNumber *)_durations[i] doubleValue], &chunk_fcTL.delay_num, &chunk_fcTL.delay_den);
|
chunk_fcTL.delay_num = chunk_fcTL.delay_num;
|
chunk_fcTL.delay_den = chunk_fcTL.delay_den;
|
chunk_fcTL.dispose_op = YY_PNG_DISPOSE_OP_BACKGROUND;
|
chunk_fcTL.blend_op = YY_PNG_BLEND_OP_SOURCE;
|
|
uint8_t fcTL[38] = {0};
|
*((uint32_t *)fcTL) = yy_swap_endian_uint32(26); //length
|
*((uint32_t *)(fcTL + 4)) = YY_FOUR_CC('f', 'c', 'T', 'L'); // fourcc
|
yy_png_chunk_fcTL_write(&chunk_fcTL, fcTL + 8);
|
*((uint32_t *)(fcTL + 34)) = yy_swap_endian_uint32((uint32_t)crc32(0, (const Bytef *)(fcTL + 4), 30));
|
[result appendBytes:fcTL length:38];
|
|
apngSequenceIndex++;
|
|
// insert fdAT (frame data)
|
for (int d = 0; d < frame->chunk_num; d++) {
|
yy_png_chunk_info *dchunk = frame->chunks + d;
|
if (dchunk->fourcc == YY_FOUR_CC('I', 'D', 'A', 'T')) {
|
uint32_t length = yy_swap_endian_uint32(dchunk->length + 4);
|
[result appendBytes:&length length:4]; //length
|
uint32_t fourcc = YY_FOUR_CC('f', 'd', 'A', 'T');
|
[result appendBytes:&fourcc length:4]; //fourcc
|
uint32_t sq = yy_swap_endian_uint32(apngSequenceIndex);
|
[result appendBytes:&sq length:4]; //data (sq)
|
[result appendBytes:(((uint8_t *)frameData.bytes) + dchunk->offset + 8) length:dchunk->length]; //data
|
uint8_t *bytes = ((uint8_t *)result.bytes) + result.length - dchunk->length - 8;
|
uint32_t crc = yy_swap_endian_uint32((uint32_t)crc32(0, bytes, dchunk->length + 8));
|
[result appendBytes:&crc length:4]; //crc
|
|
apngSequenceIndex++;
|
}
|
}
|
yy_png_info_release(frame);
|
}
|
}
|
|
[result appendBytes:((uint8_t *)firstFrameData.bytes) + chunk->offset length:chunk->length + 12];
|
}
|
yy_png_info_release(info);
|
return result;
|
}
|
|
- (NSData *)_encodeWebP {
|
#if YYIMAGE_WEBP_ENABLED
|
// encode webp
|
NSMutableArray *webpDatas = [NSMutableArray new];
|
for (NSUInteger i = 0; i < _images.count; i++) {
|
CGImageRef image = [self _newCGImageFromIndex:i decoded:NO];
|
if (!image) return nil;
|
CFDataRef frameData = YYCGImageCreateEncodedWebPData(image, _lossless, _quality, 4, YYImagePresetDefault);
|
CFRelease(image);
|
if (!frameData) return nil;
|
[webpDatas addObject:(__bridge id)frameData];
|
CFRelease(frameData);
|
}
|
if (webpDatas.count == 1) {
|
return webpDatas.firstObject;
|
} else {
|
// multi-frame webp
|
WebPMux *mux = WebPMuxNew();
|
if (!mux) return nil;
|
for (NSUInteger i = 0; i < _images.count; i++) {
|
NSData *data = webpDatas[i];
|
NSNumber *duration = _durations[i];
|
WebPMuxFrameInfo frame = {0};
|
frame.bitstream.bytes = data.bytes;
|
frame.bitstream.size = data.length;
|
frame.duration = (int)(duration.floatValue * 1000.0);
|
frame.id = WEBP_CHUNK_ANMF;
|
frame.dispose_method = WEBP_MUX_DISPOSE_BACKGROUND;
|
frame.blend_method = WEBP_MUX_NO_BLEND;
|
if (WebPMuxPushFrame(mux, &frame, 0) != WEBP_MUX_OK) {
|
WebPMuxDelete(mux);
|
return nil;
|
}
|
}
|
|
WebPMuxAnimParams params = {(uint32_t)0, (int)_loopCount};
|
if (WebPMuxSetAnimationParams(mux, ¶ms) != WEBP_MUX_OK) {
|
WebPMuxDelete(mux);
|
return nil;
|
}
|
|
WebPData output_data;
|
WebPMuxError error = WebPMuxAssemble(mux, &output_data);
|
WebPMuxDelete(mux);
|
if (error != WEBP_MUX_OK) {
|
return nil;
|
}
|
NSData *result = [NSData dataWithBytes:output_data.bytes length:output_data.size];
|
WebPDataClear(&output_data);
|
return result.length ? result : nil;
|
}
|
#else
|
return nil;
|
#endif
|
}
|
- (NSData *)encode {
|
if (_images.count == 0) return nil;
|
|
if ([self _imageIOAvaliable]) return [self _encodeWithImageIO];
|
if (_type == YYImageTypePNG) return [self _encodeAPNG];
|
if (_type == YYImageTypeWebP) return [self _encodeWebP];
|
return nil;
|
}
|
|
- (BOOL)encodeToFile:(NSString *)path {
|
if (_images.count == 0 || path.length == 0) return NO;
|
|
if ([self _imageIOAvaliable]) return [self _encodeWithImageIO:path];
|
NSData *data = [self encode];
|
if (!data) return NO;
|
return [data writeToFile:path atomically:YES];
|
}
|
|
+ (NSData *)encodeImage:(UIImage *)image type:(YYImageType)type quality:(CGFloat)quality {
|
YYImageEncoder *encoder = [[YYImageEncoder alloc] initWithType:type];
|
encoder.quality = quality;
|
[encoder addImage:image duration:0];
|
return [encoder encode];
|
}
|
|
+ (NSData *)encodeImageWithDecoder:(YYImageDecoder *)decoder type:(YYImageType)type quality:(CGFloat)quality {
|
if (!decoder || decoder.frameCount == 0) return nil;
|
YYImageEncoder *encoder = [[YYImageEncoder alloc] initWithType:type];
|
encoder.quality = quality;
|
for (int i = 0; i < decoder.frameCount; i++) {
|
UIImage *frame = [decoder frameAtIndex:i decodeForDisplay:YES].image;
|
[encoder addImageWithData:UIImagePNGRepresentation(frame) duration:[decoder frameDurationAtIndex:i]];
|
}
|
return encoder.encode;
|
}
|
|
@end
|
|
|
@implementation UIImage (YYImageCoder)
|
|
- (instancetype)yy_imageByDecoded {
|
if (self.yy_isDecodedForDisplay) return self;
|
CGImageRef imageRef = self.CGImage;
|
if (!imageRef) return self;
|
CGImageRef newImageRef = YYCGImageCreateDecodedCopy(imageRef, YES);
|
if (!newImageRef) return self;
|
UIImage *newImage = [[self.class alloc] initWithCGImage:newImageRef scale:self.scale orientation:self.imageOrientation];
|
CGImageRelease(newImageRef);
|
if (!newImage) newImage = self; // decode failed, return self.
|
newImage.yy_isDecodedForDisplay = YES;
|
return newImage;
|
}
|
|
- (BOOL)yy_isDecodedForDisplay {
|
if (self.images.count > 1 || [self isKindOfClass:[YYSpriteSheetImage class]]) return YES;
|
NSNumber *num = objc_getAssociatedObject(self, @selector(yy_isDecodedForDisplay));
|
return [num boolValue];
|
}
|
|
- (void)setYy_isDecodedForDisplay:(BOOL)isDecodedForDisplay {
|
objc_setAssociatedObject(self, @selector(yy_isDecodedForDisplay), @(isDecodedForDisplay), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
|
}
|
|
- (void)yy_saveToAlbumWithCompletionBlock:(void(^)(NSURL *assetURL, NSError *error))completionBlock {
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
NSData *data = [self _yy_dataRepresentationForSystem:YES];
|
ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
|
[library writeImageDataToSavedPhotosAlbum:data metadata:nil completionBlock:^(NSURL *assetURL, NSError *error){
|
if (!completionBlock) return;
|
if (pthread_main_np()) {
|
completionBlock(assetURL, error);
|
} else {
|
dispatch_async(dispatch_get_main_queue(), ^{
|
completionBlock(assetURL, error);
|
});
|
}
|
}];
|
});
|
}
|
|
- (NSData *)yy_imageDataRepresentation {
|
return [self _yy_dataRepresentationForSystem:NO];
|
}
|
|
/// @param forSystem YES: used for system album (PNG/JPEG/GIF), NO: used for YYImage (PNG/JPEG/GIF/WebP)
|
- (NSData *)_yy_dataRepresentationForSystem:(BOOL)forSystem {
|
NSData *data = nil;
|
if ([self isKindOfClass:[YYImage class]]) {
|
YYImage *image = (id)self;
|
if (image.animatedImageData) {
|
if (forSystem) { // system only support GIF and PNG
|
if (image.animatedImageType == YYImageTypeGIF ||
|
image.animatedImageType == YYImageTypePNG) {
|
data = image.animatedImageData;
|
}
|
} else {
|
data = image.animatedImageData;
|
}
|
}
|
}
|
if (!data) {
|
CGImageRef imageRef = self.CGImage ? (CGImageRef)CFRetain(self.CGImage) : nil;
|
if (imageRef) {
|
CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);
|
CGImageAlphaInfo alphaInfo = CGImageGetAlphaInfo(imageRef) & kCGBitmapAlphaInfoMask;
|
BOOL hasAlpha = NO;
|
if (alphaInfo == kCGImageAlphaPremultipliedLast ||
|
alphaInfo == kCGImageAlphaPremultipliedFirst ||
|
alphaInfo == kCGImageAlphaLast ||
|
alphaInfo == kCGImageAlphaFirst) {
|
hasAlpha = YES;
|
}
|
if (self.imageOrientation != UIImageOrientationUp) {
|
CGImageRef rotated = YYCGImageCreateCopyWithOrientation(imageRef, self.imageOrientation, bitmapInfo | alphaInfo);
|
if (rotated) {
|
CFRelease(imageRef);
|
imageRef = rotated;
|
}
|
}
|
@autoreleasepool {
|
UIImage *newImage = [UIImage imageWithCGImage:imageRef];
|
if (newImage) {
|
if (hasAlpha) {
|
data = UIImagePNGRepresentation([UIImage imageWithCGImage:imageRef]);
|
} else {
|
data = UIImageJPEGRepresentation([UIImage imageWithCGImage:imageRef], 0.9); // same as Apple's example
|
}
|
}
|
}
|
CFRelease(imageRef);
|
}
|
}
|
if (!data) {
|
data = UIImagePNGRepresentation(self);
|
}
|
return data;
|
}
|
|
@end
|
