// // YYImageCoder.m // YYKit // // 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 #import #import #import #import #import #import #import #import #import "YYImage.h" #import "YYKitMacro.h" #ifndef YYIMAGE_WEBP_ENABLED #if __has_include() && __has_include() && \ __has_include() && __has_include() #define YYIMAGE_WEBP_ENABLED 1 #import #import #import #import #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, 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_mutex_init_recursive(&_lock, true); 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.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.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)imageByDecoded { if (self.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.isDecodedForDisplay = YES; return newImage; } - (BOOL)isDecodedForDisplay { if (self.images.count > 1) return YES; NSNumber *num = objc_getAssociatedObject(self, @selector(isDecodedForDisplay)); return [num boolValue]; } - (void)setIsDecodedForDisplay:(BOOL)isDecodedForDisplay { objc_setAssociatedObject(self, @selector(isDecodedForDisplay), @(isDecodedForDisplay), OBJC_ASSOCIATION_RETAIN_NONATOMIC); } - (void)saveToAlbumWithCompletionBlock:(void(^)(NSURL *assetURL, NSError *error))completionBlock { dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ NSData *data = [self _imageDataRepresentationForSystem: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 *)imageDataRepresentation { return [self _imageDataRepresentationForSystem:NO]; } /// @param forSystem YES: used for system album (PNG/JPEG/GIF), NO: used for YYImage (PNG/JPEG/GIF/WebP) - (NSData *)_imageDataRepresentationForSystem:(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