LLVMFuzzerTestOneInput: 118| 3.66k|LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 119| 3.66k| llvmFuzzerTestOneInput(data, size); 120| 3.66k| return 0; 121| 3.66k|} pixel_swizzler_fuzzer.c:llvmFuzzerTestOneInput: 84| 3.66k|llvmFuzzerTestOneInput(const uint8_t* data, size_t size) { 85| | // Make a 64-bit hash out of two 32-bit hashes, each on half of the data. 86| 3.66k| size_t s2 = size / 2; 87| 3.66k| uint32_t hash0 = jenkins_hash_u32(data, s2); 88| 3.66k| uint32_t hash1 = jenkins_hash_u32(data + s2, size - s2); 89| 3.66k| uint64_t hash = (((uint64_t)hash0) << 32) | ((uint64_t)hash1); 90| | 91| | // The ! means that closed will be true for (size == 0). 92| 3.66k| const bool closed = !(1 & popcount32(hash0)); 93| | 94| 3.66k| wuffs_base__io_buffer src = 95| 3.66k| wuffs_base__ptr_u8__reader((uint8_t*)data, size, closed); 96| | 97| 3.66k| const char* msg = fuzz(&src, hash); 98| 3.66k| if (msg) { ------------------ | Branch (98:7): [True: 2.09k, False: 1.57k] ------------------ 99| 2.09k| if (strnlen(msg, 2047) >= 2047) { ------------------ | Branch (99:9): [True: 0, False: 2.09k] ------------------ 100| 0| msg = "fuzzlib: internal error: error message is too long"; 101| 0| } 102| 2.09k| if (closed && strstr(msg, "base: short read")) { ------------------ | Branch (102:9): [True: 1.10k, False: 987] | Branch (102:19): [True: 0, False: 1.10k] ------------------ 103| 0| fprintf(stderr, "short read on a closed io_reader\n"); 104| 0| intentional_segfault(); 105| 2.09k| } else if (strstr(msg, "internal error:")) { ------------------ | Branch (105:16): [True: 0, False: 2.09k] ------------------ 106| | fprintf(stderr, "internal errors shouldn't occur: \"%s\"\n", msg); 107| 0| intentional_segfault(); 108| 0| } 109| 2.09k| } 110| 3.66k| return msg; 111| 3.66k|} pixel_swizzler_fuzzer.c:jenkins_hash_u32: 53| 7.33k|jenkins_hash_u32(const uint8_t* data, size_t size) { 54| 7.33k| uint32_t hash = 0; 55| 7.33k| size_t i = 0; 56| 25.2M| while (i != size) { ------------------ | Branch (56:10): [True: 25.2M, False: 7.33k] ------------------ 57| 25.2M| hash += data[i++]; 58| 25.2M| hash += hash << 10; 59| 25.2M| hash ^= hash >> 6; 60| 25.2M| } 61| 7.33k| hash += hash << 3; 62| 7.33k| hash ^= hash >> 11; 63| 7.33k| hash += hash << 15; 64| 7.33k| return hash; 65| 7.33k|} pixel_swizzler_fuzzer.c:popcount32: 27| 3.66k|popcount32(uint32_t x) { 28| 3.66k| static const uint8_t table[256] = { 29| 3.66k| 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, // 30| 3.66k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 31| 3.66k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 32| 3.66k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 33| 3.66k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 34| 3.66k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 35| 3.66k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 36| 3.66k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 37| 3.66k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 38| 3.66k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 39| 3.66k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 40| 3.66k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 41| 3.66k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 42| 3.66k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 43| 3.66k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 44| 3.66k| 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, // 45| 3.66k| }; 46| 3.66k| return table[0xFF & (x >> 0)] + table[0xFF & (x >> 8)] + 47| 3.66k| table[0xFF & (x >> 16)] + table[0xFF & (x >> 24)]; 48| 3.66k|} round_up_to_pagesize: 97| 3|round_up_to_pagesize(size_t n) { 98| 3| size_t ps = getpagesize(); 99| 3| if (ps <= 0) { ------------------ | Branch (99:7): [True: 0, False: 3] ------------------ 100| 0| return n; 101| 0| } 102| 3| return ((n + (ps - 1)) / ps) * ps; 103| 3|} allocate_guarded_pages: 109| 7|allocate_guarded_pages(uint8_t** ptr_out, size_t len) { 110| 7| void* ptr = 111| 7| mmap(NULL, 2 * len, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); 112| 7| if (ptr == MAP_FAILED) { ------------------ | Branch (112:7): [True: 0, False: 7] ------------------ 113| 0| return "fuzz: internal error: mmap failed"; 114| 0| } 115| 7| if (mprotect(ptr, len, PROT_READ | PROT_WRITE)) { ------------------ | Branch (115:7): [True: 0, False: 7] ------------------ 116| 0| return "fuzz: internal error: mprotect failed"; 117| 0| } 118| 7| *ptr_out = ptr; 119| | return NULL; 120| 7|} fuzz_swizzle_interleaved_from_slice: 126| 3.66k|fuzz_swizzle_interleaved_from_slice(wuffs_base__io_buffer* src, uint64_t hash) { 127| 3.66k| uint8_t dst_palette_array[1024]; 128| 3.66k| uint8_t src_palette_array[1024]; 129| 3.66k| if ((src->meta.wi - src->meta.ri) >= 2048) { ------------------ | Branch (129:7): [True: 244, False: 3.42k] ------------------ 130| 244| memcpy(dst_palette_array, src->data.ptr + src->meta.ri, 1024); 131| 244| src->meta.ri += 1024; 132| 244| memcpy(src_palette_array, src->data.ptr + src->meta.ri, 1024); 133| 244| src->meta.ri += 1024; 134| 3.42k| } else { 135| 3.50M| for (uint32_t i = 0; i < 1024; i++) { ------------------ | Branch (135:26): [True: 3.50M, False: 3.42k] ------------------ 136| 3.50M| dst_palette_array[i] = (uint8_t)i; 137| 3.50M| src_palette_array[i] = (uint8_t)i; 138| 3.50M| } 139| 3.42k| } 140| 3.66k| wuffs_base__slice_u8 dst_palette = 141| 3.66k| wuffs_base__make_slice_u8(&dst_palette_array[0], 1024); 142| 3.66k| wuffs_base__slice_u8 src_palette = 143| 3.66k| wuffs_base__make_slice_u8(&src_palette_array[0], 1024); 144| | 145| 3.66k| size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]); 146| 3.66k| wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( 147| 3.66k| pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); 148| 3.66k| wuffs_base__pixel_format src_pixfmt = wuffs_base__make_pixel_format( 149| 3.66k| pixfmts[(0xFF & (hash >> 8)) % num_pixfmts]); 150| | 151| 3.66k| size_t num_blends = sizeof(blends) / sizeof(blends[0]); 152| 3.66k| wuffs_base__pixel_blend blend = blends[(0xFF & (hash >> 16)) % num_blends]; 153| | 154| 3.66k| size_t dst_len = 0xFF & (hash >> 24); 155| 3.66k| size_t src_len = 0xFF & (hash >> 32); 156| | 157| 3.66k| wuffs_base__pixel_swizzler swizzler; 158| 3.66k| wuffs_base__status status = wuffs_base__pixel_swizzler__prepare( 159| 3.66k| &swizzler, dst_pixfmt, dst_palette, src_pixfmt, src_palette, blend); 160| 3.66k| if (status.repr) { ------------------ | Branch (160:7): [True: 296, False: 3.37k] ------------------ 161| 296| return wuffs_base__status__message(&status); 162| 296| } 163| | 164| 3.37k| static size_t alloc_size = 0; 165| 3.37k| if (alloc_size == 0) { ------------------ | Branch (165:7): [True: 1, False: 3.37k] ------------------ 166| 1| alloc_size = round_up_to_pagesize(0x100); 167| 1| } 168| | 169| 3.37k| static uint8_t* dst_alloc = NULL; 170| 3.37k| if (!dst_alloc) { ------------------ | Branch (170:7): [True: 1, False: 3.37k] ------------------ 171| 1| const char* z = allocate_guarded_pages(&dst_alloc, alloc_size); 172| 1| if (z != NULL) { ------------------ | Branch (172:9): [True: 0, False: 1] ------------------ 173| 0| return z; 174| 0| } 175| 1| } 176| | 177| 3.37k| static uint8_t* src_alloc = NULL; 178| 3.37k| if (!src_alloc) { ------------------ | Branch (178:7): [True: 1, False: 3.37k] ------------------ 179| 1| const char* z = allocate_guarded_pages(&src_alloc, alloc_size); 180| 1| if (z != NULL) { ------------------ | Branch (180:9): [True: 0, False: 1] ------------------ 181| 0| return z; 182| 0| } 183| 1| } 184| | 185| | // Position dst_slice and src_slice so that reading or writing one byte past 186| | // their end will cause a segmentation fault. 187| 3.37k| wuffs_base__slice_u8 dst_slice = 188| 3.37k| wuffs_base__make_slice_u8(dst_alloc + alloc_size - dst_len, dst_len); 189| 3.37k| wuffs_base__slice_u8 src_slice = 190| 3.37k| wuffs_base__make_slice_u8(src_alloc + alloc_size - src_len, src_len); 191| | 192| | // Fill in dst_slice and src_slice. 193| 3.37k| if ((src->meta.wi - src->meta.ri) >= (dst_len + src_len)) { ------------------ | Branch (193:7): [True: 560, False: 2.81k] ------------------ 194| 560| memcpy(dst_slice.ptr, src->data.ptr + src->meta.ri, dst_len); 195| 560| src->meta.ri += dst_len; 196| 560| memcpy(src_slice.ptr, src->data.ptr + src->meta.ri, src_len); 197| 560| src->meta.ri += src_len; 198| 2.81k| } else { 199| 353k| for (size_t i = 0; i < dst_len; i++) { ------------------ | Branch (199:24): [True: 350k, False: 2.81k] ------------------ 200| 350k| dst_slice.ptr[i] = (uint8_t)i; 201| 350k| } 202| 253k| for (size_t i = 0; i < src_len; i++) { ------------------ | Branch (202:24): [True: 250k, False: 2.81k] ------------------ 203| 250k| src_slice.ptr[i] = (uint8_t)i; 204| 250k| } 205| 2.81k| } 206| | 207| | // When manually testing this program, enabling this code should lead to a 208| | // segmentation fault. 209| |#if 0 210| | src_slice.ptr[src_slice.len]++; 211| |#endif 212| | 213| | // Calling etc__swizzle_interleaved_from_slice should not crash, whether for 214| | // reading/writing out of bounds or for other reasons. 215| 3.37k| wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice( 216| 3.37k| &swizzler, dst_slice, dst_palette, src_slice); 217| | 218| | return NULL; 219| 3.37k|} fuzz_swizzle_ycck: 222| 3.66k|fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) { 223| 3.66k| uint8_t dst_palette_array[1024] = {0}; 224| 3.66k| wuffs_base__slice_u8 dst_palette = 225| 3.66k| wuffs_base__make_slice_u8(&dst_palette_array[0], 1024); 226| | 227| 3.66k| size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]); 228| 3.66k| wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( 229| 3.66k| pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); 230| | 231| 3.66k| uint32_t x_min_incl = (63 & (hash >> 8)) + 1; 232| 3.66k| uint32_t x_max_excl = (63 & (hash >> 14)) + 1; 233| 3.66k| uint32_t y_min_incl = (63 & (hash >> 20)) + 1; 234| 3.66k| uint32_t y_max_excl = (63 & (hash >> 26)) + 1; 235| | 236| 3.66k| uint32_t width_in_mcus = (3 & (hash >> 32)) + 1; 237| 3.66k| uint32_t height_in_mcus = (3 & (hash >> 34)) + 1; 238| | 239| 3.66k| uint32_t allow_hv3 = 1 & (hash >> 36); 240| 3.66k| bool is_rgb_or_cmyk = 1 & (hash >> 37); 241| 3.66k| bool triangle_filter_for_2to1 = 1 & (hash >> 38); 242| 3.66k| bool use_4th_component = 1 & (hash >> 39); 243| | 244| 3.66k| if (triangle_filter_for_2to1) { ------------------ | Branch (244:7): [True: 1.46k, False: 2.20k] ------------------ 245| 1.46k| x_min_incl = 0; 246| 1.46k| y_min_incl = 0; 247| 2.20k| } else { 248| 2.20k| if (x_min_incl > x_max_excl) { ------------------ | Branch (248:9): [True: 1.10k, False: 1.09k] ------------------ 249| 1.10k| uint32_t a = x_min_incl; 250| 1.10k| x_min_incl = x_max_excl; 251| 1.10k| x_max_excl = a; 252| 1.10k| } 253| 2.20k| if (y_min_incl > y_max_excl) { ------------------ | Branch (253:9): [True: 1.30k, False: 899] ------------------ 254| 1.30k| uint32_t a = y_min_incl; 255| 1.30k| y_min_incl = y_max_excl; 256| 1.30k| y_max_excl = a; 257| 1.30k| } 258| 2.20k| } 259| | 260| 3.66k| uint32_t possible_hv_values[2][4] = { 261| 3.66k| {1, 1, 2, 4}, 262| 3.66k| {1, 1, 3, 3}, 263| 3.66k| }; 264| 3.66k| uint32_t h0 = possible_hv_values[allow_hv3][3 & (hash >> 28)]; 265| 3.66k| uint32_t h1 = possible_hv_values[allow_hv3][3 & (hash >> 30)]; 266| 3.66k| uint32_t h2 = possible_hv_values[allow_hv3][3 & (hash >> 32)]; 267| 3.66k| uint32_t h3 = 268| 3.66k| use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 34)] : 0; ------------------ | Branch (268:7): [True: 861, False: 2.80k] ------------------ 269| 3.66k| uint32_t v0 = possible_hv_values[allow_hv3][3 & (hash >> 36)]; 270| 3.66k| uint32_t v1 = possible_hv_values[allow_hv3][3 & (hash >> 38)]; 271| 3.66k| uint32_t v2 = possible_hv_values[allow_hv3][3 & (hash >> 40)]; 272| 3.66k| uint32_t v3 = 273| 3.66k| use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 42)] : 0; ------------------ | Branch (273:7): [True: 861, False: 2.80k] ------------------ 274| | 275| 3.66k| uint32_t width0 = 8 * width_in_mcus * h0; 276| 3.66k| uint32_t width1 = 8 * width_in_mcus * h1; 277| 3.66k| uint32_t width2 = 8 * width_in_mcus * h2; 278| 3.66k| uint32_t width3 = 8 * width_in_mcus * h3; 279| 3.66k| uint32_t height0 = 8 * height_in_mcus * v0; 280| 3.66k| uint32_t height1 = 8 * height_in_mcus * v1; 281| 3.66k| uint32_t height2 = 8 * height_in_mcus * v2; 282| 3.66k| uint32_t height3 = 8 * height_in_mcus * v3; 283| | 284| 3.66k| uint32_t hmax = wuffs_base__u32__max( 285| 3.66k| h0, wuffs_base__u32__max(h1, wuffs_base__u32__max(h2, h3))); 286| 3.66k| uint32_t vmax = wuffs_base__u32__max( 287| 3.66k| v0, wuffs_base__u32__max(v1, wuffs_base__u32__max(v2, v3))); 288| 3.66k| x_max_excl = x_min_incl + wuffs_base__u32__min(x_max_excl - x_min_incl, 289| 3.66k| 8 * width_in_mcus * hmax); 290| 3.66k| y_max_excl = y_min_incl + wuffs_base__u32__min(y_max_excl - y_min_incl, 291| 3.66k| 8 * height_in_mcus * vmax); 292| | 293| 3.66k| static size_t dst_alloc_size = 0; 294| 3.66k| if (dst_alloc_size == 0) { ------------------ | Branch (294:7): [True: 1, False: 3.66k] ------------------ 295| 1| dst_alloc_size = round_up_to_pagesize(8 * 64 * 64); 296| 1| } 297| | 298| 3.66k| static uint8_t* dst_alloc = NULL; 299| 3.66k| if (!dst_alloc) { ------------------ | Branch (299:7): [True: 1, False: 3.66k] ------------------ 300| 1| const char* z = allocate_guarded_pages(&dst_alloc, dst_alloc_size); 301| 1| if (z != NULL) { ------------------ | Branch (301:9): [True: 0, False: 1] ------------------ 302| 0| return z; 303| 0| } 304| 1| } 305| | 306| 3.66k| wuffs_base__pixel_buffer dst_pixbuf; 307| 3.66k| wuffs_base__pixel_config dst_pixcfg; 308| 3.66k| wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, x_max_excl, 309| 3.66k| y_max_excl); 310| 3.66k| uint64_t dst_pixbuf_len = wuffs_base__pixel_config__pixbuf_len(&dst_pixcfg); 311| 3.66k| if (dst_pixbuf_len > dst_alloc_size) { ------------------ | Branch (311:7): [True: 0, False: 3.66k] ------------------ 312| 0| return "fuzz: internal error: dst_alloc_size is too small"; 313| 3.66k| } else { 314| 3.66k| wuffs_base__status status = wuffs_base__pixel_buffer__set_from_slice( 315| 3.66k| &dst_pixbuf, &dst_pixcfg, 316| 3.66k| wuffs_base__make_slice_u8(dst_alloc + dst_alloc_size - dst_pixbuf_len, 317| 3.66k| dst_pixbuf_len)); 318| 3.66k| if (status.repr) { ------------------ | Branch (318:9): [True: 0, False: 3.66k] ------------------ 319| 0| return "fuzz: internal error: wuffs_base__pixel_buffer__set_from_slice " 320| 0| "failed"; 321| 0| } 322| 3.66k| } 323| | 324| 3.66k| static size_t src_alloc_size = 0; 325| 3.66k| if (src_alloc_size == 0) { ------------------ | Branch (325:7): [True: 1, False: 3.66k] ------------------ 326| 1| src_alloc_size = round_up_to_pagesize(8 * 4 * 4 * 8 * 4 * 4); 327| 1| } 328| | 329| 3.66k| static uint8_t* src_alloc0 = NULL; 330| 3.66k| static uint8_t* src_alloc1 = NULL; 331| 3.66k| static uint8_t* src_alloc2 = NULL; 332| 3.66k| static uint8_t* src_alloc3 = NULL; 333| 3.66k| if (!src_alloc0) { ------------------ | Branch (333:7): [True: 1, False: 3.66k] ------------------ 334| 1| const char* z = allocate_guarded_pages(&src_alloc0, src_alloc_size); 335| 1| if (z != NULL) { ------------------ | Branch (335:9): [True: 0, False: 1] ------------------ 336| 0| return z; 337| 0| } 338| 1| } 339| 3.66k| if (!src_alloc1) { ------------------ | Branch (339:7): [True: 1, False: 3.66k] ------------------ 340| 1| const char* z = allocate_guarded_pages(&src_alloc1, src_alloc_size); 341| 1| if (z != NULL) { ------------------ | Branch (341:9): [True: 0, False: 1] ------------------ 342| 0| return z; 343| 0| } 344| 1| } 345| 3.66k| if (!src_alloc2) { ------------------ | Branch (345:7): [True: 1, False: 3.66k] ------------------ 346| 1| const char* z = allocate_guarded_pages(&src_alloc2, src_alloc_size); 347| 1| if (z != NULL) { ------------------ | Branch (347:9): [True: 0, False: 1] ------------------ 348| 0| return z; 349| 0| } 350| 1| } 351| 3.66k| if (!src_alloc3) { ------------------ | Branch (351:7): [True: 1, False: 3.66k] ------------------ 352| 1| const char* z = allocate_guarded_pages(&src_alloc3, src_alloc_size); 353| 1| if (z != NULL) { ------------------ | Branch (353:9): [True: 0, False: 1] ------------------ 354| 0| return z; 355| 0| } 356| 1| } 357| | 358| 3.66k| uint32_t src_len0 = width0 * height0; 359| 3.66k| uint32_t src_len1 = width1 * height1; 360| 3.66k| uint32_t src_len2 = width2 * height2; 361| 3.66k| uint32_t src_len3 = width3 * height3; 362| 3.66k| if ((src_len0 > src_alloc_size) || // ------------------ | Branch (362:7): [True: 0, False: 3.66k] ------------------ 363| 3.66k| (src_len1 > src_alloc_size) || // ------------------ | Branch (363:7): [True: 0, False: 3.66k] ------------------ 364| 3.66k| (src_len2 > src_alloc_size) || // ------------------ | Branch (364:7): [True: 0, False: 3.66k] ------------------ 365| 3.66k| (src_len3 > src_alloc_size)) { ------------------ | Branch (365:7): [True: 0, False: 3.66k] ------------------ 366| 0| return "fuzz: internal error: src_alloc_size is too small"; 367| 0| } 368| | 369| 3.66k| uint8_t s0 = 0x90; 370| 3.66k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (370:7): [True: 3.35k, False: 318] ------------------ 371| 3.35k| s0 = src->data.ptr[src->meta.ri++]; 372| 3.35k| } 373| 3.66k| uint8_t s1 = 0x91; 374| 3.66k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (374:7): [True: 3.06k, False: 604] ------------------ 375| 3.06k| s1 = src->data.ptr[src->meta.ri++]; 376| 3.06k| } 377| 3.66k| uint8_t s2 = 0x92; 378| 3.66k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (378:7): [True: 1.86k, False: 1.80k] ------------------ 379| 1.86k| s2 = src->data.ptr[src->meta.ri++]; 380| 1.86k| } 381| 3.66k| uint8_t s3 = 0x93; 382| 3.66k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (382:7): [True: 396, False: 3.27k] ------------------ 383| 396| s3 = src->data.ptr[src->meta.ri++]; 384| 396| } 385| | 386| 3.66k| wuffs_base__slice_u8 src0 = wuffs_base__make_slice_u8( 387| 3.66k| src_alloc0 + src_alloc_size - src_len0, src_len0); 388| 3.66k| memset(src0.ptr, s0, src0.len); 389| 3.66k| wuffs_base__slice_u8 src1 = wuffs_base__make_slice_u8( 390| 3.66k| src_alloc1 + src_alloc_size - src_len1, src_len1); 391| 3.66k| memset(src1.ptr, s1, src1.len); 392| 3.66k| wuffs_base__slice_u8 src2 = wuffs_base__make_slice_u8( 393| 3.66k| src_alloc2 + src_alloc_size - src_len2, src_len2); 394| 3.66k| memset(src2.ptr, s2, src2.len); 395| 3.66k| wuffs_base__slice_u8 src3 = wuffs_base__empty_slice_u8(); 396| 3.66k| if (use_4th_component) { ------------------ | Branch (396:7): [True: 861, False: 2.80k] ------------------ 397| 861| wuffs_base__slice_u8 src3 = wuffs_base__make_slice_u8( 398| 861| src_alloc3 + src_alloc_size - src_len3, src_len3); 399| 861| memset(src3.ptr, s3, src3.len); 400| 861| } 401| | 402| 3.66k| wuffs_base__pixel_swizzler swizzler = {0}; 403| 3.66k| uint8_t scratch_buffer[2048]; 404| 3.66k| wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck( 405| 3.66k| &swizzler, &dst_pixbuf, dst_palette, // 406| 3.66k| x_min_incl, x_max_excl, // 407| 3.66k| y_min_incl, y_max_excl, // 408| 3.66k| src0, src1, src2, src3, // 409| 3.66k| width0, width1, width2, width3, // 410| 3.66k| height0, height1, height2, height3, // 411| 3.66k| width0, width1, width2, width3, // 412| 3.66k| h0, h1, h2, h3, // 413| 3.66k| v0, v1, v2, v3, // 414| 3.66k| is_rgb_or_cmyk, // 415| 3.66k| triangle_filter_for_2to1, // 416| 3.66k| wuffs_base__make_slice_u8(scratch_buffer, sizeof(scratch_buffer))); 417| 3.66k| if (status.repr) { ------------------ | Branch (417:7): [True: 1.85k, False: 1.81k] ------------------ 418| 1.85k| return wuffs_base__status__message(&status); 419| 1.85k| } 420| 1.81k| return NULL; 421| 3.66k|} fuzz: 424| 3.66k|fuzz(wuffs_base__io_buffer* src, uint64_t hash) { 425| 3.66k| const char* s0 = fuzz_swizzle_interleaved_from_slice(src, hash); 426| 3.66k| const char* s1 = fuzz_swizzle_ycck(src, hash); 427| 3.66k| if (s0 && strstr(s0, "internal error:")) { ------------------ | Branch (427:7): [True: 296, False: 3.37k] | Branch (427:13): [True: 0, False: 296] ------------------ 428| 0| return s0; 429| 0| } 430| 3.66k| if (s1 && strstr(s1, "internal error:")) { ------------------ | Branch (430:7): [True: 1.85k, False: 1.81k] | Branch (430:13): [True: 0, False: 1.85k] ------------------ 431| 0| return s1; 432| 0| } 433| 3.66k| return s0 ? s0 : s1; ------------------ | Branch (433:10): [True: 296, False: 3.37k] ------------------ 434| 3.66k|} wuffs_base__pixel_buffer__set_color_u32_at: 24236| 527k| wuffs_base__color_u32_argb_premul color) { 24237| 527k| if (!pb) { ------------------ | Branch (24237:7): [True: 0, False: 527k] ------------------ 24238| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 24239| 0| } 24240| 527k| if ((x >= pb->pixcfg.private_impl.width) || ------------------ | Branch (24240:7): [True: 0, False: 527k] ------------------ 24241| 527k| (y >= pb->pixcfg.private_impl.height)) { ------------------ | Branch (24241:7): [True: 0, False: 527k] ------------------ 24242| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 24243| 0| } 24244| | 24245| 527k| if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (24245:7): [True: 0, False: 527k] ------------------ 24246| | // TODO: support planar formats. 24247| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 24248| 0| } 24249| | 24250| 527k| size_t stride = pb->private_impl.planes[0].stride; 24251| 527k| uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)); 24252| | 24253| 527k| switch (pb->pixcfg.private_impl.pixfmt.repr) { 24254| 16.3k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 16.3k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (24254:5): [True: 16.3k, False: 510k] ------------------ 24255| 28.1k| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 28.1k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (24255:5): [True: 11.8k, False: 515k] ------------------ 24256| 28.1k| wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color); 24257| 28.1k| break; 24258| | 24259| | // Common formats above. Rarer formats below. 24260| | 24261| 69.4k| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 69.4k|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (24261:5): [True: 69.4k, False: 457k] ------------------ 24262| 69.4k| wuffs_base__poke_u8__no_bounds_check( 24263| 69.4k| row + ((size_t)x), 24264| 69.4k| wuffs_base__color_u32_argb_premul__as__color_u8_gray(color)); 24265| 69.4k| break; 24266| 16.9k| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4828| 16.9k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (24266:5): [True: 16.9k, False: 510k] ------------------ 24267| 16.9k| wuffs_base__poke_u16le__no_bounds_check( 24268| 16.9k| row + (2 * ((size_t)x)), 24269| 16.9k| wuffs_base__color_u32_argb_premul__as__color_u16_gray(color)); 24270| 16.9k| break; 24271| 8.63k| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4829| 8.63k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (24271:5): [True: 8.63k, False: 518k] ------------------ 24272| 8.63k| wuffs_base__poke_u16be__no_bounds_check( 24273| 8.63k| row + (2 * ((size_t)x)), 24274| 8.63k| wuffs_base__color_u32_argb_premul__as__color_u16_gray(color)); 24275| 8.63k| break; 24276| 20.7k| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4830| 20.7k|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (24276:5): [True: 20.7k, False: 506k] ------------------ 24277| 20.7k| wuffs_base__poke_u16le__no_bounds_check( 24278| 20.7k| row + (2 * ((size_t)x)), 24279| 20.7k| wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul( 24280| 20.7k| color)); 24281| 20.7k| break; 24282| | 24283| 36.4k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4842| 36.4k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (24283:5): [True: 36.4k, False: 490k] ------------------ 24284| 36.4k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4843| 36.4k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (24284:5): [True: 0, False: 527k] ------------------ 24285| 50.6k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4844| 50.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (24285:5): [True: 14.2k, False: 512k] ------------------ 24286| 50.6k| wuffs_base__poke_u8__no_bounds_check( 24287| 50.6k| row + ((size_t)x), wuffs_base__pixel_palette__closest_element( 24288| 50.6k| wuffs_base__pixel_buffer__palette(pb), 24289| 50.6k| pb->pixcfg.private_impl.pixfmt, color)); 24290| 50.6k| break; 24291| | 24292| 59.3k| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 59.3k|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (24292:5): [True: 59.3k, False: 467k] ------------------ 24293| 59.3k| wuffs_base__poke_u16le__no_bounds_check( 24294| 59.3k| row + (2 * ((size_t)x)), 24295| 59.3k| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color)); 24296| 59.3k| break; 24297| 65.9k| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 65.9k|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (24297:5): [True: 65.9k, False: 461k] ------------------ 24298| 65.9k| wuffs_base__poke_u24le__no_bounds_check(row + (3 * ((size_t)x)), color); 24299| 65.9k| break; 24300| 19.4k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 19.4k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (24300:5): [True: 19.4k, False: 507k] ------------------ 24301| 19.4k| wuffs_base__poke_u32le__no_bounds_check( 24302| 19.4k| row + (4 * ((size_t)x)), 24303| 19.4k| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 24304| 19.4k| color)); 24305| 19.4k| break; 24306| 93.6k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 93.6k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (24306:5): [True: 93.6k, False: 433k] ------------------ 24307| 93.6k| wuffs_base__poke_u64le__no_bounds_check( 24308| 93.6k| row + (8 * ((size_t)x)), 24309| 93.6k| wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul( 24310| 93.6k| color)); 24311| 93.6k| break; 24312| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (24312:5): [True: 0, False: 527k] ------------------ 24313| 0| wuffs_base__poke_u64le__no_bounds_check( 24314| 0| row + (8 * ((size_t)x)), wuffs_base__color_u32__as__color_u64(color)); 24315| 0| break; 24316| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (24316:5): [True: 0, False: 527k] ------------------ 24317| 0| wuffs_base__poke_u32le__no_bounds_check( 24318| 0| row + (4 * ((size_t)x)), (color >> 31) ? (color | 0xFF000000) : 0); ------------------ | Branch (24318:36): [True: 0, False: 0] ------------------ 24319| 0| break; 24320| | 24321| 54.8k| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 54.8k|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (24321:5): [True: 54.8k, False: 472k] ------------------ 24322| 54.8k| wuffs_base__poke_u24le__no_bounds_check( 24323| 54.8k| row + (3 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color)); 24324| 54.8k| break; 24325| 17.9k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 17.9k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (24325:5): [True: 17.9k, False: 509k] ------------------ 24326| 17.9k| wuffs_base__poke_u32le__no_bounds_check( 24327| 17.9k| row + (4 * ((size_t)x)), 24328| 17.9k| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 24329| 17.9k| wuffs_base__color_swap_u32_argb_abgr(color))); 24330| 17.9k| break; 24331| 21.1k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 21.1k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (24331:5): [True: 21.1k, False: 505k] ------------------ 24332| 21.1k| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 21.1k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (24332:5): [True: 0, False: 527k] ------------------ 24333| 21.1k| wuffs_base__poke_u32le__no_bounds_check( 24334| 21.1k| row + (4 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color)); 24335| 21.1k| break; 24336| | 24337| 0| default: ------------------ | Branch (24337:5): [True: 0, False: 527k] ------------------ 24338| | // TODO: support more formats. 24339| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 24340| 527k| } 24341| | 24342| 527k| return wuffs_base__make_status(NULL); 24343| 527k|} wuffs_base__pixel_palette__closest_element: 24646| 50.6k| wuffs_base__color_u32_argb_premul c) { 24647| 50.6k| size_t n = palette_slice.len / 4; 24648| 50.6k| if (n > (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 50.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ | Branch (24648:7): [True: 0, False: 50.6k] ------------------ 24649| 0| n = (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4); ------------------ | | 4784| 0|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 24650| 0| } 24651| 50.6k| size_t best_index = 0; 24652| 50.6k| uint64_t best_score = 0xFFFFFFFFFFFFFFFF; 24653| | 24654| | // Work in 16-bit color. 24655| 50.6k| uint32_t ca = 0x101 * (0xFF & (c >> 24)); 24656| 50.6k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 24657| 50.6k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 24658| 50.6k| uint32_t cb = 0x101 * (0xFF & (c >> 0)); 24659| | 24660| 50.6k| switch (palette_format.repr) { ------------------ | Branch (24660:11): [True: 50.6k, False: 0] ------------------ 24661| 36.4k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4842| 36.4k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (24661:5): [True: 36.4k, False: 14.2k] ------------------ 24662| 36.4k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4843| 36.4k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (24662:5): [True: 0, False: 50.6k] ------------------ 24663| 50.6k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: { ------------------ | | 4844| 50.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (24663:5): [True: 14.2k, False: 36.4k] ------------------ 24664| 50.6k| bool nonpremul = palette_format.repr == 24665| 50.6k| WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL; ------------------ | | 4842| 50.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ 24666| | 24667| 50.6k| size_t i; 24668| 13.0M| for (i = 0; i < n; i++) { ------------------ | Branch (24668:19): [True: 12.9M, False: 50.6k] ------------------ 24669| | // Work in 16-bit color. 24670| 12.9M| uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0])); 24671| 12.9M| uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1])); 24672| 12.9M| uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2])); 24673| 12.9M| uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3])); 24674| | 24675| | // Convert to premultiplied alpha. 24676| 12.9M| if (nonpremul && (pa != 0xFFFF)) { ------------------ | Branch (24676:13): [True: 9.32M, False: 3.63M] | Branch (24676:26): [True: 5.58M, False: 3.74M] ------------------ 24677| 5.58M| pb = (pb * pa) / 0xFFFF; 24678| 5.58M| pg = (pg * pa) / 0xFFFF; 24679| 5.58M| pr = (pr * pa) / 0xFFFF; 24680| 5.58M| } 24681| | 24682| | // These deltas are conceptually int32_t (signed) but after squaring, 24683| | // it's equivalent to work in uint32_t (unsigned). 24684| 12.9M| pb -= cb; 24685| 12.9M| pg -= cg; 24686| 12.9M| pr -= cr; 24687| 12.9M| pa -= ca; 24688| 12.9M| uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) + 24689| 12.9M| ((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa)); 24690| 12.9M| if (best_score > score) { ------------------ | Branch (24690:13): [True: 120k, False: 12.8M] ------------------ 24691| 120k| best_score = score; 24692| 120k| best_index = i; 24693| 120k| } 24694| 12.9M| } 24695| 50.6k| break; 24696| 36.4k| } 24697| 50.6k| } 24698| | 24699| 50.6k| return (uint8_t)best_index; 24700| 50.6k|} wuffs_base__pixel_swizzler__prepare: 31880| 3.66k| wuffs_base__pixel_blend blend) { 31881| 3.66k| if (!p) { ------------------ | Branch (31881:7): [True: 0, False: 3.66k] ------------------ 31882| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 31883| 0| } 31884| 3.66k| p->private_impl.func = NULL; 31885| 3.66k| p->private_impl.transparent_black_func = NULL; 31886| 3.66k| p->private_impl.dst_pixfmt_bytes_per_pixel = 0; 31887| 3.66k| p->private_impl.src_pixfmt_bytes_per_pixel = 0; 31888| | 31889| | // ---- 31890| | 31891| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 31892| | switch (dst_pixfmt.repr) { 31893| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y) 31894| | case WUFFS_BASE__PIXEL_FORMAT__Y: 31895| | break; 31896| |#endif 31897| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_YA_NONPREMUL) 31898| | case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: 31899| | break; 31900| |#endif 31901| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565) 31902| | case WUFFS_BASE__PIXEL_FORMAT__BGR_565: 31903| | break; 31904| |#endif 31905| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR) 31906| | case WUFFS_BASE__PIXEL_FORMAT__BGR: 31907| | break; 31908| |#endif 31909| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL) 31910| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: 31911| | break; 31912| |#endif 31913| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL_4X16LE) 31914| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: 31915| | break; 31916| |#endif 31917| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_PREMUL) 31918| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: 31919| | break; 31920| |#endif 31921| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGB) 31922| | case WUFFS_BASE__PIXEL_FORMAT__RGB: 31923| | break; 31924| |#endif 31925| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_NONPREMUL) 31926| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: 31927| | break; 31928| |#endif 31929| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_PREMUL) 31930| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: 31931| | break; 31932| |#endif 31933| | default: 31934| | return wuffs_base__make_status( 31935| | wuffs_base__error__disabled_by_wuffs_config_dst_pixel_format_enable_allowlist); 31936| | } 31937| |#endif // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 31938| | 31939| | // ---- 31940| | 31941| 3.66k| wuffs_base__pixel_swizzler__func func = NULL; 31942| 3.66k| wuffs_base__pixel_swizzler__transparent_black_func transparent_black_func = 31943| 3.66k| NULL; 31944| | 31945| 3.66k| uint32_t dst_pixfmt_bits_per_pixel = 31946| 3.66k| wuffs_base__pixel_format__bits_per_pixel(&dst_pixfmt); 31947| 3.66k| if ((dst_pixfmt_bits_per_pixel == 0) || ------------------ | Branch (31947:7): [True: 0, False: 3.66k] ------------------ 31948| 3.66k| ((dst_pixfmt_bits_per_pixel & 7) != 0)) { ------------------ | Branch (31948:7): [True: 0, False: 3.66k] ------------------ 31949| 0| return wuffs_base__make_status( 31950| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 31951| 0| } 31952| | 31953| 3.66k| uint32_t src_pixfmt_bits_per_pixel = 31954| 3.66k| wuffs_base__pixel_format__bits_per_pixel(&src_pixfmt); 31955| 3.66k| if ((src_pixfmt_bits_per_pixel == 0) || ------------------ | Branch (31955:7): [True: 0, False: 3.66k] ------------------ 31956| 3.66k| ((src_pixfmt_bits_per_pixel & 7) != 0)) { ------------------ | Branch (31956:7): [True: 0, False: 3.66k] ------------------ 31957| 0| return wuffs_base__make_status( 31958| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 31959| 0| } 31960| | 31961| | // TODO: support many more formats. 31962| | 31963| 3.66k| switch (blend) { ------------------ | Branch (31963:11): [True: 3.66k, False: 0] ------------------ 31964| 1.61k| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 1.61k|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31964:5): [True: 1.61k, False: 2.05k] ------------------ 31965| 1.61k| transparent_black_func = 31966| 1.61k| wuffs_private_impl__swizzle_transparent_black_src; 31967| 1.61k| break; 31968| | 31969| 2.05k| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 2.05k|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31969:5): [True: 2.05k, False: 1.61k] ------------------ 31970| 2.05k| transparent_black_func = 31971| 2.05k| wuffs_private_impl__swizzle_transparent_black_src_over; 31972| 2.05k| break; 31973| 3.66k| } 31974| | 31975| 3.66k| switch (src_pixfmt.repr) { ------------------ | Branch (31975:11): [True: 3.66k, False: 0] ------------------ 31976| 140| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 140|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31976:5): [True: 140, False: 3.52k] ------------------ 31977| 140| func = wuffs_private_impl__pixel_swizzler__prepare__y( 31978| 140| p, dst_pixfmt, dst_palette, src_palette, blend); 31979| 140| break; 31980| | 31981| 130| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4829| 130|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (31981:5): [True: 130, False: 3.53k] ------------------ 31982| 130| func = wuffs_private_impl__pixel_swizzler__prepare__y_16be( 31983| 130| p, dst_pixfmt, dst_palette, src_palette, blend); 31984| 130| break; 31985| | 31986| 160| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4828| 160|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (31986:5): [True: 160, False: 3.50k] ------------------ 31987| 160| func = wuffs_private_impl__pixel_swizzler__prepare__y_16le( 31988| 160| p, dst_pixfmt, dst_palette, src_palette, blend); 31989| 160| break; 31990| | 31991| 304| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4830| 304|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (31991:5): [True: 304, False: 3.36k] ------------------ 31992| 304| func = wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul( 31993| 304| p, dst_pixfmt, dst_palette, src_palette, blend); 31994| 304| break; 31995| | 31996| 238| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4842| 238|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (31996:5): [True: 238, False: 3.43k] ------------------ 31997| 238| func = 31998| 238| wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul( 31999| 238| p, dst_pixfmt, dst_palette, src_palette, blend); 32000| 238| break; 32001| | 32002| 387| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4844| 387|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (32002:5): [True: 387, False: 3.28k] ------------------ 32003| 387| func = wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary( 32004| 387| p, dst_pixfmt, dst_palette, src_palette, blend); 32005| 387| break; 32006| | 32007| 124| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 124|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32007:5): [True: 124, False: 3.54k] ------------------ 32008| 124| func = wuffs_private_impl__pixel_swizzler__prepare__bgr_565( 32009| 124| p, dst_pixfmt, dst_palette, src_palette, blend); 32010| 124| break; 32011| | 32012| 149| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 149|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32012:5): [True: 149, False: 3.51k] ------------------ 32013| 149| func = wuffs_private_impl__pixel_swizzler__prepare__bgr( 32014| 149| p, dst_pixfmt, dst_palette, src_palette, blend); 32015| 149| break; 32016| | 32017| 250| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 250|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32017:5): [True: 250, False: 3.41k] ------------------ 32018| 250| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul( 32019| 250| p, dst_pixfmt, dst_palette, src_palette, blend); 32020| 250| break; 32021| | 32022| 313| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 313|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32022:5): [True: 313, False: 3.35k] ------------------ 32023| 313| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le( 32024| 313| p, dst_pixfmt, dst_palette, src_palette, blend); 32025| 313| break; 32026| | 32027| 286| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 286|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32027:5): [True: 286, False: 3.38k] ------------------ 32028| 286| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul( 32029| 286| p, dst_pixfmt, dst_palette, src_palette, blend); 32030| 286| break; 32031| | 32032| 434| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 434|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (32032:5): [True: 434, False: 3.23k] ------------------ 32033| 434| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le( 32034| 434| p, dst_pixfmt, dst_palette, src_palette, blend); 32035| 434| break; 32036| | 32037| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32037:5): [True: 0, False: 3.66k] ------------------ 32038| 0| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( 32039| 0| p, dst_pixfmt, dst_palette, src_palette, blend); 32040| 0| break; 32041| | 32042| 141| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 141|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32042:5): [True: 141, False: 3.52k] ------------------ 32043| 141| func = wuffs_private_impl__pixel_swizzler__prepare__bgrx( 32044| 141| p, dst_pixfmt, dst_palette, src_palette, blend); 32045| 141| break; 32046| | 32047| 115| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 115|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32047:5): [True: 115, False: 3.55k] ------------------ 32048| 115| func = wuffs_private_impl__pixel_swizzler__prepare__rgb( 32049| 115| p, dst_pixfmt, dst_palette, src_palette, blend); 32050| 115| break; 32051| | 32052| 230| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 230|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32052:5): [True: 230, False: 3.43k] ------------------ 32053| 230| func = wuffs_private_impl__pixel_swizzler__prepare__rgba_nonpremul( 32054| 230| p, dst_pixfmt, dst_palette, src_palette, blend); 32055| 230| break; 32056| | 32057| 267| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 267|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32057:5): [True: 267, False: 3.40k] ------------------ 32058| 267| func = wuffs_private_impl__pixel_swizzler__prepare__rgba_premul( 32059| 267| p, dst_pixfmt, dst_palette, src_palette, blend); 32060| 267| break; 32061| 3.66k| } 32062| | 32063| 3.66k| p->private_impl.func = func; 32064| 3.66k| p->private_impl.transparent_black_func = transparent_black_func; 32065| 3.66k| p->private_impl.dst_pixfmt_bytes_per_pixel = dst_pixfmt_bits_per_pixel / 8; 32066| 3.66k| p->private_impl.src_pixfmt_bytes_per_pixel = src_pixfmt_bits_per_pixel / 8; 32067| 3.66k| return wuffs_base__make_status( 32068| 3.66k| func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_option); ------------------ | Branch (32068:7): [True: 3.37k, False: 296] ------------------ 32069| 3.66k|} wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice: 32118| 3.37k| wuffs_base__slice_u8 src) { 32119| 3.37k| if (p && p->private_impl.func) { ------------------ | Branch (32119:7): [True: 3.37k, False: 0] | Branch (32119:12): [True: 3.37k, False: 0] ------------------ 32120| 3.37k| return (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr, 32121| 3.37k| dst_palette.len, src.ptr, src.len); 32122| 3.37k| } 32123| 0| return 0; 32124| 3.37k|} wuffs_base__pixel_swizzler__swizzle_ycck: 33358| 3.66k| wuffs_base__slice_u8 scratch_buffer_2k) { 33359| 3.66k| if (!p) { ------------------ | Branch (33359:7): [True: 0, False: 3.66k] ------------------ 33360| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 33361| 3.66k| } else if (!dst || // ------------------ | Branch (33361:14): [True: 0, False: 3.66k] ------------------ 33362| 3.66k| (x_min_incl > x_max_excl) || // ------------------ | Branch (33362:14): [True: 0, False: 3.66k] ------------------ 33363| 3.66k| (x_max_excl > 0xFFFFu) || // ------------------ | Branch (33363:14): [True: 0, False: 3.66k] ------------------ 33364| 3.66k| (y_min_incl > y_max_excl) || // ------------------ | Branch (33364:14): [True: 0, False: 3.66k] ------------------ 33365| 3.66k| (y_max_excl > 0xFFFFu) || // ------------------ | Branch (33365:14): [True: 0, False: 3.66k] ------------------ 33366| 3.66k| (4u <= ((unsigned int)h0 - 1u)) || // ------------------ | Branch (33366:14): [True: 0, False: 3.66k] ------------------ 33367| 3.66k| (4u <= ((unsigned int)h1 - 1u)) || // ------------------ | Branch (33367:14): [True: 0, False: 3.66k] ------------------ 33368| 3.66k| (4u <= ((unsigned int)h2 - 1u)) || // ------------------ | Branch (33368:14): [True: 0, False: 3.66k] ------------------ 33369| 3.66k| (4u <= ((unsigned int)v0 - 1u)) || // ------------------ | Branch (33369:14): [True: 0, False: 3.66k] ------------------ 33370| 3.66k| (4u <= ((unsigned int)v1 - 1u)) || // ------------------ | Branch (33370:14): [True: 0, False: 3.66k] ------------------ 33371| 3.66k| (4u <= ((unsigned int)v2 - 1u)) || // ------------------ | Branch (33371:14): [True: 0, False: 3.66k] ------------------ 33372| 3.66k| (triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) || ------------------ | Branch (33372:15): [True: 1.46k, False: 2.20k] | Branch (33372:43): [True: 0, False: 1.46k] ------------------ 33373| 3.66k| (scratch_buffer_2k.len < 2048u)) { ------------------ | Branch (33373:14): [True: 0, False: 3.66k] ------------------ 33374| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 33375| 0| } 33376| 3.66k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (33376:7): [True: 861, False: 2.80k] | Branch (33376:21): [True: 0, False: 2.80k] ------------------ 33377| 861| if ((4u <= ((unsigned int)h3 - 1u)) || // ------------------ | Branch (33377:9): [True: 0, False: 861] ------------------ 33378| 861| (4u <= ((unsigned int)v3 - 1u))) { ------------------ | Branch (33378:9): [True: 0, False: 861] ------------------ 33379| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 33380| 0| } 33381| 861| } 33382| | 33383| 3.66k| uint32_t max_incl_h = wuffs_private_impl__u32__max_of_4(h0, h1, h2, h3); 33384| 3.66k| uint32_t max_incl_v = wuffs_private_impl__u32__max_of_4(v0, v1, v2, v3); 33385| | 33386| | // Calculate the inverse h and v ratios. 33387| | // 33388| | // It also canonicalizes (h=2 and max_incl_h=4) as equivalent to (h=1 and 33389| | // max_incl_h=2). In both cases, the inv_h value is 2. 33390| 3.66k| uint32_t inv_h0 = max_incl_h / h0; 33391| 3.66k| uint32_t inv_h1 = max_incl_h / h1; 33392| 3.66k| uint32_t inv_h2 = max_incl_h / h2; 33393| 3.66k| uint32_t inv_h3 = h3 ? (max_incl_h / h3) : 0u; ------------------ | Branch (33393:21): [True: 861, False: 2.80k] ------------------ 33394| 3.66k| uint32_t inv_v0 = max_incl_v / v0; 33395| 3.66k| uint32_t inv_v1 = max_incl_v / v1; 33396| 3.66k| uint32_t inv_v2 = max_incl_v / v2; 33397| 3.66k| uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; ------------------ | Branch (33397:21): [True: 861, False: 2.80k] ------------------ 33398| | 33399| 3.66k| if (x_min_incl != 0) { ------------------ | Branch (33399:7): [True: 2.20k, False: 1.46k] ------------------ 33400| 2.20k| if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) || ------------------ | Branch (33400:9): [True: 445, False: 1.75k] | Branch (33400:34): [True: 244, False: 1.51k] ------------------ 33401| 1.51k| (x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) { ------------------ | Branch (33401:9): [True: 135, False: 1.37k] | Branch (33401:35): [True: 178, False: 1.20k] | Branch (33401:45): [True: 14, False: 164] ------------------ 33402| 838| return wuffs_base__make_status(wuffs_base__error__bad_argument); 33403| 838| } 33404| 2.20k| } 33405| 2.83k| if (y_min_incl != 0) { ------------------ | Branch (33405:7): [True: 1.36k, False: 1.46k] ------------------ 33406| 1.36k| if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) || ------------------ | Branch (33406:9): [True: 287, False: 1.07k] | Branch (33406:34): [True: 99, False: 978] ------------------ 33407| 978| (y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) { ------------------ | Branch (33407:9): [True: 29, False: 949] | Branch (33407:35): [True: 77, False: 872] | Branch (33407:45): [True: 15, False: 62] ------------------ 33408| 430| return wuffs_base__make_status(wuffs_base__error__bad_argument); 33409| 430| } 33410| 1.36k| } 33411| | 33412| 2.40k| uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u; 33413| 2.40k| if (inv_h0 == 2) { ------------------ | Branch (33413:7): [True: 338, False: 2.06k] ------------------ 33414| 338| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0); 33415| 338| } 33416| 2.40k| if (inv_h1 == 2) { ------------------ | Branch (33416:7): [True: 334, False: 2.06k] ------------------ 33417| 334| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1); 33418| 334| } 33419| 2.40k| if (inv_h2 == 2) { ------------------ | Branch (33419:7): [True: 363, False: 2.03k] ------------------ 33420| 363| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2); 33421| 363| } 33422| 2.40k| if (inv_h3 == 2) { ------------------ | Branch (33422:7): [True: 62, False: 2.33k] ------------------ 33423| 62| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3); 33424| 62| } 33425| | 33426| 2.40k| uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u; 33427| 2.40k| if (inv_v0 == 2) { ------------------ | Branch (33427:7): [True: 361, False: 2.03k] ------------------ 33428| 361| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0); 33429| 361| } 33430| 2.40k| if (inv_v1 == 2) { ------------------ | Branch (33430:7): [True: 386, False: 2.01k] ------------------ 33431| 386| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1); 33432| 386| } 33433| 2.40k| if (inv_v2 == 2) { ------------------ | Branch (33433:7): [True: 231, False: 2.16k] ------------------ 33434| 231| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2); 33435| 231| } 33436| 2.40k| if (inv_v3 == 2) { ------------------ | Branch (33436:7): [True: 66, False: 2.33k] ------------------ 33437| 66| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3); 33438| 66| } 33439| | 33440| 2.40k| x_max_excl = wuffs_base__u32__min( // 33441| 2.40k| wuffs_base__pixel_config__width(&dst->pixcfg), // 33442| 2.40k| x_min_incl + wuffs_private_impl__u32__min_of_5( // 33443| 2.40k| x_max_excl - x_min_incl, // 33444| 2.40k| width0 * inv_h0, // 33445| 2.40k| width1 * inv_h1, // 33446| 2.40k| width2 * inv_h2, // 33447| 2.40k| inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF)); ------------------ | Branch (33447:24): [True: 563, False: 1.83k] ------------------ 33448| 2.40k| y_max_excl = wuffs_base__u32__min( // 33449| 2.40k| wuffs_base__pixel_config__height(&dst->pixcfg), // 33450| 2.40k| y_min_incl + wuffs_private_impl__u32__min_of_5( // 33451| 2.40k| y_max_excl - y_min_incl, // 33452| 2.40k| height0 * inv_v0, // 33453| 2.40k| height1 * inv_v1, // 33454| 2.40k| height2 * inv_v2, // 33455| 2.40k| inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF)); ------------------ | Branch (33455:24): [True: 563, False: 1.83k] ------------------ 33456| | 33457| 2.40k| if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) { ------------------ | Branch (33457:7): [True: 15, False: 2.38k] | Branch (33457:37): [True: 16, False: 2.36k] ------------------ 33458| 31| return wuffs_base__make_status(NULL); 33459| 31| } 33460| 2.36k| uint32_t width = x_max_excl - x_min_incl; 33461| 2.36k| uint32_t height = y_max_excl - y_min_incl; 33462| | 33463| 2.36k| if (((h0 * inv_h0) != max_incl_h) || // ------------------ | Branch (33463:7): [True: 0, False: 2.36k] ------------------ 33464| 2.36k| ((h1 * inv_h1) != max_incl_h) || // ------------------ | Branch (33464:7): [True: 0, False: 2.36k] ------------------ 33465| 2.36k| ((h2 * inv_h2) != max_incl_h) || // ------------------ | Branch (33465:7): [True: 0, False: 2.36k] ------------------ 33466| 2.36k| ((v0 * inv_v0) != max_incl_v) || // ------------------ | Branch (33466:7): [True: 0, False: 2.36k] ------------------ 33467| 2.36k| ((v1 * inv_v1) != max_incl_v) || // ------------------ | Branch (33467:7): [True: 0, False: 2.36k] ------------------ 33468| 2.36k| ((v2 * inv_v2) != max_incl_v) || // ------------------ | Branch (33468:7): [True: 0, False: 2.36k] ------------------ 33469| 2.36k| (src0.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (33469:7): [True: 0, False: 2.36k] ------------------ 33470| 2.36k| width, height, stride0, inv_h0, inv_v0)) || 33471| 2.36k| (src1.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (33471:7): [True: 0, False: 2.36k] ------------------ 33472| 2.36k| width, height, stride1, inv_h1, inv_v1)) || 33473| 2.36k| (src2.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (33473:7): [True: 0, False: 2.36k] ------------------ 33474| 2.36k| width, height, stride2, inv_h2, inv_v2))) { 33475| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 33476| 0| } 33477| 2.36k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (33477:7): [True: 560, False: 1.80k] | Branch (33477:21): [True: 0, False: 1.80k] ------------------ 33478| 560| if (((h3 * inv_h3) != max_incl_h) || // ------------------ | Branch (33478:9): [True: 0, False: 560] ------------------ 33479| 560| ((v3 * inv_v3) != max_incl_v) || // ------------------ | Branch (33479:9): [True: 0, False: 560] ------------------ 33480| 560| (src3.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (33480:9): [True: 560, False: 0] ------------------ 33481| 560| width, height, stride3, inv_h3, inv_v3))) { 33482| 560| return wuffs_base__make_status(wuffs_base__error__bad_argument); 33483| 560| } 33484| 560| } 33485| | 33486| 1.80k| if (wuffs_base__pixel_format__is_planar(&dst->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (33486:7): [True: 0, False: 1.80k] ------------------ 33487| | // TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO. 33488| 0| return wuffs_base__make_status( 33489| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 33490| 0| } 33491| | 33492| | // ---- 33493| | 33494| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 33495| | switch (dst->pixcfg.private_impl.pixfmt.repr) { 33496| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y) 33497| | case WUFFS_BASE__PIXEL_FORMAT__Y: 33498| | break; 33499| |#endif 33500| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_YA_NONPREMUL) 33501| | case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: 33502| | break; 33503| |#endif 33504| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565) 33505| | case WUFFS_BASE__PIXEL_FORMAT__BGR_565: 33506| | break; 33507| |#endif 33508| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR) 33509| | case WUFFS_BASE__PIXEL_FORMAT__BGR: 33510| | break; 33511| |#endif 33512| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL) 33513| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: 33514| | break; 33515| |#endif 33516| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL_4X16LE) 33517| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: 33518| | break; 33519| |#endif 33520| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_PREMUL) 33521| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: 33522| | break; 33523| |#endif 33524| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGB) 33525| | case WUFFS_BASE__PIXEL_FORMAT__RGB: 33526| | break; 33527| |#endif 33528| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_NONPREMUL) 33529| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: 33530| | break; 33531| |#endif 33532| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_PREMUL) 33533| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: 33534| | break; 33535| |#endif 33536| | default: 33537| | return wuffs_base__make_status( 33538| | wuffs_base__error__disabled_by_wuffs_config_dst_pixel_format_enable_allowlist); 33539| | } 33540| |#else // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 33541| 1.80k| switch (dst->pixcfg.private_impl.pixfmt.repr) { 33542| 165| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 165|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (33542:5): [True: 165, False: 1.64k] ------------------ 33543| 202| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4828| 202|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (33543:5): [True: 37, False: 1.77k] ------------------ 33544| 231| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4829| 231|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (33544:5): [True: 29, False: 1.78k] ------------------ 33545| 285| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4830| 285|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (33545:5): [True: 54, False: 1.75k] ------------------ 33546| 353| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4842| 353|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (33546:5): [True: 68, False: 1.74k] ------------------ 33547| 353| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4843| 353|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (33547:5): [True: 0, False: 1.80k] ------------------ 33548| 395| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4844| 395|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (33548:5): [True: 42, False: 1.76k] ------------------ 33549| 543| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 543|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (33549:5): [True: 148, False: 1.66k] ------------------ 33550| 663| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 663|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (33550:5): [True: 120, False: 1.68k] ------------------ 33551| 858| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 858|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (33551:5): [True: 195, False: 1.61k] ------------------ 33552| 1.08k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 1.08k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (33552:5): [True: 222, False: 1.58k] ------------------ 33553| 1.21k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 1.21k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (33553:5): [True: 131, False: 1.67k] ------------------ 33554| 1.31k| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 1.31k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (33554:5): [True: 99, False: 1.71k] ------------------ 33555| 1.42k| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 1.42k|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (33555:5): [True: 115, False: 1.69k] ------------------ 33556| 1.63k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 1.63k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (33556:5): [True: 208, False: 1.60k] ------------------ 33557| 1.78k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 1.78k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (33557:5): [True: 149, False: 1.66k] ------------------ 33558| 1.78k| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 1.78k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (33558:5): [True: 0, False: 1.80k] ------------------ 33559| 1.78k| break; 33560| | 33561| 27| default: ------------------ | Branch (33561:5): [True: 27, False: 1.78k] ------------------ 33562| | // TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO. 33563| 27| return wuffs_base__make_status( 33564| 27| wuffs_base__error__unsupported_pixel_swizzler_option); 33565| 1.80k| } 33566| 1.78k|#endif // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 33567| | 33568| | // ---- 33569| | 33570| 1.78k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; 33571| | 33572| 1.78k| if (is_rgb_or_cmyk) { ------------------ | Branch (33572:7): [True: 429, False: 1.35k] ------------------ 33573| 429| conv3func = &wuffs_private_impl__swizzle_rgb__convert_3_general; 33574| 1.35k| } else { 33575| 1.35k| switch (dst->pixcfg.private_impl.pixfmt.repr) { 33576| 163| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 163|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (33576:7): [True: 163, False: 1.19k] ------------------ 33577| 262| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 262|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (33577:7): [True: 99, False: 1.25k] ------------------ 33578| 345| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 345|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (33578:7): [True: 83, False: 1.27k] ------------------ 33579| 345|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 33580| 345| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (33580:13): [True: 345, False: 0] ------------------ 33581| 345| conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2; 33582| 345| break; 33583| 345| } 33584| 0|#endif 33585| 0| conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_bgrx; 33586| 0| break; 33587| 178| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 178|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (33587:7): [True: 178, False: 1.17k] ------------------ 33588| 292| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 292|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (33588:7): [True: 114, False: 1.23k] ------------------ 33589| 292| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 292|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (33589:7): [True: 0, False: 1.35k] ------------------ 33590| 292|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 33591| 292| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (33591:13): [True: 292, False: 0] ------------------ 33592| 292| conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_rgbx_x86_avx2; 33593| 292| break; 33594| 292| } 33595| 0|#endif 33596| 0| conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_rgbx; 33597| 0| break; 33598| 716| default: ------------------ | Branch (33598:7): [True: 716, False: 637] ------------------ 33599| 716| conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_general; 33600| 716| break; 33601| 1.35k| } 33602| 1.35k| } 33603| | 33604| 1.78k| void (*func3)(wuffs_base__pixel_buffer * dst, // 33605| 1.78k| uint32_t x_min_incl, // 33606| 1.78k| uint32_t x_max_excl, // 33607| 1.78k| uint32_t y_min_incl, // 33608| 1.78k| uint32_t y_max_excl, // 33609| 1.78k| const uint8_t* src_ptr0, // 33610| 1.78k| const uint8_t* src_ptr1, // 33611| 1.78k| const uint8_t* src_ptr2, // 33612| 1.78k| uint32_t stride0, // 33613| 1.78k| uint32_t stride1, // 33614| 1.78k| uint32_t stride2, // 33615| 1.78k| uint32_t inv_h0, // 33616| 1.78k| uint32_t inv_h1, // 33617| 1.78k| uint32_t inv_h2, // 33618| 1.78k| uint32_t inv_v0, // 33619| 1.78k| uint32_t inv_v1, // 33620| 1.78k| uint32_t inv_v2, // 33621| 1.78k| uint32_t half_width_for_2to1, // 33622| 1.78k| uint32_t half_height_for_2to1, // 33623| 1.78k| uint8_t* scratch_buffer_2k_ptr, // 33624| 1.78k| wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], 33625| 1.78k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) = 33626| 1.78k| &wuffs_private_impl__swizzle_ycc__general__box_filter; 33627| | 33628| 1.78k| void (*func4)(wuffs_base__pixel_buffer * dst, // 33629| 1.78k| uint32_t x_min_incl, // 33630| 1.78k| uint32_t x_max_excl, // 33631| 1.78k| uint32_t y_min_incl, // 33632| 1.78k| uint32_t y_max_excl, // 33633| 1.78k| const uint8_t* src_ptr0, // 33634| 1.78k| const uint8_t* src_ptr1, // 33635| 1.78k| const uint8_t* src_ptr2, // 33636| 1.78k| const uint8_t* src_ptr3, // 33637| 1.78k| uint32_t stride0, // 33638| 1.78k| uint32_t stride1, // 33639| 1.78k| uint32_t stride2, // 33640| 1.78k| uint32_t stride3, // 33641| 1.78k| uint32_t inv_h0, // 33642| 1.78k| uint32_t inv_h1, // 33643| 1.78k| uint32_t inv_h2, // 33644| 1.78k| uint32_t inv_h3, // 33645| 1.78k| uint32_t inv_v0, // 33646| 1.78k| uint32_t inv_v1, // 33647| 1.78k| uint32_t inv_v2, // 33648| 1.78k| uint32_t inv_v3, // 33649| 1.78k| uint32_t half_width_for_2to1, // 33650| 1.78k| uint32_t half_height_for_2to1, // 33651| 1.78k| uint8_t* scratch_buffer_2k_ptr, // 33652| 1.78k| wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], 33653| 1.78k| wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) = 33654| 1.78k| &wuffs_private_impl__swizzle_ycck__general__box_filter; 33655| | 33656| 1.78k| wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4]; 33657| 1.78k| memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs, 33658| 1.78k| sizeof upfuncs); 33659| | 33660| 1.78k| if (triangle_filter_for_2to1 && ------------------ | Branch (33660:7): [True: 956, False: 826] ------------------ 33661| 956| (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) || ------------------ | Branch (33661:8): [True: 216, False: 740] ------------------ 33662| 740| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) || ------------------ | Branch (33662:8): [True: 114, False: 626] ------------------ 33663| 626| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) || ------------------ | Branch (33663:8): [True: 79, False: 547] ------------------ 33664| 547| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h3, inv_v3))) { ------------------ | Branch (33664:8): [True: 0, False: 547] ------------------ 33665| 409| func3 = &wuffs_private_impl__swizzle_ycc__general__triangle_filter; 33666| 409| func4 = &wuffs_private_impl__swizzle_ycck__general__triangle_filter; 33667| | 33668| 409| upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle; 33669| 409| upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle; 33670| 409| upfuncs[1][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle; 33671| | 33672| 409|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 33673| |#if defined(__GNUC__) && !defined(__clang__) 33674| | // Don't use our AVX2 implementation for GCC (but do use it for clang). For 33675| | // some unknown reason, GCC performs noticably better on the non-SIMD 33676| | // version. Possibly because GCC's auto-vectorizer is smarter (just with 33677| | // SSE2, not AVX2) than our hand-written code, but that's just a guess. 33678| | // 33679| | // See commits 51bc60ef9298cb2efc1b29a9681191f66d49820d and 33680| | // cd769a0cdf1b5affee13f6089b995f3d39569cb4 for benchmark numbers. 33681| | // 33682| | // See also https://godbolt.org/z/MbhbPGEz4 for Debian Bullseye's clang 11 33683| | // versus gcc 10, where only gcc auto-vectorizes, although later clang 33684| | // versions will also auto-vectorize. 33685| |#else 33686| 409| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (33686:9): [True: 409, False: 0] ------------------ 33687| 409| upfuncs[1][1] = 33688| 409| wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2; 33689| 409| } 33690| 409|#endif 33691| 409|#endif 33692| 409| } 33693| | 33694| 1.78k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (33694:7): [True: 0, False: 1.78k] | Branch (33694:21): [True: 0, False: 1.78k] ------------------ 33695| 0| wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = 33696| 0| is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general ------------------ | Branch (33696:9): [True: 0, False: 0] ------------------ 33697| 0| : &wuffs_private_impl__swizzle_ycck__convert_4_general; 33698| 0| (*func4)( // 33699| 0| dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // 33700| 0| src0.ptr, src1.ptr, src2.ptr, src3.ptr, // 33701| 0| stride0, stride1, stride2, stride3, // 33702| 0| inv_h0, inv_h1, inv_h2, inv_h3, // 33703| 0| inv_v0, inv_v1, inv_v2, inv_v3, // 33704| 0| half_width_for_2to1, half_height_for_2to1, // 33705| 0| scratch_buffer_2k.ptr, &upfuncs, conv4func); 33706| | 33707| 1.78k| } else { 33708| 1.78k| (*func3)( // 33709| 1.78k| dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // 33710| 1.78k| src0.ptr, src1.ptr, src2.ptr, // 33711| 1.78k| stride0, stride1, stride2, // 33712| 1.78k| inv_h0, inv_h1, inv_h2, // 33713| 1.78k| inv_v0, inv_v1, inv_v2, // 33714| 1.78k| half_width_for_2to1, half_height_for_2to1, // 33715| 1.78k| scratch_buffer_2k.ptr, &upfuncs, conv3func); 33716| 1.78k| } 33717| | 33718| | return wuffs_base__make_status(NULL); 33719| 1.78k|} pixel_swizzler_fuzzer.c:wuffs_base__make_status: 624| 538k|wuffs_base__make_status(const char* repr) { 625| 538k| wuffs_base__status z; 626| 538k| z.repr = repr; 627| 538k| return z; 628| 538k|} pixel_swizzler_fuzzer.c:wuffs_base__u32__min: 1055| 33.4k|wuffs_base__u32__min(uint32_t x, uint32_t y) { 1056| 33.4k| return x < y ? x : y; ------------------ | Branch (1056:10): [True: 18.0k, False: 15.4k] ------------------ 1057| 33.4k|} pixel_swizzler_fuzzer.c:wuffs_base__make_slice_u8: 1719| 87.6k|wuffs_base__make_slice_u8(uint8_t* ptr, size_t len) { 1720| 87.6k| wuffs_base__slice_u8 ret; 1721| 87.6k| ret.ptr = ptr; 1722| 87.6k| ret.len = len; 1723| 87.6k| return ret; 1724| 87.6k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u32le__no_bounds_check: 1439| 65.7k|wuffs_base__peek_u32le__no_bounds_check(const uint8_t* p) { 1440| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1441| | uint32_t x; 1442| | memcpy(&x, p, 4); 1443| | return x; 1444| |#else 1445| 65.7k| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | 1446| 65.7k| ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); 1447| 65.7k|#endif 1448| 65.7k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u24le__no_bounds_check: 1421| 1.41k|wuffs_base__peek_u24le__no_bounds_check(const uint8_t* p) { 1422| 1.41k| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | 1423| 1.41k| ((uint32_t)(p[2]) << 16); 1424| 1.41k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u16le__no_bounds_check: 1404| 9.98k|wuffs_base__peek_u16le__no_bounds_check(const uint8_t* p) { 1405| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1406| | uint16_t x; 1407| | memcpy(&x, p, 2); 1408| | return x; 1409| |#else 1410| 9.98k| return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); 1411| 9.98k|#endif 1412| 9.98k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u24be__no_bounds_check: 1415| 282|wuffs_base__peek_u24be__no_bounds_check(const uint8_t* p) { 1416| 282| return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) | 1417| 282| ((uint32_t)(p[2]) << 0); 1418| 282|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u16be__no_bounds_check: 1393| 50|wuffs_base__peek_u16be__no_bounds_check(const uint8_t* p) { 1394| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1395| | uint16_t x; 1396| | memcpy(&x, p, 2); 1397| | return _byteswap_ushort(x); 1398| |#else 1399| 50| return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); 1400| 50|#endif 1401| 50|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_planar: 4915| 536k|wuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) { 4916| 536k| return ((f->repr >> 16) & 0x03) != 0; 4917| 536k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul: 4469| 16.8k| uint32_t argb_nonpremul) { 4470| | // Multiplying by 0x101 (twice, once for alpha and once for color) converts 4471| | // from 8-bit to 16-bit color. Shifting right by 8 undoes that. 4472| | // 4473| | // Working in the higher bit depth can produce slightly different (and 4474| | // arguably slightly more accurate) results. For example, given 8-bit blue 4475| | // and alpha of 0x80 and 0x81: 4476| | // 4477| | // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40 4478| | // - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41 4479| 16.8k| uint32_t a = 0xFF & (argb_nonpremul >> 24); 4480| 16.8k| uint32_t a16 = a * (0x101 * 0x101); 4481| | 4482| 16.8k| uint32_t r = 0xFF & (argb_nonpremul >> 16); 4483| 16.8k| r = ((r * a16) / 0xFFFF) >> 8; 4484| 16.8k| uint32_t g = 0xFF & (argb_nonpremul >> 8); 4485| 16.8k| g = ((g * a16) / 0xFFFF) >> 8; 4486| 16.8k| uint32_t b = 0xFF & (argb_nonpremul >> 0); 4487| 16.8k| b = ((b * a16) / 0xFFFF) >> 8; 4488| | 4489| 16.8k| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4490| 16.8k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul: 4401| 3.06k|wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(uint16_t rgb_565) { 4402| 3.06k| uint32_t b5 = 0x1F & (rgb_565 >> 0); 4403| 3.06k| uint32_t b = (b5 << 3) | (b5 >> 2); 4404| 3.06k| uint32_t g6 = 0x3F & (rgb_565 >> 5); 4405| 3.06k| uint32_t g = (g6 << 2) | (g6 >> 4); 4406| 3.06k| uint32_t r5 = 0x1F & (rgb_565 >> 11); 4407| 3.06k| uint32_t r = (r5 << 3) | (r5 >> 2); 4408| 3.06k| return 0xFF000000 | (r << 16) | (g << 8) | (b << 0); 4409| 3.06k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul: 4519| 692| uint64_t argb_nonpremul) { 4520| 692| uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); 4521| | 4522| 692| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); 4523| 692| r16 = (r16 * a16) / 0xFFFF; 4524| 692| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); 4525| 692| g16 = (g16 * a16) / 0xFFFF; 4526| 692| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); 4527| 692| b16 = (b16 * a16) / 0xFFFF; 4528| | 4529| 692| return ((a16 >> 8) << 24) | ((r16 >> 8) << 16) | ((g16 >> 8) << 8) | 4530| 692| ((b16 >> 8) << 0); 4531| 692|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u64le__no_bounds_check: 1509| 7.12k|wuffs_base__peek_u64le__no_bounds_check(const uint8_t* p) { 1510| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1511| | uint64_t x; 1512| | memcpy(&x, p, 8); 1513| | return x; 1514| |#else 1515| 7.12k| return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | 1516| 7.12k| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | 1517| 7.12k| ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | 1518| 7.12k| ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56); 1519| 7.12k|#endif 1520| 7.12k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64__as__color_u32: 4629| 2.86k|wuffs_base__color_u64__as__color_u32(uint64_t c) { 4630| 2.86k| uint32_t a = ((uint32_t)(0xFF & (c >> 56))); 4631| 2.86k| uint32_t r = ((uint32_t)(0xFF & (c >> 40))); 4632| 2.86k| uint32_t g = ((uint32_t)(0xFF & (c >> 24))); 4633| 2.86k| uint32_t b = ((uint32_t)(0xFF & (c >> 8))); 4634| 2.86k| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4635| 2.86k|} pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u32_argb_abgr: 4718| 103k|wuffs_base__color_swap_u32_argb_abgr(uint32_t u) { 4719| 103k| uint32_t o = u & 0xFF00FF00ul; 4720| 103k| uint32_t r = u & 0x00FF0000ul; 4721| 103k| uint32_t b = u & 0x000000FFul; 4722| 103k| return o | (r >> 16) | (b << 16); 4723| 103k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u32le__no_bounds_check: 1576| 259k|wuffs_base__poke_u32le__no_bounds_check(uint8_t* p, uint32_t x) { 1577| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \ 1578| | (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)) 1579| | // This seems to perform better on gcc 10 (but not clang 9). Clang also 1580| | // defines "__GNUC__". 1581| | memcpy(p, &x, 4); 1582| |#else 1583| 259k| p[0] = (uint8_t)(x >> 0); 1584| 259k| p[1] = (uint8_t)(x >> 8); 1585| 259k| p[2] = (uint8_t)(x >> 16); 1586| 259k| p[3] = (uint8_t)(x >> 24); 1587| 259k|#endif 1588| 259k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u8__no_bounds_check: 1530| 120k|wuffs_base__poke_u8__no_bounds_check(uint8_t* p, uint8_t x) { 1531| 120k| p[0] = x; 1532| 120k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u8_gray: 4413| 91.8k| wuffs_base__color_u32_argb_premul c) { 4414| | // Work in 16-bit color. 4415| 91.8k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 4416| 91.8k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 4417| 91.8k| uint32_t cb = 0x101 * (0xFF & (c >> 0)); 4418| | 4419| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4420| | // as those given by the JFIF specification. 4421| | // 4422| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We 4423| | // shift by 24, not just by 16, because the return value is 8-bit color, not 4424| | // 16-bit color. 4425| 91.8k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4426| 91.8k| return (uint8_t)(weighted_average >> 24); 4427| 91.8k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u16le__no_bounds_check: 1541| 107k|wuffs_base__poke_u16le__no_bounds_check(uint8_t* p, uint16_t x) { 1542| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \ 1543| | (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)) 1544| | // This seems to perform better on gcc 10 (but not clang 9). Clang also 1545| | // defines "__GNUC__". 1546| | memcpy(p, &x, 2); 1547| |#else 1548| 107k| p[0] = (uint8_t)(x >> 0); 1549| 107k| p[1] = (uint8_t)(x >> 8); 1550| 107k|#endif 1551| 107k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_gray: 4451| 25.5k| wuffs_base__color_u32_argb_premul c) { 4452| | // Work in 16-bit color. 4453| 25.5k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 4454| 25.5k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 4455| 25.5k| uint32_t cb = 0x101 * (0xFF & (c >> 0)); 4456| | 4457| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4458| | // as those given by the JFIF specification. 4459| | // 4460| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). 4461| 25.5k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4462| 25.5k| return (uint16_t)(weighted_average >> 16); 4463| 25.5k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u16be__no_bounds_check: 1535| 8.63k|wuffs_base__poke_u16be__no_bounds_check(uint8_t* p, uint16_t x) { 1536| 8.63k| p[0] = (uint8_t)(x >> 8); 1537| 8.63k| p[1] = (uint8_t)(x >> 0); 1538| 8.63k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul: 4431| 20.7k| wuffs_base__color_u32_argb_premul c) { 4432| 20.7k| uint32_t a = 0xFF & (c >> 24); 4433| 20.7k| if (a == 0) { ------------------ | Branch (4433:7): [True: 0, False: 20.7k] ------------------ 4434| 0| return 0; 4435| 0| } 4436| 20.7k| uint32_t a16 = a * 0x101; 4437| | 4438| 20.7k| uint32_t cr = 0xFF & (c >> 16); 4439| 20.7k| cr = (cr * (0x101 * 0xFFFF)) / a16; 4440| 20.7k| uint32_t cg = 0xFF & (c >> 8); 4441| 20.7k| cg = (cg * (0x101 * 0xFFFF)) / a16; 4442| 20.7k| uint32_t cb = 0xFF & (c >> 0); 4443| 20.7k| cb = (cb * (0x101 * 0xFFFF)) / a16; 4444| | 4445| 20.7k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4446| 20.7k| return (uint16_t)((a16 & 0xFF00) | (weighted_average >> 24)); 4447| 20.7k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__palette: 5849| 50.6k|wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) { 5850| 50.6k| if (pb && ------------------ | Branch (5850:7): [True: 50.6k, False: 0] ------------------ 5851| 50.6k| wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (5851:7): [True: 50.6k, False: 0] ------------------ 5852| 50.6k| wuffs_base__table_u8* tab = 5853| 50.6k| &pb->private_impl 5854| 50.6k| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; ------------------ | | 4781| 50.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3 ------------------ 5855| 50.6k| if ((tab->width == ------------------ | Branch (5855:9): [True: 50.6k, False: 0] ------------------ 5856| 50.6k| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) && ------------------ | | 4784| 50.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5857| 50.6k| (tab->height == 1)) { ------------------ | Branch (5857:9): [True: 50.6k, False: 0] ------------------ 5858| 50.6k| return wuffs_base__make_slice_u8( 5859| 50.6k| tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH); ------------------ | | 4784| 50.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5860| 50.6k| } 5861| 50.6k| } 5862| 0| return wuffs_base__empty_slice_u8(); 5863| 50.6k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_indexed: 4905| 57.9k|wuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) { 4906| 57.9k| return ((f->repr >> 18) & 0x01) != 0; 4907| 57.9k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565: 4393| 62.0k| wuffs_base__color_u32_argb_premul c) { 4394| 62.0k| uint32_t r5 = 0xF800 & (c >> 8); 4395| 62.0k| uint32_t g6 = 0x07E0 & (c >> 5); 4396| 62.0k| uint32_t b5 = 0x001F & (c >> 3); 4397| 62.0k| return (uint16_t)(r5 | g6 | b5); 4398| 62.0k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u24le__no_bounds_check: 1561| 126k|wuffs_base__poke_u24le__no_bounds_check(uint8_t* p, uint32_t x) { 1562| 126k| p[0] = (uint8_t)(x >> 0); 1563| 126k| p[1] = (uint8_t)(x >> 8); 1564| 126k| p[2] = (uint8_t)(x >> 16); 1565| 126k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul: 4496| 38.9k| wuffs_base__color_u32_argb_premul c) { 4497| 38.9k| uint32_t a = 0xFF & (c >> 24); 4498| 38.9k| if (a == 0xFF) { ------------------ | Branch (4498:7): [True: 37.6k, False: 1.27k] ------------------ 4499| 37.6k| return c; 4500| 37.6k| } else if (a == 0) { ------------------ | Branch (4500:14): [True: 206, False: 1.06k] ------------------ 4501| 206| return 0; 4502| 206| } 4503| 1.06k| uint32_t a16 = a * 0x101; 4504| | 4505| 1.06k| uint32_t r = 0xFF & (c >> 16); 4506| 1.06k| r = ((r * (0x101 * 0xFFFF)) / a16) >> 8; 4507| 1.06k| uint32_t g = 0xFF & (c >> 8); 4508| 1.06k| g = ((g * (0x101 * 0xFFFF)) / a16) >> 8; 4509| 1.06k| uint32_t b = 0xFF & (c >> 0); 4510| 1.06k| b = ((b * (0x101 * 0xFFFF)) / a16) >> 8; 4511| | 4512| 1.06k| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4513| 38.9k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u64le__no_bounds_check: 1663| 97.4k|wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) { 1664| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \ 1665| | (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)) 1666| | // This seems to perform better on gcc 10 (but not clang 9). Clang also 1667| | // defines "__GNUC__". 1668| | memcpy(p, &x, 8); 1669| |#else 1670| 97.4k| p[0] = (uint8_t)(x >> 0); 1671| 97.4k| p[1] = (uint8_t)(x >> 8); 1672| 97.4k| p[2] = (uint8_t)(x >> 16); 1673| 97.4k| p[3] = (uint8_t)(x >> 24); 1674| 97.4k| p[4] = (uint8_t)(x >> 32); 1675| 97.4k| p[5] = (uint8_t)(x >> 40); 1676| 97.4k| p[6] = (uint8_t)(x >> 48); 1677| 97.4k| p[7] = (uint8_t)(x >> 56); 1678| 97.4k|#endif 1679| 97.4k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul: 4537| 93.6k| wuffs_base__color_u32_argb_premul c) { 4538| 93.6k| uint32_t a = 0xFF & (c >> 24); 4539| 93.6k| if (a == 0xFF) { ------------------ | Branch (4539:7): [True: 93.6k, False: 0] ------------------ 4540| 93.6k| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); 4541| 93.6k| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); 4542| 93.6k| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); 4543| 93.6k| return 0xFFFF000000000000u | (r16 << 32) | (g16 << 16) | (b16 << 0); 4544| 93.6k| } else if (a == 0) { ------------------ | Branch (4544:14): [True: 0, False: 0] ------------------ 4545| 0| return 0; 4546| 0| } 4547| 0| uint64_t a16 = a * 0x101; 4548| | 4549| 0| uint64_t r = 0xFF & (c >> 16); 4550| 0| uint64_t r16 = (r * (0x101 * 0xFFFF)) / a16; 4551| 0| uint64_t g = 0xFF & (c >> 8); 4552| 0| uint64_t g16 = (g * (0x101 * 0xFFFF)) / a16; 4553| 0| uint64_t b = 0xFF & (c >> 0); 4554| 0| uint64_t b16 = (b * (0x101 * 0xFFFF)) / a16; 4555| | 4556| 0| return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); 4557| 93.6k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32__as__color_u64: 4620| 3.85k|wuffs_base__color_u32__as__color_u64(uint32_t c) { 4621| 3.85k| uint64_t a16 = 0x101 * (0xFF & (c >> 24)); 4622| 3.85k| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); 4623| 3.85k| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); 4624| 3.85k| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); 4625| 3.85k| return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); 4626| 3.85k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__bits_per_pixel: 4878| 14.6k|wuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) { 4879| 14.6k| if (((f->repr >> 16) & 0x03) != 0) { ------------------ | Branch (4879:7): [True: 0, False: 14.6k] ------------------ 4880| 0| return 0; 4881| 0| } 4882| 14.6k| return wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 4883| 14.6k| (f->repr >> 0)] + 4884| 14.6k| wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 4885| 14.6k| (f->repr >> 4)] + 4886| 14.6k| wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 4887| 14.6k| (f->repr >> 8)] + 4888| 14.6k| wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 4889| 14.6k| (f->repr >> 12)]; 4890| 14.6k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y: 30447| 140| wuffs_base__pixel_blend blend) { 30448| 140| switch (dst_pixfmt.repr) { ------------------ | Branch (30448:11): [True: 122, False: 18] ------------------ 30449| 15| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 15|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (30449:5): [True: 15, False: 125] ------------------ 30450| 15| return wuffs_private_impl__swizzle_copy_1_1; 30451| | 30452| 18| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (30452:5): [True: 18, False: 122] ------------------ 30453| 18| return wuffs_private_impl__swizzle_bgr_565__y; 30454| | 30455| 13| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (30455:5): [True: 13, False: 127] ------------------ 30456| 20| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 20|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (30456:5): [True: 7, False: 133] ------------------ 30457| 20| return wuffs_private_impl__swizzle_xxx__y; 30458| | 30459| 8| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (30459:5): [True: 8, False: 132] ------------------ 30460| 11| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (30460:5): [True: 3, False: 137] ------------------ 30461| 11| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (30461:5): [True: 0, False: 140] ------------------ 30462| 26| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 26|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (30462:5): [True: 15, False: 125] ------------------ 30463| 36| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 36|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (30463:5): [True: 10, False: 130] ------------------ 30464| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (30464:5): [True: 11, False: 129] ------------------ 30465| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (30465:5): [True: 0, False: 140] ------------------ 30466| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (30466:5): [True: 0, False: 140] ------------------ 30467| 47|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 30468| 47| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (30468:11): [True: 47, False: 0] ------------------ 30469| 47| return wuffs_private_impl__swizzle_xxxx__y__x86_sse42; 30470| 47| } 30471| 0|#endif 30472| 0| return wuffs_private_impl__swizzle_xxxx__y; 30473| | 30474| 19| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (30474:5): [True: 19, False: 121] ------------------ 30475| 22| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (30475:5): [True: 3, False: 137] ------------------ 30476| 22| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4857| 22|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (30476:5): [True: 0, False: 140] ------------------ 30477| 22| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4859| 22|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (30477:5): [True: 0, False: 140] ------------------ 30478| 22| return wuffs_private_impl__swizzle_xxxxxxxx__y; 30479| 140| } 30480| 18| return NULL; 30481| 140|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_1_1: 25210| 33| size_t src_len) { 25211| 33| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (25211:16): [True: 14, False: 19] ------------------ 25212| 33| if (len > 0) { ------------------ | Branch (25212:7): [True: 14, False: 19] ------------------ 25213| 14| memmove(dst_ptr, src_ptr, len); 25214| 14| } 25215| 33| return len; 25216| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y: 25908| 18| size_t src_len) { 25909| 18| size_t dst_len2 = dst_len / 2; 25910| 18| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (25910:16): [True: 9, False: 9] ------------------ 25911| 18| uint8_t* d = dst_ptr; 25912| 18| const uint8_t* s = src_ptr; 25913| 18| size_t n = len; 25914| | 25915| | // TODO: unroll. 25916| | 25917| 317| while (n >= 1) { ------------------ | Branch (25917:10): [True: 299, False: 18] ------------------ 25918| 299| uint32_t y5 = (uint32_t)(s[0] >> 3); 25919| 299| uint32_t y6 = (uint32_t)(s[0] >> 2); 25920| 299| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 25921| 299| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 25922| | 25923| 299| s += 1 * 1; 25924| 299| d += 1 * 2; 25925| 299| n -= 1; 25926| 299| } 25927| | 25928| 18| return len; 25929| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y: 29088| 20| size_t src_len) { 29089| 20| size_t dst_len3 = dst_len / 3; 29090| 20| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29090:16): [True: 12, False: 8] ------------------ 29091| 20| uint8_t* d = dst_ptr; 29092| 20| const uint8_t* s = src_ptr; 29093| 20| size_t n = len; 29094| | 29095| | // TODO: unroll. 29096| | 29097| 290| while (n >= 1) { ------------------ | Branch (29097:10): [True: 270, False: 20] ------------------ 29098| 270| uint8_t s0 = s[0]; 29099| 270| d[0] = s0; 29100| 270| d[1] = s0; 29101| 270| d[2] = s0; 29102| | 29103| 270| s += 1 * 1; 29104| 270| d += 1 * 3; 29105| 270| n -= 1; 29106| 270| } 29107| | 29108| 20| return len; 29109| 20|} pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_sse42: 375| 169|wuffs_base__cpu_arch__have_x86_sse42(void) { 376| |#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) 377| | return true; 378| |#else 379| 169|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) 380| | // GCC defines these macros but MSVC does not. 381| | // - bit_PCLMUL = (1 << 1) 382| | // - bit_POPCNT = (1 << 23) 383| | // - bit_SSE4_2 = (1 << 20) 384| 169| const unsigned int sse42_ecx1 = 0x00900002; 385| | 386| | // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). 387| 169|#if defined(__GNUC__) 388| 169| unsigned int eax1 = 0; 389| 169| unsigned int ebx1 = 0; 390| 169| unsigned int ecx1 = 0; 391| 169| unsigned int edx1 = 0; 392| 169| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && ------------------ | Branch (392:7): [True: 169, False: 0] ------------------ 393| 169| ((ecx1 & sse42_ecx1) == sse42_ecx1)) { ------------------ | Branch (393:7): [True: 169, False: 0] ------------------ 394| 169| return true; 395| 169| } 396| |#elif defined(_MSC_VER) // defined(__GNUC__) 397| | int x1[4]; 398| | __cpuid(x1, 1); 399| | if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) { 400| | return true; 401| | } 402| |#else 403| |#error "WUFFS_PRIVATE_IMPL__CPU_ARCH__ETC combined with an unsupported compiler" 404| |#endif // defined(__GNUC__); defined(_MSC_VER) 405| 0|#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) 406| 0| return false; 407| 169|#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) 408| 169|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y__x86_sse42: 29358| 47| size_t src_len) { 29359| 47| size_t dst_len4 = dst_len / 4; 29360| 47| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (29360:16): [True: 30, False: 17] ------------------ 29361| 47| uint8_t* d = dst_ptr; 29362| 47| const uint8_t* s = src_ptr; 29363| 47| size_t n = len; 29364| | 29365| 47| __m128i shuffle = _mm_set_epi8(+0x03, +0x03, +0x03, +0x03, // 29366| 47| +0x02, +0x02, +0x02, +0x02, // 29367| 47| +0x01, +0x01, +0x01, +0x01, // 29368| 47| +0x00, +0x00, +0x00, +0x00); 29369| 47| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 29370| 47| -0x01, +0x00, +0x00, +0x00, // 29371| 47| -0x01, +0x00, +0x00, +0x00, // 29372| 47| -0x01, +0x00, +0x00, +0x00); 29373| | 29374| 194| while (n >= 4) { ------------------ | Branch (29374:10): [True: 147, False: 47] ------------------ 29375| 147| __m128i x; 29376| 147| x = _mm_cvtsi32_si128((int)(wuffs_base__peek_u32le__no_bounds_check(s))); 29377| 147| x = _mm_shuffle_epi8(x, shuffle); 29378| 147| x = _mm_or_si128(x, or_ff); 29379| 147| _mm_storeu_si128((__m128i*)(void*)d, x); 29380| | 29381| 147| s += 4 * 1; 29382| 147| d += 4 * 4; 29383| 147| n -= 4; 29384| 147| } 29385| | 29386| 85| while (n >= 1) { ------------------ | Branch (29386:10): [True: 38, False: 47] ------------------ 29387| 38| wuffs_base__poke_u32le__no_bounds_check( 29388| 38| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); 29389| | 29390| 38| s += 1 * 1; 29391| 38| d += 1 * 4; 29392| 38| n -= 1; 29393| 38| } 29394| | 29395| 47| return len; 29396| 47|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y: 29550| 22| size_t src_len) { 29551| 22| size_t dst_len8 = dst_len / 8; 29552| 22| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (29552:16): [True: 14, False: 8] ------------------ 29553| 22| uint8_t* d = dst_ptr; 29554| 22| const uint8_t* s = src_ptr; 29555| 22| size_t n = len; 29556| | 29557| 291| while (n >= 1) { ------------------ | Branch (29557:10): [True: 269, False: 22] ------------------ 29558| 269| wuffs_base__poke_u64le__no_bounds_check( 29559| 269| d + (0 * 8), 0xFFFF000000000000 | (0x010101010101 * (uint64_t)s[0])); 29560| | 29561| 269| s += 1 * 1; 29562| 269| d += 1 * 8; 29563| 269| n -= 1; 29564| 269| } 29565| | 29566| 22| return len; 29567| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16be: 30489| 130| wuffs_base__pixel_blend blend) { 30490| 130| switch (dst_pixfmt.repr) { ------------------ | Branch (30490:11): [True: 122, False: 8] ------------------ 30491| 20| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (30491:5): [True: 20, False: 110] ------------------ 30492| 20| return wuffs_private_impl__swizzle_y__y_16be; 30493| | 30494| 4| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4828| 4|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (30494:5): [True: 4, False: 126] ------------------ 30495| 4| return wuffs_private_impl__swizzle_y_16le__y_16be; 30496| | 30497| 3| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4829| 3|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (30497:5): [True: 3, False: 127] ------------------ 30498| 3| return wuffs_private_impl__swizzle_copy_2_2; 30499| | 30500| 26| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 26|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (30500:5): [True: 26, False: 104] ------------------ 30501| 26| return wuffs_private_impl__swizzle_bgr_565__y_16be; 30502| | 30503| 5| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (30503:5): [True: 5, False: 125] ------------------ 30504| 16| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (30504:5): [True: 11, False: 119] ------------------ 30505| 16| return wuffs_private_impl__swizzle_xxx__y_16be; 30506| | 30507| 8| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (30507:5): [True: 8, False: 122] ------------------ 30508| 16| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (30508:5): [True: 8, False: 122] ------------------ 30509| 16| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (30509:5): [True: 0, False: 130] ------------------ 30510| 28| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 28|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (30510:5): [True: 12, False: 118] ------------------ 30511| 38| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 38|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (30511:5): [True: 10, False: 120] ------------------ 30512| 42| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 42|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (30512:5): [True: 4, False: 126] ------------------ 30513| 42| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 42|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (30513:5): [True: 0, False: 130] ------------------ 30514| 42| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 42|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (30514:5): [True: 0, False: 130] ------------------ 30515| 42| return wuffs_private_impl__swizzle_xxxx__y_16be; 30516| | 30517| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (30517:5): [True: 4, False: 126] ------------------ 30518| 11| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (30518:5): [True: 7, False: 123] ------------------ 30519| 11| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4857| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (30519:5): [True: 0, False: 130] ------------------ 30520| 11| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4859| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (30520:5): [True: 0, False: 130] ------------------ 30521| 11| return wuffs_private_impl__swizzle_xxxxxxxx__y_16be; 30522| 130| } 30523| 8| return NULL; 30524| 130|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__y_16be: 30144| 20| size_t src_len) { 30145| 20| size_t src_len2 = src_len / 2; 30146| 20| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30146:16): [True: 4, False: 16] ------------------ 30147| 20| uint8_t* d = dst_ptr; 30148| 20| const uint8_t* s = src_ptr; 30149| 20| size_t n = len; 30150| | 30151| | // TODO: unroll. 30152| | 30153| 1.02k| while (n >= 1) { ------------------ | Branch (30153:10): [True: 1.00k, False: 20] ------------------ 30154| 1.00k| d[0] = s[0]; 30155| | 30156| 1.00k| s += 1 * 2; 30157| 1.00k| d += 1 * 1; 30158| 1.00k| n -= 1; 30159| 1.00k| } 30160| | 30161| 20| return len; 30162| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y_16le__y_16be: 30352| 22| size_t src_len) { 30353| 22| size_t dst_len2 = dst_len / 2; 30354| 22| size_t src_len2 = src_len / 2; 30355| 22| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (30355:16): [True: 8, False: 14] ------------------ 30356| 22| uint8_t* d = dst_ptr; 30357| 22| const uint8_t* s = src_ptr; 30358| 22| size_t n = len; 30359| | 30360| 547| while (n >= 1) { ------------------ | Branch (30360:10): [True: 525, False: 22] ------------------ 30361| 525| uint8_t s0 = s[0]; 30362| 525| uint8_t s1 = s[1]; 30363| 525| d[0] = s1; 30364| 525| d[1] = s0; 30365| | 30366| 525| s += 1 * 2; 30367| 525| d += 1 * 2; 30368| 525| n -= 1; 30369| 525| } 30370| | 30371| 22| return len; 30372| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_2_2: 25224| 16| size_t src_len) { 25225| 16| size_t dst_len2 = dst_len / 2; 25226| 16| size_t src_len2 = src_len / 2; 25227| 16| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (25227:16): [True: 3, False: 13] ------------------ 25228| 16| if (len > 0) { ------------------ | Branch (25228:7): [True: 11, False: 5] ------------------ 25229| 11| memmove(dst_ptr, src_ptr, len * 2); 25230| 11| } 25231| 16| return len; 25232| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16be: 25937| 26| size_t src_len) { 25938| 26| size_t dst_len2 = dst_len / 2; 25939| 26| size_t src_len2 = src_len / 2; 25940| 26| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (25940:16): [True: 10, False: 16] ------------------ 25941| 26| uint8_t* d = dst_ptr; 25942| 26| const uint8_t* s = src_ptr; 25943| 26| size_t n = len; 25944| | 25945| | // TODO: unroll. 25946| | 25947| 1.33k| while (n >= 1) { ------------------ | Branch (25947:10): [True: 1.30k, False: 26] ------------------ 25948| 1.30k| uint32_t y5 = (uint32_t)(s[0] >> 3); 25949| 1.30k| uint32_t y6 = (uint32_t)(s[0] >> 2); 25950| 1.30k| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 25951| 1.30k| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 25952| | 25953| 1.30k| s += 1 * 2; 25954| 1.30k| d += 1 * 2; 25955| 1.30k| n -= 1; 25956| 1.30k| } 25957| | 25958| 26| return len; 25959| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16be: 29117| 16| size_t src_len) { 29118| 16| size_t dst_len3 = dst_len / 3; 29119| 16| size_t src_len2 = src_len / 2; 29120| 16| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29120:16): [True: 5, False: 11] ------------------ 29121| 16| uint8_t* d = dst_ptr; 29122| 16| const uint8_t* s = src_ptr; 29123| 16| size_t n = len; 29124| | 29125| | // TODO: unroll. 29126| | 29127| 393| while (n >= 1) { ------------------ | Branch (29127:10): [True: 377, False: 16] ------------------ 29128| 377| uint8_t s0 = s[0]; 29129| 377| d[0] = s0; 29130| 377| d[1] = s0; 29131| 377| d[2] = s0; 29132| | 29133| 377| s += 1 * 2; 29134| 377| d += 1 * 3; 29135| 377| n -= 1; 29136| 377| } 29137| | 29138| 16| return len; 29139| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y_16be: 29431| 42| size_t src_len) { 29432| 42| size_t dst_len4 = dst_len / 4; 29433| 42| size_t src_len2 = src_len / 2; 29434| 42| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (29434:16): [True: 19, False: 23] ------------------ 29435| 42| uint8_t* d = dst_ptr; 29436| 42| const uint8_t* s = src_ptr; 29437| 42| size_t n = len; 29438| | 29439| 775| while (n >= 1) { ------------------ | Branch (29439:10): [True: 733, False: 42] ------------------ 29440| 733| wuffs_base__poke_u32le__no_bounds_check( 29441| 733| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); 29442| | 29443| 733| s += 1 * 2; 29444| 733| d += 1 * 4; 29445| 733| n -= 1; 29446| 733| } 29447| | 29448| 42| return len; 29449| 42|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16be: 29575| 11| size_t src_len) { 29576| 11| size_t dst_len8 = dst_len / 8; 29577| 11| size_t src_len2 = src_len / 2; 29578| 11| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (29578:16): [True: 7, False: 4] ------------------ 29579| 11| uint8_t* d = dst_ptr; 29580| 11| const uint8_t* s = src_ptr; 29581| 11| size_t n = len; 29582| | 29583| 61| while (n >= 1) { ------------------ | Branch (29583:10): [True: 50, False: 11] ------------------ 29584| 50| uint64_t s0 = 29585| 50| ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(s + (0 * 2)))); 29586| 50| wuffs_base__poke_u64le__no_bounds_check( 29587| 50| d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0)); 29588| | 29589| 50| s += 1 * 2; 29590| 50| d += 1 * 8; 29591| 50| n -= 1; 29592| 50| } 29593| | 29594| 11| return len; 29595| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16le: 30532| 160| wuffs_base__pixel_blend blend) { 30533| 160| switch (dst_pixfmt.repr) { ------------------ | Branch (30533:11): [True: 150, False: 10] ------------------ 30534| 23| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 23|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (30534:5): [True: 23, False: 137] ------------------ 30535| 23| return wuffs_private_impl__swizzle_y__y_16le; 30536| | 30537| 6| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4828| 6|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (30537:5): [True: 6, False: 154] ------------------ 30538| 6| return wuffs_private_impl__swizzle_copy_2_2; 30539| | 30540| 18| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4829| 18|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (30540:5): [True: 18, False: 142] ------------------ 30541| 18| return wuffs_private_impl__swizzle_y_16le__y_16be; 30542| | 30543| 25| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (30543:5): [True: 25, False: 135] ------------------ 30544| 25| return wuffs_private_impl__swizzle_bgr_565__y_16le; 30545| | 30546| 9| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (30546:5): [True: 9, False: 151] ------------------ 30547| 19| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 19|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (30547:5): [True: 10, False: 150] ------------------ 30548| 19| return wuffs_private_impl__swizzle_xxx__y_16le; 30549| | 30550| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (30550:5): [True: 6, False: 154] ------------------ 30551| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (30551:5): [True: 9, False: 151] ------------------ 30552| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (30552:5): [True: 0, False: 160] ------------------ 30553| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (30553:5): [True: 3, False: 157] ------------------ 30554| 31| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 31|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (30554:5): [True: 13, False: 147] ------------------ 30555| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (30555:5): [True: 16, False: 144] ------------------ 30556| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (30556:5): [True: 0, False: 160] ------------------ 30557| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (30557:5): [True: 0, False: 160] ------------------ 30558| 47| return wuffs_private_impl__swizzle_xxxx__y_16le; 30559| | 30560| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (30560:5): [True: 9, False: 151] ------------------ 30561| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (30561:5): [True: 3, False: 157] ------------------ 30562| 12| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4857| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (30562:5): [True: 0, False: 160] ------------------ 30563| 12| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4859| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (30563:5): [True: 0, False: 160] ------------------ 30564| 12| return wuffs_private_impl__swizzle_xxxxxxxx__y_16le; 30565| 160| } 30566| 10| return NULL; 30567| 160|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__y_16le: 30170| 23| size_t src_len) { 30171| 23| size_t src_len2 = src_len / 2; 30172| 23| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30172:16): [True: 7, False: 16] ------------------ 30173| 23| uint8_t* d = dst_ptr; 30174| 23| const uint8_t* s = src_ptr; 30175| 23| size_t n = len; 30176| | 30177| | // TODO: unroll. 30178| | 30179| 441| while (n >= 1) { ------------------ | Branch (30179:10): [True: 418, False: 23] ------------------ 30180| 418| d[0] = s[1]; 30181| | 30182| 418| s += 1 * 2; 30183| 418| d += 1 * 1; 30184| 418| n -= 1; 30185| 418| } 30186| | 30187| 23| return len; 30188| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16le: 25967| 25| size_t src_len) { 25968| 25| size_t dst_len2 = dst_len / 2; 25969| 25| size_t src_len2 = src_len / 2; 25970| 25| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (25970:16): [True: 9, False: 16] ------------------ 25971| 25| uint8_t* d = dst_ptr; 25972| 25| const uint8_t* s = src_ptr; 25973| 25| size_t n = len; 25974| | 25975| | // TODO: unroll. 25976| | 25977| 1.04k| while (n >= 1) { ------------------ | Branch (25977:10): [True: 1.01k, False: 25] ------------------ 25978| 1.01k| uint32_t y5 = (uint32_t)(s[1] >> 3); 25979| 1.01k| uint32_t y6 = (uint32_t)(s[1] >> 2); 25980| 1.01k| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 25981| 1.01k| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 25982| | 25983| 1.01k| s += 1 * 2; 25984| 1.01k| d += 1 * 2; 25985| 1.01k| n -= 1; 25986| 1.01k| } 25987| | 25988| 25| return len; 25989| 25|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16le: 29147| 19| size_t src_len) { 29148| 19| size_t dst_len3 = dst_len / 3; 29149| 19| size_t src_len2 = src_len / 2; 29150| 19| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29150:16): [True: 6, False: 13] ------------------ 29151| 19| uint8_t* d = dst_ptr; 29152| 19| const uint8_t* s = src_ptr; 29153| 19| size_t n = len; 29154| | 29155| | // TODO: unroll. 29156| | 29157| 611| while (n >= 1) { ------------------ | Branch (29157:10): [True: 592, False: 19] ------------------ 29158| 592| uint8_t s0 = s[1]; 29159| 592| d[0] = s0; 29160| 592| d[1] = s0; 29161| 592| d[2] = s0; 29162| | 29163| 592| s += 1 * 2; 29164| 592| d += 1 * 3; 29165| 592| n -= 1; 29166| 592| } 29167| | 29168| 19| return len; 29169| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y_16le: 29457| 47| size_t src_len) { 29458| 47| size_t dst_len4 = dst_len / 4; 29459| 47| size_t src_len2 = src_len / 2; 29460| 47| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (29460:16): [True: 21, False: 26] ------------------ 29461| 47| uint8_t* d = dst_ptr; 29462| 47| const uint8_t* s = src_ptr; 29463| 47| size_t n = len; 29464| | 29465| 927| while (n >= 1) { ------------------ | Branch (29465:10): [True: 880, False: 47] ------------------ 29466| 880| wuffs_base__poke_u32le__no_bounds_check( 29467| 880| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[1])); 29468| | 29469| 880| s += 1 * 2; 29470| 880| d += 1 * 4; 29471| 880| n -= 1; 29472| 880| } 29473| | 29474| 47| return len; 29475| 47|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16le: 29603| 12| size_t src_len) { 29604| 12| size_t dst_len8 = dst_len / 8; 29605| 12| size_t src_len2 = src_len / 2; 29606| 12| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (29606:16): [True: 5, False: 7] ------------------ 29607| 12| uint8_t* d = dst_ptr; 29608| 12| const uint8_t* s = src_ptr; 29609| 12| size_t n = len; 29610| | 29611| 111| while (n >= 1) { ------------------ | Branch (29611:10): [True: 99, False: 12] ------------------ 29612| 99| uint64_t s0 = 29613| 99| ((uint64_t)(wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))); 29614| 99| wuffs_base__poke_u64le__no_bounds_check( 29615| 99| d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0)); 29616| | 29617| 99| s += 1 * 2; 29618| 99| d += 1 * 8; 29619| 99| n -= 1; 29620| 99| } 29621| | 29622| 12| return len; 29623| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul: 30575| 304| wuffs_base__pixel_blend blend) { 30576| 304| switch (dst_pixfmt.repr) { ------------------ | Branch (30576:11): [True: 279, False: 25] ------------------ 30577| 38| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 38|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (30577:5): [True: 38, False: 266] ------------------ 30578| 38| switch (blend) { ------------------ | Branch (30578:15): [True: 38, False: 0] ------------------ 30579| 20| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30579:9): [True: 20, False: 18] ------------------ 30580| 20| return wuffs_private_impl__swizzle_y__ya_nonpremul__src; 30581| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30581:9): [True: 18, False: 20] ------------------ 30582| 18| return wuffs_private_impl__swizzle_y__ya_nonpremul__src_over; 30583| 38| } 30584| 0| return NULL; 30585| | 30586| 29| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4830| 29|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (30586:5): [True: 29, False: 275] ------------------ 30587| 29| switch (blend) { ------------------ | Branch (30587:15): [True: 29, False: 0] ------------------ 30588| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30588:9): [True: 1, False: 28] ------------------ 30589| 1| return wuffs_private_impl__swizzle_copy_2_2; 30590| 28| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 28|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30590:9): [True: 28, False: 1] ------------------ 30591| 28| return wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over; 30592| 29| } 30593| 0| return NULL; 30594| | 30595| 42| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 42|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (30595:5): [True: 42, False: 262] ------------------ 30596| 42| switch (blend) { ------------------ | Branch (30596:15): [True: 42, False: 0] ------------------ 30597| 22| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 22|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30597:9): [True: 22, False: 20] ------------------ 30598| 22| return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src; 30599| 20| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30599:9): [True: 20, False: 22] ------------------ 30600| 20| return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over; 30601| 42| } 30602| 0| return NULL; 30603| | 30604| 18| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (30604:5): [True: 18, False: 286] ------------------ 30605| 33| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 33|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (30605:5): [True: 15, False: 289] ------------------ 30606| 33| switch (blend) { ------------------ | Branch (30606:15): [True: 33, False: 0] ------------------ 30607| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30607:9): [True: 16, False: 17] ------------------ 30608| 16| return wuffs_private_impl__swizzle_xxx__ya_nonpremul__src; 30609| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30609:9): [True: 17, False: 16] ------------------ 30610| 17| return wuffs_private_impl__swizzle_xxx__ya_nonpremul__src_over; 30611| 33| } 30612| 0| return NULL; 30613| | 30614| 21| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 21|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (30614:5): [True: 21, False: 283] ------------------ 30615| 43| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (30615:5): [True: 22, False: 282] ------------------ 30616| 43| switch (blend) { ------------------ | Branch (30616:15): [True: 43, False: 0] ------------------ 30617| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30617:9): [True: 18, False: 25] ------------------ 30618| 18| return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src; 30619| 25| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 25|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30619:9): [True: 25, False: 18] ------------------ 30620| 25| return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over; 30621| 43| } 30622| 0| return NULL; 30623| | 30624| 24| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 24|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (30624:5): [True: 24, False: 280] ------------------ 30625| 50| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 50|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (30625:5): [True: 26, False: 278] ------------------ 30626| 50| switch (blend) { ------------------ | Branch (30626:15): [True: 50, False: 0] ------------------ 30627| 22| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 22|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30627:9): [True: 22, False: 28] ------------------ 30628| 22| return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src; 30629| 28| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 28|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30629:9): [True: 28, False: 22] ------------------ 30630| 28| return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over; 30631| 50| } 30632| 0| return NULL; 30633| | 30634| 44| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 44|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (30634:5): [True: 44, False: 260] ------------------ 30635| 44| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4857| 44|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (30635:5): [True: 0, False: 304] ------------------ 30636| 44| switch (blend) { ------------------ | Branch (30636:15): [True: 44, False: 0] ------------------ 30637| 14| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30637:9): [True: 14, False: 30] ------------------ 30638| 14| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src; 30639| 30| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 30|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30639:9): [True: 30, False: 14] ------------------ 30640| 30| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over; 30641| 44| } 30642| 0| return NULL; 30643| 304| } 30644| 25| return NULL; 30645| 304|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src: 30196| 20| size_t src_len) { 30197| 20| size_t src_len2 = src_len / 2; 30198| 20| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30198:16): [True: 4, False: 16] ------------------ 30199| 20| uint8_t* d = dst_ptr; 30200| 20| const uint8_t* s = src_ptr; 30201| 20| size_t n = len; 30202| | 30203| | // TODO: unroll. 30204| | 30205| 681| while (n >= 1) { ------------------ | Branch (30205:10): [True: 661, False: 20] ------------------ 30206| 661| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 30207| 661| d[0] = (uint8_t) 30208| 661| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0); 30209| | 30210| 661| s += 1 * 2; 30211| 661| d += 1 * 1; 30212| 661| n -= 1; 30213| 661| } 30214| | 30215| 20| return len; 30216| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src_over: 30224| 18| size_t src_len) { 30225| 18| size_t src_len2 = src_len / 2; 30226| 18| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30226:16): [True: 3, False: 15] ------------------ 30227| 18| uint8_t* d = dst_ptr; 30228| 18| const uint8_t* s = src_ptr; 30229| 18| size_t n = len; 30230| | 30231| | // TODO: unroll. 30232| | 30233| 751| while (n >= 1) { ------------------ | Branch (30233:10): [True: 733, False: 18] ------------------ 30234| 733| uint32_t d0 = 0xFF000000 | ((uint32_t)(d[0]) * 0x010101); 30235| 733| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 30236| 733| d[0] = (uint8_t)wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, 30237| 733| s0); 30238| | 30239| 733| s += 1 * 2; 30240| 733| d += 1 * 1; 30241| 733| n -= 1; 30242| 733| } 30243| | 30244| 18| return len; 30245| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u32_axxx: 24891| 6.27k| uint32_t src_nonpremul) { 24892| | // Extract 16-bit color components. 24893| 6.27k| uint32_t da = 0x101 * (0xFF & (dst_premul >> 24)); 24894| 6.27k| uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16)); 24895| 6.27k| uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8)); 24896| 6.27k| uint32_t db = 0x101 * (0xFF & (dst_premul >> 0)); 24897| 6.27k| uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24)); 24898| 6.27k| uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16)); 24899| 6.27k| uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8)); 24900| 6.27k| uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0)); 24901| | 24902| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24903| 6.27k| uint32_t ia = 0xFFFF - sa; 24904| | 24905| | // Composite src (nonpremul) over dst (premul). 24906| 6.27k| da = sa + ((da * ia) / 0xFFFF); 24907| 6.27k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 24908| 6.27k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 24909| 6.27k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 24910| | 24911| | // Convert from 16-bit color to 8-bit color. 24912| 6.27k| da >>= 8; 24913| 6.27k| dr >>= 8; 24914| 6.27k| dg >>= 8; 24915| 6.27k| db >>= 8; 24916| | 24917| | // Combine components. 24918| 6.27k| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 24919| 6.27k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over: 30383| 28| size_t src_len) { 30384| 28| size_t dst_len2 = dst_len / 2; 30385| 28| size_t src_len2 = src_len / 2; 30386| 28| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (30386:16): [True: 5, False: 23] ------------------ 30387| 28| uint8_t* d = dst_ptr; 30388| 28| const uint8_t* s = src_ptr; 30389| 28| size_t n = len; 30390| | 30391| 936| while (n >= 1) { ------------------ | Branch (30391:10): [True: 908, False: 28] ------------------ 30392| 908| uint32_t d0 = ((uint32_t)(d[1]) << 24) | ((uint32_t)(d[0]) * 0x010101); 30393| 908| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 30394| 908| uint32_t c0 = 30395| 908| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0); 30396| 908| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)(c0 >> 16)); 30397| | 30398| 908| s += 1 * 2; 30399| 908| d += 1 * 2; 30400| 908| n -= 1; 30401| 908| } 30402| | 30403| 28| return len; 30404| 28|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx: 24707| 2.45k| uint32_t src_nonpremul) { 24708| | // Extract 16-bit color components. 24709| | // 24710| | // If the destination is transparent then SRC_OVER is equivalent to SRC: just 24711| | // return src_nonpremul. This isn't just an optimization (skipping the rest 24712| | // of the function's computation). It also preserves the nonpremul 24713| | // distinction between e.g. transparent red and transparent blue that would 24714| | // otherwise be lost by converting from nonpremul to premul and back. 24715| 2.45k| uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24)); 24716| 2.45k| if (da == 0) { ------------------ | Branch (24716:7): [True: 476, False: 1.97k] ------------------ 24717| 476| return src_nonpremul; 24718| 476| } 24719| 1.97k| uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16)); 24720| 1.97k| uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8)); 24721| 1.97k| uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0)); 24722| 1.97k| uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24)); 24723| 1.97k| uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16)); 24724| 1.97k| uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8)); 24725| 1.97k| uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0)); 24726| | 24727| | // Convert dst from nonpremul to premul. 24728| 1.97k| dr = (dr * da) / 0xFFFF; 24729| 1.97k| dg = (dg * da) / 0xFFFF; 24730| 1.97k| db = (db * da) / 0xFFFF; 24731| | 24732| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24733| 1.97k| uint32_t ia = 0xFFFF - sa; 24734| | 24735| | // Composite src (nonpremul) over dst (premul). 24736| 1.97k| da = sa + ((da * ia) / 0xFFFF); 24737| 1.97k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 24738| 1.97k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 24739| 1.97k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 24740| | 24741| | // Convert dst from premul to nonpremul. 24742| 1.97k| if (da != 0) { ------------------ | Branch (24742:7): [True: 1.97k, False: 0] ------------------ 24743| 1.97k| dr = (dr * 0xFFFF) / da; 24744| 1.97k| dg = (dg * 0xFFFF) / da; 24745| 1.97k| db = (db * 0xFFFF) / da; 24746| 1.97k| } 24747| | 24748| | // Convert from 16-bit color to 8-bit color. 24749| 1.97k| da >>= 8; 24750| 1.97k| dr >>= 8; 24751| 1.97k| dg >>= 8; 24752| 1.97k| db >>= 8; 24753| | 24754| | // Combine components. 24755| 1.97k| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 24756| 2.45k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src: 25997| 22| size_t src_len) { 25998| 22| size_t dst_len2 = dst_len / 2; 25999| 22| size_t src_len2 = src_len / 2; 26000| 22| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26000:16): [True: 4, False: 18] ------------------ 26001| 22| uint8_t* d = dst_ptr; 26002| 22| const uint8_t* s = src_ptr; 26003| 22| size_t n = len; 26004| | 26005| | // TODO: unroll. 26006| | 26007| 834| while (n >= 1) { ------------------ | Branch (26007:10): [True: 812, False: 22] ------------------ 26008| 812| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 26009| | 26010| 812| wuffs_base__poke_u16le__no_bounds_check( 26011| 812| d + (0 * 2), 26012| 812| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26013| 812| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26014| 812| s0))); 26015| | 26016| 812| s += 1 * 2; 26017| 812| d += 1 * 2; 26018| 812| n -= 1; 26019| 812| } 26020| | 26021| 22| return len; 26022| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over: 26031| 20| size_t src_len) { 26032| 20| size_t dst_len2 = dst_len / 2; 26033| 20| size_t src_len2 = src_len / 2; 26034| 20| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26034:16): [True: 5, False: 15] ------------------ 26035| 20| uint8_t* d = dst_ptr; 26036| 20| const uint8_t* s = src_ptr; 26037| 20| size_t n = len; 26038| | 26039| | // TODO: unroll. 26040| | 26041| 788| while (n >= 1) { ------------------ | Branch (26041:10): [True: 768, False: 20] ------------------ 26042| | // Extract 16-bit color components. 26043| 768| uint32_t sa = 0x101 * ((uint32_t)s[1]); 26044| 768| uint32_t sy = 0x101 * ((uint32_t)s[0]); 26045| | 26046| | // Convert from 565 color to 16-bit color. 26047| 768| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26048| 768| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26049| 768| uint32_t dr = (0x8421 * old_r5) >> 4; 26050| 768| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26051| 768| uint32_t dg = (0x1041 * old_g6) >> 2; 26052| 768| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26053| 768| uint32_t db = (0x8421 * old_b5) >> 4; 26054| | 26055| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26056| 768| uint32_t ia = 0xFFFF - sa; 26057| | 26058| | // Composite src (nonpremul) over dst (premul). 26059| 768| dr = ((sy * sa) + (dr * ia)) / 0xFFFF; 26060| 768| dg = ((sy * sa) + (dg * ia)) / 0xFFFF; 26061| 768| db = ((sy * sa) + (db * ia)) / 0xFFFF; 26062| | 26063| | // Convert from 16-bit color to 565 color and combine the components. 26064| 768| uint32_t new_r5 = 0x1F & (dr >> 11); 26065| 768| uint32_t new_g6 = 0x3F & (dg >> 10); 26066| 768| uint32_t new_b5 = 0x1F & (db >> 11); 26067| 768| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26068| 768| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26069| | 26070| 768| s += 1 * 2; 26071| 768| d += 1 * 2; 26072| 768| n -= 1; 26073| 768| } 26074| | 26075| 20| return len; 26076| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__ya_nonpremul__src: 29177| 16| size_t src_len) { 29178| 16| size_t dst_len3 = dst_len / 3; 29179| 16| size_t src_len2 = src_len / 2; 29180| 16| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29180:16): [True: 4, False: 12] ------------------ 29181| 16| uint8_t* d = dst_ptr; 29182| 16| const uint8_t* s = src_ptr; 29183| 16| size_t n = len; 29184| | 29185| | // TODO: unroll. 29186| | 29187| 391| while (n >= 1) { ------------------ | Branch (29187:10): [True: 375, False: 16] ------------------ 29188| 375| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 29189| 375| wuffs_base__poke_u24le__no_bounds_check( 29190| 375| d + (0 * 3), 29191| 375| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 29192| | 29193| 375| s += 1 * 2; 29194| 375| d += 1 * 3; 29195| 375| n -= 1; 29196| 375| } 29197| | 29198| 16| return len; 29199| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__ya_nonpremul__src_over: 29208| 17| size_t src_len) { 29209| 17| size_t dst_len3 = dst_len / 3; 29210| 17| size_t src_len2 = src_len / 2; 29211| 17| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29211:16): [True: 11, False: 6] ------------------ 29212| 17| uint8_t* d = dst_ptr; 29213| 17| const uint8_t* s = src_ptr; 29214| 17| size_t n = len; 29215| | 29216| | // TODO: unroll. 29217| | 29218| 351| while (n >= 1) { ------------------ | Branch (29218:10): [True: 334, False: 17] ------------------ 29219| 334| uint32_t d0 = 29220| 334| wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000; 29221| 334| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 29222| 334| wuffs_base__poke_u24le__no_bounds_check( 29223| 334| d + (0 * 3), 29224| 334| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 29225| | 29226| 334| s += 1 * 2; 29227| 334| d += 1 * 3; 29228| 334| n -= 1; 29229| 334| } 29230| | 29231| 17| return len; 29232| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src: 27233| 18| size_t src_len) { 27234| 18| size_t dst_len4 = dst_len / 4; 27235| 18| size_t src_len2 = src_len / 2; 27236| 18| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (27236:16): [True: 7, False: 11] ------------------ 27237| 18| uint8_t* d = dst_ptr; 27238| 18| const uint8_t* s = src_ptr; 27239| 18| size_t n = len; 27240| | 27241| | // TODO: unroll. 27242| | 27243| 356| while (n >= 1) { ------------------ | Branch (27243:10): [True: 338, False: 18] ------------------ 27244| 338| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 27245| 338| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 27246| | 27247| 338| s += 1 * 2; 27248| 338| d += 1 * 4; 27249| 338| n -= 1; 27250| 338| } 27251| | 27252| 18| return len; 27253| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over: 27262| 25| size_t src_len) { 27263| 25| size_t dst_len4 = dst_len / 4; 27264| 25| size_t src_len2 = src_len / 2; 27265| 25| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (27265:16): [True: 11, False: 14] ------------------ 27266| 25| uint8_t* d = dst_ptr; 27267| 25| const uint8_t* s = src_ptr; 27268| 25| size_t n = len; 27269| | 27270| | // TODO: unroll. 27271| | 27272| 316| while (n >= 1) { ------------------ | Branch (27272:10): [True: 291, False: 25] ------------------ 27273| 291| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27274| 291| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 27275| 291| wuffs_base__poke_u32le__no_bounds_check( 27276| 291| d + (0 * 4), 27277| 291| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27278| | 27279| 291| s += 1 * 2; 27280| 291| d += 1 * 4; 27281| 291| n -= 1; 27282| 291| } 27283| | 27284| 25| return len; 27285| 25|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src: 28217| 22| size_t src_len) { 28218| 22| size_t dst_len4 = dst_len / 4; 28219| 22| size_t src_len2 = src_len / 2; 28220| 22| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28220:16): [True: 7, False: 15] ------------------ 28221| 22| uint8_t* d = dst_ptr; 28222| 22| const uint8_t* s = src_ptr; 28223| 22| size_t n = len; 28224| | 28225| | // TODO: unroll. 28226| | 28227| 559| while (n >= 1) { ------------------ | Branch (28227:10): [True: 537, False: 22] ------------------ 28228| 537| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 28229| 537| wuffs_base__poke_u32le__no_bounds_check( 28230| 537| d + (0 * 4), 28231| 537| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28232| | 28233| 537| s += 1 * 2; 28234| 537| d += 1 * 4; 28235| 537| n -= 1; 28236| 537| } 28237| | 28238| 22| return len; 28239| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over: 28248| 28| size_t src_len) { 28249| 28| size_t dst_len4 = dst_len / 4; 28250| 28| size_t src_len2 = src_len / 2; 28251| 28| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28251:16): [True: 20, False: 8] ------------------ 28252| 28| uint8_t* d = dst_ptr; 28253| 28| const uint8_t* s = src_ptr; 28254| 28| size_t n = len; 28255| | 28256| | // TODO: unroll. 28257| | 28258| 458| while (n >= 1) { ------------------ | Branch (28258:10): [True: 430, False: 28] ------------------ 28259| 430| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28260| 430| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 28261| 430| wuffs_base__poke_u32le__no_bounds_check( 28262| 430| d + (0 * 4), 28263| 430| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28264| | 28265| 430| s += 1 * 2; 28266| 430| d += 1 * 4; 28267| 430| n -= 1; 28268| 430| } 28269| | 28270| 28| return len; 28271| 28|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src: 27668| 14| size_t src_len) { 27669| 14| size_t dst_len8 = dst_len / 8; 27670| 14| size_t src_len2 = src_len / 2; 27671| 14| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (27671:16): [True: 9, False: 5] ------------------ 27672| 14| uint8_t* d = dst_ptr; 27673| 14| const uint8_t* s = src_ptr; 27674| | 27675| 14| size_t n = len; 27676| 152| while (n >= 1) { ------------------ | Branch (27676:10): [True: 138, False: 14] ------------------ 27677| 138| uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) | 27678| 138| ((uint64_t)(s[0]) * 0x0000010101010101); 27679| 138| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 27680| | 27681| 138| s += 1 * 2; 27682| 138| d += 1 * 8; 27683| 138| n -= 1; 27684| 138| } 27685| 14| return len; 27686| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over: 27695| 30| size_t src_len) { 27696| 30| size_t dst_len8 = dst_len / 8; 27697| 30| size_t src_len2 = src_len / 2; 27698| 30| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (27698:16): [True: 12, False: 18] ------------------ 27699| 30| uint8_t* d = dst_ptr; 27700| 30| const uint8_t* s = src_ptr; 27701| | 27702| 30| size_t n = len; 27703| 250| while (n >= 1) { ------------------ | Branch (27703:10): [True: 220, False: 30] ------------------ 27704| 220| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27705| 220| uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) | 27706| 220| ((uint64_t)(s[0]) * 0x0000010101010101); 27707| 220| wuffs_base__poke_u64le__no_bounds_check( 27708| 220| d + (0 * 8), 27709| 220| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 27710| | 27711| 220| s += 1 * 2; 27712| 220| d += 1 * 8; 27713| 220| n -= 1; 27714| 220| } 27715| 30| return len; 27716| 30|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx: 24761| 1.72k| uint64_t src_nonpremul) { 24762| | // Extract components. 24763| | // 24764| | // If the destination is transparent then SRC_OVER is equivalent to SRC: just 24765| | // return src_nonpremul. This isn't just an optimization (skipping the rest 24766| | // of the function's computation). It also preserves the nonpremul 24767| | // distinction between e.g. transparent red and transparent blue that would 24768| | // otherwise be lost by converting from nonpremul to premul and back. 24769| 1.72k| uint64_t da = 0xFFFF & (dst_nonpremul >> 48); 24770| 1.72k| if (da == 0) { ------------------ | Branch (24770:7): [True: 296, False: 1.42k] ------------------ 24771| 296| return src_nonpremul; 24772| 296| } 24773| 1.42k| uint64_t dr = 0xFFFF & (dst_nonpremul >> 32); 24774| 1.42k| uint64_t dg = 0xFFFF & (dst_nonpremul >> 16); 24775| 1.42k| uint64_t db = 0xFFFF & (dst_nonpremul >> 0); 24776| 1.42k| uint64_t sa = 0xFFFF & (src_nonpremul >> 48); 24777| 1.42k| uint64_t sr = 0xFFFF & (src_nonpremul >> 32); 24778| 1.42k| uint64_t sg = 0xFFFF & (src_nonpremul >> 16); 24779| 1.42k| uint64_t sb = 0xFFFF & (src_nonpremul >> 0); 24780| | 24781| | // Convert dst from nonpremul to premul. 24782| 1.42k| dr = (dr * da) / 0xFFFF; 24783| 1.42k| dg = (dg * da) / 0xFFFF; 24784| 1.42k| db = (db * da) / 0xFFFF; 24785| | 24786| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24787| 1.42k| uint64_t ia = 0xFFFF - sa; 24788| | 24789| | // Composite src (nonpremul) over dst (premul). 24790| 1.42k| da = sa + ((da * ia) / 0xFFFF); 24791| 1.42k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 24792| 1.42k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 24793| 1.42k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 24794| | 24795| | // Convert dst from premul to nonpremul. 24796| 1.42k| if (da != 0) { ------------------ | Branch (24796:7): [True: 1.42k, False: 0] ------------------ 24797| 1.42k| dr = (dr * 0xFFFF) / da; 24798| 1.42k| dg = (dg * 0xFFFF) / da; 24799| 1.42k| db = (db * 0xFFFF) / da; 24800| 1.42k| } 24801| | 24802| | // Combine components. 24803| 1.42k| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 24804| 1.72k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul: 30653| 238| wuffs_base__pixel_blend blend) { 30654| 238| switch (dst_pixfmt.repr) { ------------------ | Branch (30654:11): [True: 217, False: 21] ------------------ 30655| 41| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 41|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (30655:5): [True: 41, False: 197] ------------------ 30656| 41| switch (blend) { ------------------ | Branch (30656:15): [True: 41, False: 0] ------------------ 30657| 22| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 22|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30657:9): [True: 22, False: 19] ------------------ 30658| 22| if (wuffs_private_impl__swizzle_squash_align4_y_8888( ------------------ | Branch (30658:15): [True: 0, False: 22] ------------------ 30659| 22| dst_palette.ptr, dst_palette.len, src_palette.ptr, 30660| 22| src_palette.len, true) != 30661| 22| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 22|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30662| 0| return NULL; 30663| 0| } 30664| 22| return wuffs_private_impl__swizzle_y__index__src; 30665| 19| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30665:9): [True: 19, False: 22] ------------------ 30666| 19| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30666:15): [True: 0, False: 19] ------------------ 30667| 19| src_palette) != 30668| 19| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 19|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30669| 0| return NULL; 30670| 0| } 30671| 19| return wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over; 30672| 41| } 30673| 0| return NULL; 30674| | 30675| 18| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4842| 18|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (30675:5): [True: 18, False: 220] ------------------ 30676| 18| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30676:11): [True: 0, False: 18] ------------------ 30677| 18| src_palette) != 30678| 18| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 18|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30679| 0| return NULL; 30680| 0| } 30681| 18| switch (blend) { ------------------ | Branch (30681:15): [True: 14, False: 4] ------------------ 30682| 14| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30682:9): [True: 14, False: 4] ------------------ 30683| 14| return wuffs_private_impl__swizzle_copy_1_1; 30684| 18| } 30685| 4| return NULL; 30686| | 30687| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (30687:5): [True: 19, False: 219] ------------------ 30688| 19| switch (blend) { ------------------ | Branch (30688:15): [True: 19, False: 0] ------------------ 30689| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30689:9): [True: 1, False: 18] ------------------ 30690| 1| if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888( ------------------ | Branch (30690:15): [True: 0, False: 1] ------------------ 30691| 1| dst_palette.ptr, dst_palette.len, src_palette.ptr, 30692| 1| src_palette.len, true) != 30693| 1| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 1|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30694| 0| return NULL; 30695| 0| } 30696| 1| return wuffs_private_impl__swizzle_bgr_565__index__src; 30697| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30697:9): [True: 18, False: 1] ------------------ 30698| 18| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30698:15): [True: 0, False: 18] ------------------ 30699| 18| src_palette) != 30700| 18| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 18|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30701| 0| return NULL; 30702| 0| } 30703| 18| return wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over; 30704| 19| } 30705| 0| return NULL; 30706| | 30707| 18| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (30707:5): [True: 18, False: 220] ------------------ 30708| 18| switch (blend) { ------------------ | Branch (30708:15): [True: 18, False: 0] ------------------ 30709| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30709:9): [True: 9, False: 9] ------------------ 30710| 9| if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src( ------------------ | Branch (30710:15): [True: 0, False: 9] ------------------ 30711| 9| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30712| 9| src_palette.len) != 30713| 9| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 9|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30714| 0| return NULL; 30715| 0| } 30716| 9| return wuffs_private_impl__swizzle_xxx__index__src; 30717| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30717:9): [True: 9, False: 9] ------------------ 30718| 9| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30718:15): [True: 0, False: 9] ------------------ 30719| 9| src_palette) != 30720| 9| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 9|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30721| 0| return NULL; 30722| 0| } 30723| 9| return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over; 30724| 18| } 30725| 0| return NULL; 30726| | 30727| 23| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 23|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (30727:5): [True: 23, False: 215] ------------------ 30728| 23| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30728:11): [True: 0, False: 23] ------------------ 30729| 23| src_palette) != 30730| 23| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 23|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30731| 0| return NULL; 30732| 0| } 30733| 23| switch (blend) { ------------------ | Branch (30733:15): [True: 23, False: 0] ------------------ 30734| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30734:9): [True: 4, False: 19] ------------------ 30735| 4| return wuffs_private_impl__swizzle_xxxx__index__src; 30736| 19| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30736:9): [True: 19, False: 4] ------------------ 30737| 19| return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over; 30738| 23| } 30739| 0| return NULL; 30740| | 30741| 52| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 52|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (30741:5): [True: 52, False: 186] ------------------ 30742| 52| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30742:11): [True: 0, False: 52] ------------------ 30743| 52| src_palette) != 30744| 52| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 52|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30745| 0| return NULL; 30746| 0| } 30747| 52| switch (blend) { ------------------ | Branch (30747:15): [True: 52, False: 0] ------------------ 30748| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30748:9): [True: 7, False: 45] ------------------ 30749| 7| return wuffs_private_impl__swizzle_xxxxxxxx__index__src; 30750| 45| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 45|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30750:9): [True: 45, False: 7] ------------------ 30751| 45| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over; 30752| 52| } 30753| 0| return NULL; 30754| | 30755| 10| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (30755:5): [True: 10, False: 228] ------------------ 30756| 10| switch (blend) { ------------------ | Branch (30756:15): [True: 10, False: 0] ------------------ 30757| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30757:9): [True: 2, False: 8] ------------------ 30758| 2| if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src( ------------------ | Branch (30758:15): [True: 0, False: 2] ------------------ 30759| 2| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30760| 2| src_palette.len) != 30761| 2| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 2|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30762| 0| return NULL; 30763| 0| } 30764| 2| return wuffs_private_impl__swizzle_xxxx__index__src; 30765| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30765:9): [True: 8, False: 2] ------------------ 30766| 8| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30766:15): [True: 0, False: 8] ------------------ 30767| 8| src_palette) != 30768| 8| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 8|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30769| 0| return NULL; 30770| 0| } 30771| 8| return wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over; 30772| 10| } 30773| 0| return NULL; 30774| | 30775| 19| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 19|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (30775:5): [True: 19, False: 219] ------------------ 30776| 19| switch (blend) { ------------------ | Branch (30776:15): [True: 19, False: 0] ------------------ 30777| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30777:9): [True: 10, False: 9] ------------------ 30778| 10| if (wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src( ------------------ | Branch (30778:15): [True: 0, False: 10] ------------------ 30779| 10| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30780| 10| src_palette.len) != 30781| 10| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 10|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30782| 0| return NULL; 30783| 0| } 30784| 10| return wuffs_private_impl__swizzle_xxx__index__src; 30785| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30785:9): [True: 9, False: 10] ------------------ 30786| 9| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (30786:15): [True: 0, False: 9] ------------------ 30787| 9| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30788| 9| src_palette.len) != 30789| 9| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 9|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30790| 0| return NULL; 30791| 0| } 30792| 9| return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over; 30793| 19| } 30794| 0| return NULL; 30795| | 30796| 9| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (30796:5): [True: 9, False: 229] ------------------ 30797| 9| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (30797:11): [True: 0, False: 9] ------------------ 30798| 9| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30799| 9| src_palette.len) != 30800| 9| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 9|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30801| 0| return NULL; 30802| 0| } 30803| 9| switch (blend) { ------------------ | Branch (30803:15): [True: 9, False: 0] ------------------ 30804| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30804:9): [True: 2, False: 7] ------------------ 30805| 2| return wuffs_private_impl__swizzle_xxxx__index__src; 30806| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30806:9): [True: 7, False: 2] ------------------ 30807| 7| return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over; 30808| 9| } 30809| 0| return NULL; 30810| | 30811| 8| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 8|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (30811:5): [True: 8, False: 230] ------------------ 30812| 8| switch (blend) { ------------------ | Branch (30812:15): [True: 8, False: 0] ------------------ 30813| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30813:9): [True: 3, False: 5] ------------------ 30814| 3| if (wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src( ------------------ | Branch (30814:15): [True: 0, False: 3] ------------------ 30815| 3| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30816| 3| src_palette.len) != 30817| 3| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 3|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30818| 0| return NULL; 30819| 0| } 30820| 3| return wuffs_private_impl__swizzle_xxxx__index__src; 30821| 5| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30821:9): [True: 5, False: 3] ------------------ 30822| 5| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (30822:15): [True: 0, False: 5] ------------------ 30823| 5| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30824| 5| src_palette.len) != 30825| 5| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 5|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30826| 0| return NULL; 30827| 0| } 30828| 5| return wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over; 30829| 8| } 30830| 0| return NULL; 30831| | 30832| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (30832:5): [True: 0, False: 238] ------------------ 30833| | // TODO. 30834| 0| break; 30835| 238| } 30836| 21| return NULL; 30837| 238|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_y_8888: 25044| 60| bool nonpremul) { 25045| 60| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25045:17): [True: 0, False: 60] ------------------ 25046| 60| uint8_t* d = dst_ptr; 25047| 60| const uint8_t* s = src_ptr; 25048| | 25049| 60| size_t n = len; 25050| 15.4k| while (n--) { ------------------ | Branch (25050:10): [True: 15.3k, False: 60] ------------------ 25051| 15.3k| uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s); 25052| 15.3k| if (nonpremul) { ------------------ | Branch (25052:9): [True: 5.63k, False: 9.72k] ------------------ 25053| 5.63k| argb = 25054| 5.63k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb); 25055| 5.63k| } 25056| 15.3k| uint32_t s0 = wuffs_base__color_u32_argb_premul__as__color_u8_gray(argb); 25057| 15.3k| wuffs_base__poke_u32le__no_bounds_check( 25058| 15.3k| d, (argb & 0xFF000000) | (s0 * 0x010101)); 25059| 15.3k| s += 4; 25060| 15.3k| d += 4; 25061| 15.3k| } 25062| 60| return len; 25063| 60|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index__src: 30253| 27| size_t src_len) { 30254| 27| if (dst_palette_len != ------------------ | Branch (30254:7): [True: 0, False: 27] ------------------ 30255| 27| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 27|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30256| 0| return 0; 30257| 0| } 30258| 27| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (30258:16): [True: 5, False: 22] ------------------ 30259| 27| uint8_t* d = dst_ptr; 30260| 27| const uint8_t* s = src_ptr; 30261| 27| size_t n = len; 30262| | 30263| | // TODO: unroll. 30264| | 30265| 1.86k| while (n >= 1) { ------------------ | Branch (30265:10): [True: 1.83k, False: 27] ------------------ 30266| 1.83k| d[0] = dst_palette_ptr[(size_t)s[0] * 4]; 30267| | 30268| 1.83k| s += 1 * 1; 30269| 1.83k| d += 1 * 1; 30270| 1.83k| n -= 1; 30271| 1.83k| } 30272| | 30273| 27| return len; 30274| 27|} pixel_swizzler_fuzzer.c:wuffs_private_impl__slice_u8__copy_from_slice: 18298| 349| wuffs_base__slice_u8 src) { 18299| 349| size_t len = dst.len < src.len ? dst.len : src.len; ------------------ | Branch (18299:16): [True: 0, False: 349] ------------------ 18300| 349| if (len > 0) { ------------------ | Branch (18300:7): [True: 349, False: 0] ------------------ 18301| 349| memmove(dst.ptr, src.ptr, len); 18302| 349| } 18303| 349| return len; 18304| 349|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over: 30283| 19| size_t src_len) { 30284| 19| if (dst_palette_len != ------------------ | Branch (30284:7): [True: 0, False: 19] ------------------ 30285| 19| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 19|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30286| 0| return 0; 30287| 0| } 30288| 19| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (30288:16): [True: 2, False: 17] ------------------ 30289| 19| uint8_t* d = dst_ptr; 30290| 19| const uint8_t* s = src_ptr; 30291| 19| size_t n = len; 30292| | 30293| | // TODO: unroll. 30294| | 30295| 2.06k| while (n >= 1) { ------------------ | Branch (30295:10): [True: 2.04k, False: 19] ------------------ 30296| 2.04k| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30297| 2.04k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30298| 2.04k| ((size_t)s[0] * 4)); 30299| 2.04k| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30300| 2.04k| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 30301| | 30302| 2.04k| s += 1 * 1; 30303| 2.04k| d += 1 * 1; 30304| 2.04k| n -= 1; 30305| 2.04k| } 30306| | 30307| 19| return len; 30308| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_bgr_565_8888: 25013| 37| bool nonpremul) { 25014| 37| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25014:17): [True: 0, False: 37] ------------------ 25015| 37| uint8_t* d = dst_ptr; 25016| 37| const uint8_t* s = src_ptr; 25017| | 25018| 37| size_t n = len; 25019| 9.50k| while (n--) { ------------------ | Branch (25019:10): [True: 9.47k, False: 37] ------------------ 25020| 9.47k| uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s); 25021| 9.47k| if (nonpremul) { ------------------ | Branch (25021:9): [True: 256, False: 9.21k] ------------------ 25022| 256| argb = 25023| 256| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb); 25024| 256| } 25025| 9.47k| uint32_t b5 = 0x1F & (argb >> (8 - 5)); 25026| 9.47k| uint32_t g6 = 0x3F & (argb >> (16 - 6)); 25027| 9.47k| uint32_t r5 = 0x1F & (argb >> (24 - 5)); 25028| 9.47k| uint32_t alpha = argb & 0xFF000000; 25029| 9.47k| wuffs_base__poke_u32le__no_bounds_check( 25030| 9.47k| d, alpha | (r5 << 11) | (g6 << 5) | (b5 << 0)); 25031| 9.47k| s += 4; 25032| 9.47k| d += 4; 25033| 9.47k| } 25034| 37| return len; 25035| 37|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index__src: 26084| 9| size_t src_len) { 26085| 9| if (dst_palette_len != ------------------ | Branch (26085:7): [True: 0, False: 9] ------------------ 26086| 9| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 9|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26087| 0| return 0; 26088| 0| } 26089| 9| size_t dst_len2 = dst_len / 2; 26090| 9| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26090:16): [True: 2, False: 7] ------------------ 26091| 9| uint8_t* d = dst_ptr; 26092| 9| const uint8_t* s = src_ptr; 26093| 9| size_t n = len; 26094| | 26095| 9| const size_t loop_unroll_count = 4; 26096| | 26097| 80| while (n >= loop_unroll_count) { ------------------ | Branch (26097:10): [True: 71, False: 9] ------------------ 26098| 71| wuffs_base__poke_u16le__no_bounds_check( 26099| 71| d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check( 26100| 71| dst_palette_ptr + ((size_t)s[0] * 4))); 26101| 71| wuffs_base__poke_u16le__no_bounds_check( 26102| 71| d + (1 * 2), wuffs_base__peek_u16le__no_bounds_check( 26103| 71| dst_palette_ptr + ((size_t)s[1] * 4))); 26104| 71| wuffs_base__poke_u16le__no_bounds_check( 26105| 71| d + (2 * 2), wuffs_base__peek_u16le__no_bounds_check( 26106| 71| dst_palette_ptr + ((size_t)s[2] * 4))); 26107| 71| wuffs_base__poke_u16le__no_bounds_check( 26108| 71| d + (3 * 2), wuffs_base__peek_u16le__no_bounds_check( 26109| 71| dst_palette_ptr + ((size_t)s[3] * 4))); 26110| | 26111| 71| s += loop_unroll_count * 1; 26112| 71| d += loop_unroll_count * 2; 26113| 71| n -= loop_unroll_count; 26114| 71| } 26115| | 26116| 23| while (n >= 1) { ------------------ | Branch (26116:10): [True: 14, False: 9] ------------------ 26117| 14| wuffs_base__poke_u16le__no_bounds_check( 26118| 14| d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check( 26119| 14| dst_palette_ptr + ((size_t)s[0] * 4))); 26120| | 26121| 14| s += 1 * 1; 26122| 14| d += 1 * 2; 26123| 14| n -= 1; 26124| 14| } 26125| | 26126| 9| return len; 26127| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over: 26136| 18| size_t src_len) { 26137| 18| if (dst_palette_len != ------------------ | Branch (26137:7): [True: 0, False: 18] ------------------ 26138| 18| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 18|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26139| 0| return 0; 26140| 0| } 26141| 18| size_t dst_len2 = dst_len / 2; 26142| 18| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26142:16): [True: 6, False: 12] ------------------ 26143| 18| uint8_t* d = dst_ptr; 26144| 18| const uint8_t* s = src_ptr; 26145| 18| size_t n = len; 26146| | 26147| | // TODO: unroll. 26148| | 26149| 585| while (n >= 1) { ------------------ | Branch (26149:10): [True: 567, False: 18] ------------------ 26150| 567| uint32_t d0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 26151| 567| wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2))); 26152| 567| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 26153| 567| ((size_t)s[0] * 4)); 26154| 567| wuffs_base__poke_u16le__no_bounds_check( 26155| 567| d + (0 * 2), 26156| 567| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26157| 567| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0))); 26158| | 26159| 567| s += 1 * 1; 26160| 567| d += 1 * 2; 26161| 567| n -= 1; 26162| 567| } 26163| | 26164| 18| return len; 26165| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src: 27727| 29| size_t src_len) { 27728| 29| size_t dst_len4 = dst_len / 4; 27729| 29| size_t src_len4 = src_len / 4; 27730| 29| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27730:16): [True: 8, False: 21] ------------------ 27731| 29| uint8_t* d = dst_ptr; 27732| 29| const uint8_t* s = src_ptr; 27733| 29| size_t n = len; 27734| | 27735| | // TODO: unroll. 27736| | 27737| 3.06k| while (n >= 1) { ------------------ | Branch (27737:10): [True: 3.03k, False: 29] ------------------ 27738| 3.03k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27739| 3.03k| wuffs_base__poke_u32le__no_bounds_check( 27740| 3.03k| d + (0 * 4), 27741| 3.03k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 27742| | 27743| 3.03k| s += 1 * 4; 27744| 3.03k| d += 1 * 4; 27745| 3.03k| n -= 1; 27746| 3.03k| } 27747| | 27748| 29| return len; 27749| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index__src: 28903| 28| size_t src_len) { 28904| 28| if (dst_palette_len != ------------------ | Branch (28904:7): [True: 0, False: 28] ------------------ 28905| 28| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 28|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 28906| 0| return 0; 28907| 0| } 28908| 28| size_t dst_len3 = dst_len / 3; 28909| 28| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (28909:16): [True: 15, False: 13] ------------------ 28910| 28| uint8_t* d = dst_ptr; 28911| 28| const uint8_t* s = src_ptr; 28912| 28| size_t n = len; 28913| | 28914| 28| const size_t loop_unroll_count = 4; 28915| | 28916| | // The comparison in the while condition is ">", not ">=", because with 28917| | // ">=", the last 4-byte store could write past the end of the dst slice. 28918| | // 28919| | // Each 4-byte store writes one too many bytes, but a subsequent store 28920| | // will overwrite that with the correct byte. There is always another 28921| | // store, whether a 4-byte store in this loop or a 1-byte store in the 28922| | // next loop. 28923| 181| while (n > loop_unroll_count) { ------------------ | Branch (28923:10): [True: 153, False: 28] ------------------ 28924| 153| wuffs_base__poke_u32le__no_bounds_check( 28925| 153| d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check( 28926| 153| dst_palette_ptr + ((size_t)s[0] * 4))); 28927| 153| wuffs_base__poke_u32le__no_bounds_check( 28928| 153| d + (1 * 3), wuffs_base__peek_u32le__no_bounds_check( 28929| 153| dst_palette_ptr + ((size_t)s[1] * 4))); 28930| 153| wuffs_base__poke_u32le__no_bounds_check( 28931| 153| d + (2 * 3), wuffs_base__peek_u32le__no_bounds_check( 28932| 153| dst_palette_ptr + ((size_t)s[2] * 4))); 28933| 153| wuffs_base__poke_u32le__no_bounds_check( 28934| 153| d + (3 * 3), wuffs_base__peek_u32le__no_bounds_check( 28935| 153| dst_palette_ptr + ((size_t)s[3] * 4))); 28936| | 28937| 153| s += loop_unroll_count * 1; 28938| 153| d += loop_unroll_count * 3; 28939| 153| n -= loop_unroll_count; 28940| 153| } 28941| | 28942| 85| while (n >= 1) { ------------------ | Branch (28942:10): [True: 57, False: 28] ------------------ 28943| 57| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 28944| 57| ((size_t)s[0] * 4)); 28945| 57| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 28946| | 28947| 57| s += 1 * 1; 28948| 57| d += 1 * 3; 28949| 57| n -= 1; 28950| 57| } 28951| | 28952| 28| return len; 28953| 28|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over: 28962| 18| size_t src_len) { 28963| 18| if (dst_palette_len != ------------------ | Branch (28963:7): [True: 0, False: 18] ------------------ 28964| 18| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 18|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 28965| 0| return 0; 28966| 0| } 28967| 18| size_t dst_len3 = dst_len / 3; 28968| 18| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (28968:16): [True: 8, False: 10] ------------------ 28969| 18| uint8_t* d = dst_ptr; 28970| 18| const uint8_t* s = src_ptr; 28971| 18| size_t n = len; 28972| | 28973| | // TODO: unroll. 28974| | 28975| 535| while (n >= 1) { ------------------ | Branch (28975:10): [True: 517, False: 18] ------------------ 28976| 517| uint32_t d0 = 28977| 517| wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000; 28978| 517| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 28979| 517| ((size_t)s[0] * 4)); 28980| 517| wuffs_base__poke_u24le__no_bounds_check( 28981| 517| d + (0 * 3), 28982| 517| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28983| | 28984| 517| s += 1 * 1; 28985| 517| d += 1 * 3; 28986| 517| n -= 1; 28987| 517| } 28988| | 28989| 18| return len; 28990| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index__src: 29242| 24| size_t src_len) { 29243| 24| if (dst_palette_len != ------------------ | Branch (29243:7): [True: 0, False: 24] ------------------ 29244| 24| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 24|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29245| 0| return 0; 29246| 0| } 29247| 24| size_t dst_len4 = dst_len / 4; 29248| 24| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (29248:16): [True: 16, False: 8] ------------------ 29249| 24| uint8_t* d = dst_ptr; 29250| 24| const uint8_t* s = src_ptr; 29251| 24| size_t n = len; 29252| | 29253| 24| const size_t loop_unroll_count = 4; 29254| | 29255| 158| while (n >= loop_unroll_count) { ------------------ | Branch (29255:10): [True: 134, False: 24] ------------------ 29256| 134| wuffs_base__poke_u32le__no_bounds_check( 29257| 134| d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check( 29258| 134| dst_palette_ptr + ((size_t)s[0] * 4))); 29259| 134| wuffs_base__poke_u32le__no_bounds_check( 29260| 134| d + (1 * 4), wuffs_base__peek_u32le__no_bounds_check( 29261| 134| dst_palette_ptr + ((size_t)s[1] * 4))); 29262| 134| wuffs_base__poke_u32le__no_bounds_check( 29263| 134| d + (2 * 4), wuffs_base__peek_u32le__no_bounds_check( 29264| 134| dst_palette_ptr + ((size_t)s[2] * 4))); 29265| 134| wuffs_base__poke_u32le__no_bounds_check( 29266| 134| d + (3 * 4), wuffs_base__peek_u32le__no_bounds_check( 29267| 134| dst_palette_ptr + ((size_t)s[3] * 4))); 29268| | 29269| 134| s += loop_unroll_count * 1; 29270| 134| d += loop_unroll_count * 4; 29271| 134| n -= loop_unroll_count; 29272| 134| } 29273| | 29274| 54| while (n >= 1) { ------------------ | Branch (29274:10): [True: 30, False: 24] ------------------ 29275| 30| wuffs_base__poke_u32le__no_bounds_check( 29276| 30| d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check( 29277| 30| dst_palette_ptr + ((size_t)s[0] * 4))); 29278| | 29279| 30| s += 1 * 1; 29280| 30| d += 1 * 4; 29281| 30| n -= 1; 29282| 30| } 29283| | 29284| 24| return len; 29285| 24|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over: 27105| 26| size_t src_len) { 27106| 26| if (dst_palette_len != ------------------ | Branch (27106:7): [True: 0, False: 26] ------------------ 27107| 26| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 26|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 27108| 0| return 0; 27109| 0| } 27110| 26| size_t dst_len4 = dst_len / 4; 27111| 26| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (27111:16): [True: 15, False: 11] ------------------ 27112| 26| uint8_t* d = dst_ptr; 27113| 26| const uint8_t* s = src_ptr; 27114| 26| size_t n = len; 27115| | 27116| | // TODO: unroll. 27117| | 27118| 295| while (n >= 1) { ------------------ | Branch (27118:10): [True: 269, False: 26] ------------------ 27119| 269| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27120| 269| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 27121| 269| ((size_t)s[0] * 4)); 27122| 269| wuffs_base__poke_u32le__no_bounds_check( 27123| 269| d + (0 * 4), 27124| 269| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27125| | 27126| 269| s += 1 * 1; 27127| 269| d += 1 * 4; 27128| 269| n -= 1; 27129| 269| } 27130| | 27131| 26| return len; 27132| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index__src: 29485| 15| size_t src_len) { 29486| 15| if (dst_palette_len != ------------------ | Branch (29486:7): [True: 0, False: 15] ------------------ 29487| 15| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 15|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29488| 0| return 0; 29489| 0| } 29490| 15| size_t dst_len8 = dst_len / 8; 29491| 15| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (29491:16): [True: 7, False: 8] ------------------ 29492| 15| uint8_t* d = dst_ptr; 29493| 15| const uint8_t* s = src_ptr; 29494| 15| size_t n = len; 29495| | 29496| 156| while (n >= 1) { ------------------ | Branch (29496:10): [True: 141, False: 15] ------------------ 29497| 141| wuffs_base__poke_u64le__no_bounds_check( 29498| 141| d + (0 * 8), wuffs_base__color_u32__as__color_u64( 29499| 141| wuffs_base__peek_u32le__no_bounds_check( 29500| 141| dst_palette_ptr + ((size_t)s[0] * 4)))); 29501| | 29502| 141| s += 1 * 1; 29503| 141| d += 1 * 8; 29504| 141| n -= 1; 29505| 141| } 29506| | 29507| 15| return len; 29508| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over: 27506| 45| size_t src_len) { 27507| 45| if (dst_palette_len != ------------------ | Branch (27507:7): [True: 0, False: 45] ------------------ 27508| 45| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 45|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 27509| 0| return 0; 27510| 0| } 27511| 45| size_t dst_len8 = dst_len / 8; 27512| 45| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (27512:16): [True: 28, False: 17] ------------------ 27513| 45| uint8_t* d = dst_ptr; 27514| 45| const uint8_t* s = src_ptr; 27515| 45| size_t n = len; 27516| | 27517| 377| while (n >= 1) { ------------------ | Branch (27517:10): [True: 332, False: 45] ------------------ 27518| 332| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27519| 332| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 27520| 332| wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 27521| 332| ((size_t)s[0] * 4))); 27522| 332| wuffs_base__poke_u64le__no_bounds_check( 27523| 332| d + (0 * 8), 27524| 332| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 27525| | 27526| 332| s += 1 * 1; 27527| 332| d += 1 * 8; 27528| 332| n -= 1; 27529| 332| } 27530| | 27531| 45| return len; 27532| 45|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over: 27951| 13| size_t src_len) { 27952| 13| if (dst_palette_len != ------------------ | Branch (27952:7): [True: 0, False: 13] ------------------ 27953| 13| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 13|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 27954| 0| return 0; 27955| 0| } 27956| 13| size_t dst_len4 = dst_len / 4; 27957| 13| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (27957:16): [True: 9, False: 4] ------------------ 27958| 13| uint8_t* d = dst_ptr; 27959| 13| const uint8_t* s = src_ptr; 27960| 13| size_t n = len; 27961| | 27962| | // TODO: unroll. 27963| | 27964| 271| while (n >= 1) { ------------------ | Branch (27964:10): [True: 258, False: 13] ------------------ 27965| 258| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27966| 258| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 27967| 258| ((size_t)s[0] * 4)); 27968| 258| wuffs_base__poke_u32le__no_bounds_check( 27969| 258| d + (0 * 4), 27970| 258| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 27971| | 27972| 258| s += 1 * 1; 27973| 258| d += 1 * 4; 27974| 258| n -= 1; 27975| 258| } 27976| | 27977| 13| return len; 27978| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src: 27987| 30| size_t src_len) { 27988| 30| size_t dst_len4 = dst_len / 4; 27989| 30| size_t src_len4 = src_len / 4; 27990| 30| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27990:16): [True: 6, False: 24] ------------------ 27991| 30| uint8_t* d = dst_ptr; 27992| 30| const uint8_t* s = src_ptr; 27993| 30| size_t n = len; 27994| | 27995| | // TODO: unroll. 27996| | 27997| 3.52k| while (n >= 1) { ------------------ | Branch (27997:10): [True: 3.49k, False: 30] ------------------ 27998| 3.49k| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27999| 3.49k| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28000| 3.49k| wuffs_base__poke_u32le__no_bounds_check( 28001| 3.49k| d + (0 * 4), 28002| 3.49k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28003| | 28004| 3.49k| s += 1 * 4; 28005| 3.49k| d += 1 * 4; 28006| 3.49k| n -= 1; 28007| 3.49k| } 28008| | 28009| 30| return len; 28010| 30|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx: 25146| 115| size_t src_len) { 25147| 115| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25147:17): [True: 0, False: 115] ------------------ 25148| 115| uint8_t* d = dst_ptr; 25149| 115| const uint8_t* s = src_ptr; 25150| | 25151| 115| size_t n = len; 25152| 29.5k| while (n--) { ------------------ | Branch (25152:10): [True: 29.4k, False: 115] ------------------ 25153| 29.4k| uint8_t s0 = s[0]; 25154| 29.4k| uint8_t s1 = s[1]; 25155| 29.4k| uint8_t s2 = s[2]; 25156| 29.4k| uint8_t s3 = s[3]; 25157| 29.4k| d[0] = s2; 25158| 29.4k| d[1] = s1; 25159| 29.4k| d[2] = s0; 25160| 29.4k| d[3] = s3; 25161| 29.4k| s += 4; 25162| 29.4k| d += 4; 25163| 29.4k| } 25164| 115| return len; 25165| 115|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary: 30845| 387| wuffs_base__pixel_blend blend) { 30846| 387| switch (dst_pixfmt.repr) { ------------------ | Branch (30846:11): [True: 368, False: 19] ------------------ 30847| 38| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 38|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (30847:5): [True: 38, False: 349] ------------------ 30848| 38| if (wuffs_private_impl__swizzle_squash_align4_y_8888( ------------------ | Branch (30848:11): [True: 0, False: 38] ------------------ 30849| 38| dst_palette.ptr, dst_palette.len, src_palette.ptr, 30850| 38| src_palette.len, false) != 30851| 38| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 38|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30852| 0| return NULL; 30853| 0| } 30854| 38| switch (blend) { ------------------ | Branch (30854:15): [True: 38, False: 0] ------------------ 30855| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30855:9): [True: 5, False: 33] ------------------ 30856| 5| return wuffs_private_impl__swizzle_y__index__src; 30857| 33| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 33|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30857:9): [True: 33, False: 5] ------------------ 30858| 33| return wuffs_private_impl__swizzle_y__index_binary_alpha__src_over; 30859| 38| } 30860| 0| return NULL; 30861| | 30862| 4| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4842| 4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (30862:5): [True: 4, False: 383] ------------------ 30863| 4| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4843| 4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (30863:5): [True: 0, False: 387] ------------------ 30864| 11| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4844| 11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (30864:5): [True: 7, False: 380] ------------------ 30865| 11| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30865:11): [True: 0, False: 11] ------------------ 30866| 11| src_palette) != 30867| 11| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30868| 0| return NULL; 30869| 0| } 30870| 11| switch (blend) { ------------------ | Branch (30870:15): [True: 4, False: 7] ------------------ 30871| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30871:9): [True: 4, False: 7] ------------------ 30872| 4| return wuffs_private_impl__swizzle_copy_1_1; 30873| 11| } 30874| 7| return NULL; 30875| | 30876| 36| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 36|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (30876:5): [True: 36, False: 351] ------------------ 30877| 36| if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888( ------------------ | Branch (30877:11): [True: 0, False: 36] ------------------ 30878| 36| dst_palette.ptr, dst_palette.len, src_palette.ptr, 30879| 36| src_palette.len, false) != 30880| 36| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 36|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30881| 0| return NULL; 30882| 0| } 30883| 36| switch (blend) { ------------------ | Branch (30883:15): [True: 36, False: 0] ------------------ 30884| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30884:9): [True: 8, False: 28] ------------------ 30885| 8| return wuffs_private_impl__swizzle_bgr_565__index__src; 30886| 28| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 28|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30886:9): [True: 28, False: 8] ------------------ 30887| 28| return wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over; 30888| 36| } 30889| 0| return NULL; 30890| | 30891| 70| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 70|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (30891:5): [True: 70, False: 317] ------------------ 30892| 70| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30892:11): [True: 0, False: 70] ------------------ 30893| 70| src_palette) != 30894| 70| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 70|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30895| 0| return NULL; 30896| 0| } 30897| 70| switch (blend) { ------------------ | Branch (30897:15): [True: 70, False: 0] ------------------ 30898| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30898:9): [True: 8, False: 62] ------------------ 30899| 8| return wuffs_private_impl__swizzle_xxx__index__src; 30900| 62| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 62|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30900:9): [True: 62, False: 8] ------------------ 30901| 62| return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over; 30902| 70| } 30903| 0| return NULL; 30904| | 30905| 39| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 39|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (30905:5): [True: 39, False: 348] ------------------ 30906| 76| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 76|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (30906:5): [True: 37, False: 350] ------------------ 30907| 76| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 76|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (30907:5): [True: 0, False: 387] ------------------ 30908| 76| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30908:11): [True: 0, False: 76] ------------------ 30909| 76| src_palette) != 30910| 76| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 76|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30911| 0| return NULL; 30912| 0| } 30913| 76| switch (blend) { ------------------ | Branch (30913:15): [True: 76, False: 0] ------------------ 30914| 6| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30914:9): [True: 6, False: 70] ------------------ 30915| 6| return wuffs_private_impl__swizzle_xxxx__index__src; 30916| 70| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 70|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30916:9): [True: 70, False: 6] ------------------ 30917| 70| return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over; 30918| 76| } 30919| 0| return NULL; 30920| | 30921| 16| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (30921:5): [True: 16, False: 371] ------------------ 30922| 45| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 45|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (30922:5): [True: 29, False: 358] ------------------ 30923| 45| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (30923:11): [True: 0, False: 45] ------------------ 30924| 45| src_palette) != 30925| 45| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 45|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30926| 0| return NULL; 30927| 0| } 30928| 45| switch (blend) { ------------------ | Branch (30928:15): [True: 45, False: 0] ------------------ 30929| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30929:9): [True: 8, False: 37] ------------------ 30930| 8| return wuffs_private_impl__swizzle_xxxxxxxx__index__src; 30931| 37| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 37|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30931:9): [True: 37, False: 8] ------------------ 30932| 37| return wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over; 30933| 45| } 30934| 0| return NULL; 30935| | 30936| 40| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 40|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (30936:5): [True: 40, False: 347] ------------------ 30937| 40| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (30937:11): [True: 0, False: 40] ------------------ 30938| 40| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30939| 40| src_palette.len) != 30940| 40| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 40|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30941| 0| return NULL; 30942| 0| } 30943| 40| switch (blend) { ------------------ | Branch (30943:15): [True: 40, False: 0] ------------------ 30944| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30944:9): [True: 1, False: 39] ------------------ 30945| 1| return wuffs_private_impl__swizzle_xxx__index__src; 30946| 39| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 39|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30946:9): [True: 39, False: 1] ------------------ 30947| 39| return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over; 30948| 40| } 30949| 0| return NULL; 30950| | 30951| 28| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 28|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (30951:5): [True: 28, False: 359] ------------------ 30952| 52| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 52|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (30952:5): [True: 24, False: 363] ------------------ 30953| 52| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 52|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (30953:5): [True: 0, False: 387] ------------------ 30954| 52| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (30954:11): [True: 0, False: 52] ------------------ 30955| 52| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 30956| 52| src_palette.len) != 30957| 52| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4784| 52|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30958| 0| return NULL; 30959| 0| } 30960| 52| switch (blend) { ------------------ | Branch (30960:15): [True: 52, False: 0] ------------------ 30961| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (30961:9): [True: 7, False: 45] ------------------ 30962| 7| return wuffs_private_impl__swizzle_xxxx__index__src; 30963| 45| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 45|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (30963:9): [True: 45, False: 7] ------------------ 30964| 45| return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over; 30965| 52| } 30966| 0| return NULL; 30967| 387| } 30968| 19| return NULL; 30969| 387|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_binary_alpha__src_over: 30317| 33| size_t src_len) { 30318| 33| if (dst_palette_len != ------------------ | Branch (30318:7): [True: 0, False: 33] ------------------ 30319| 33| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 33|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30320| 0| return 0; 30321| 0| } 30322| 33| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (30322:16): [True: 7, False: 26] ------------------ 30323| 33| uint8_t* d = dst_ptr; 30324| 33| const uint8_t* s = src_ptr; 30325| 33| size_t n = len; 30326| | 30327| | // TODO: unroll. 30328| | 30329| 2.55k| while (n >= 1) { ------------------ | Branch (30329:10): [True: 2.52k, False: 33] ------------------ 30330| 2.52k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30331| 2.52k| ((size_t)s[0] * 4)); 30332| 2.52k| if (s0) { ------------------ | Branch (30332:9): [True: 2.10k, False: 416] ------------------ 30333| 2.10k| d[0] = (uint8_t)s0; 30334| 2.10k| } 30335| | 30336| 2.52k| s += 1 * 1; 30337| 2.52k| d += 1 * 1; 30338| 2.52k| n -= 1; 30339| 2.52k| } 30340| | 30341| 33| return len; 30342| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over: 26174| 28| size_t src_len) { 26175| 28| if (dst_palette_len != ------------------ | Branch (26175:7): [True: 0, False: 28] ------------------ 26176| 28| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 28|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26177| 0| return 0; 26178| 0| } 26179| 28| size_t dst_len2 = dst_len / 2; 26180| 28| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26180:16): [True: 12, False: 16] ------------------ 26181| 28| uint8_t* d = dst_ptr; 26182| 28| const uint8_t* s = src_ptr; 26183| 28| size_t n = len; 26184| | 26185| | // TODO: unroll. 26186| | 26187| 1.18k| while (n >= 1) { ------------------ | Branch (26187:10): [True: 1.15k, False: 28] ------------------ 26188| 1.15k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 26189| 1.15k| ((size_t)s[0] * 4)); 26190| 1.15k| if (s0) { ------------------ | Branch (26190:9): [True: 1.07k, False: 79] ------------------ 26191| 1.07k| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)s0); 26192| 1.07k| } 26193| | 26194| 1.15k| s += 1 * 1; 26195| 1.15k| d += 1 * 2; 26196| 1.15k| n -= 1; 26197| 1.15k| } 26198| | 26199| 28| return len; 26200| 28|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over: 28999| 101| size_t src_len) { 29000| 101| if (dst_palette_len != ------------------ | Branch (29000:7): [True: 0, False: 101] ------------------ 29001| 101| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 101|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29002| 0| return 0; 29003| 0| } 29004| 101| size_t dst_len3 = dst_len / 3; 29005| 101| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29005:16): [True: 61, False: 40] ------------------ 29006| 101| uint8_t* d = dst_ptr; 29007| 101| const uint8_t* s = src_ptr; 29008| 101| size_t n = len; 29009| | 29010| 101| const size_t loop_unroll_count = 4; 29011| | 29012| 1.06k| while (n >= loop_unroll_count) { ------------------ | Branch (29012:10): [True: 966, False: 101] ------------------ 29013| 966| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29014| 966| ((size_t)s[0] * 4)); 29015| 966| if (s0) { ------------------ | Branch (29015:9): [True: 750, False: 216] ------------------ 29016| 750| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29017| 750| } 29018| 966| uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29019| 966| ((size_t)s[1] * 4)); 29020| 966| if (s1) { ------------------ | Branch (29020:9): [True: 730, False: 236] ------------------ 29021| 730| wuffs_base__poke_u24le__no_bounds_check(d + (1 * 3), s1); 29022| 730| } 29023| 966| uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29024| 966| ((size_t)s[2] * 4)); 29025| 966| if (s2) { ------------------ | Branch (29025:9): [True: 744, False: 222] ------------------ 29026| 744| wuffs_base__poke_u24le__no_bounds_check(d + (2 * 3), s2); 29027| 744| } 29028| 966| uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29029| 966| ((size_t)s[3] * 4)); 29030| 966| if (s3) { ------------------ | Branch (29030:9): [True: 735, False: 231] ------------------ 29031| 735| wuffs_base__poke_u24le__no_bounds_check(d + (3 * 3), s3); 29032| 735| } 29033| | 29034| 966| s += loop_unroll_count * 1; 29035| 966| d += loop_unroll_count * 3; 29036| 966| n -= loop_unroll_count; 29037| 966| } 29038| | 29039| 274| while (n >= 1) { ------------------ | Branch (29039:10): [True: 173, False: 101] ------------------ 29040| 173| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29041| 173| ((size_t)s[0] * 4)); 29042| 173| if (s0) { ------------------ | Branch (29042:9): [True: 146, False: 27] ------------------ 29043| 146| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29044| 146| } 29045| | 29046| 173| s += 1 * 1; 29047| 173| d += 1 * 3; 29048| 173| n -= 1; 29049| 173| } 29050| | 29051| 101| return len; 29052| 101|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over: 29294| 115| size_t src_len) { 29295| 115| if (dst_palette_len != ------------------ | Branch (29295:7): [True: 0, False: 115] ------------------ 29296| 115| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 115|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29297| 0| return 0; 29298| 0| } 29299| 115| size_t dst_len4 = dst_len / 4; 29300| 115| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (29300:16): [True: 78, False: 37] ------------------ 29301| 115| uint8_t* d = dst_ptr; 29302| 115| const uint8_t* s = src_ptr; 29303| 115| size_t n = len; 29304| | 29305| 115| const size_t loop_unroll_count = 4; 29306| | 29307| 1.00k| while (n >= loop_unroll_count) { ------------------ | Branch (29307:10): [True: 885, False: 115] ------------------ 29308| 885| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29309| 885| ((size_t)s[0] * 4)); 29310| 885| if (s0) { ------------------ | Branch (29310:9): [True: 720, False: 165] ------------------ 29311| 720| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 29312| 720| } 29313| 885| uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29314| 885| ((size_t)s[1] * 4)); 29315| 885| if (s1) { ------------------ | Branch (29315:9): [True: 719, False: 166] ------------------ 29316| 719| wuffs_base__poke_u32le__no_bounds_check(d + (1 * 4), s1); 29317| 719| } 29318| 885| uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29319| 885| ((size_t)s[2] * 4)); 29320| 885| if (s2) { ------------------ | Branch (29320:9): [True: 732, False: 153] ------------------ 29321| 732| wuffs_base__poke_u32le__no_bounds_check(d + (2 * 4), s2); 29322| 732| } 29323| 885| uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29324| 885| ((size_t)s[3] * 4)); 29325| 885| if (s3) { ------------------ | Branch (29325:9): [True: 721, False: 164] ------------------ 29326| 721| wuffs_base__poke_u32le__no_bounds_check(d + (3 * 4), s3); 29327| 721| } 29328| | 29329| 885| s += loop_unroll_count * 1; 29330| 885| d += loop_unroll_count * 4; 29331| 885| n -= loop_unroll_count; 29332| 885| } 29333| | 29334| 301| while (n >= 1) { ------------------ | Branch (29334:10): [True: 186, False: 115] ------------------ 29335| 186| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29336| 186| ((size_t)s[0] * 4)); 29337| 186| if (s0) { ------------------ | Branch (29337:9): [True: 153, False: 33] ------------------ 29338| 153| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 29339| 153| } 29340| | 29341| 186| s += 1 * 1; 29342| 186| d += 1 * 4; 29343| 186| n -= 1; 29344| 186| } 29345| | 29346| 115| return len; 29347| 115|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over: 29517| 37| size_t src_len) { 29518| 37| if (dst_palette_len != ------------------ | Branch (29518:7): [True: 0, False: 37] ------------------ 29519| 37| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 37|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29520| 0| return 0; 29521| 0| } 29522| 37| size_t dst_len8 = dst_len / 8; 29523| 37| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (29523:16): [True: 29, False: 8] ------------------ 29524| 37| uint8_t* d = dst_ptr; 29525| 37| const uint8_t* s = src_ptr; 29526| 37| size_t n = len; 29527| | 29528| 513| while (n >= 1) { ------------------ | Branch (29528:10): [True: 476, False: 37] ------------------ 29529| 476| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29530| 476| ((size_t)s[0] * 4)); 29531| 476| if (s0) { ------------------ | Branch (29531:9): [True: 374, False: 102] ------------------ 29532| 374| wuffs_base__poke_u64le__no_bounds_check( 29533| 374| d + (0 * 8), wuffs_base__color_u32__as__color_u64(s0)); 29534| 374| } 29535| | 29536| 476| s += 1 * 1; 29537| 476| d += 1 * 8; 29538| 476| n -= 1; 29539| 476| } 29540| | 29541| 37| return len; 29542| 37|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr_565: 30977| 124| wuffs_base__pixel_blend blend) { 30978| 124| switch (dst_pixfmt.repr) { ------------------ | Branch (30978:11): [True: 109, False: 15] ------------------ 30979| 21| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 21|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (30979:5): [True: 21, False: 103] ------------------ 30980| 21| return wuffs_private_impl__swizzle_y__bgr_565; 30981| | 30982| 6| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (30982:5): [True: 6, False: 118] ------------------ 30983| 6| return wuffs_private_impl__swizzle_copy_2_2; 30984| | 30985| 13| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (30985:5): [True: 13, False: 111] ------------------ 30986| 13| return wuffs_private_impl__swizzle_bgr__bgr_565; 30987| | 30988| 3| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 3|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (30988:5): [True: 3, False: 121] ------------------ 30989| 5| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (30989:5): [True: 2, False: 122] ------------------ 30990| 5| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (30990:5): [True: 0, False: 124] ------------------ 30991| 16| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (30991:5): [True: 11, False: 113] ------------------ 30992| 16| return wuffs_private_impl__swizzle_bgrw__bgr_565; 30993| | 30994| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (30994:5): [True: 4, False: 120] ------------------ 30995| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (30995:5): [True: 11, False: 113] ------------------ 30996| 15| return wuffs_private_impl__swizzle_bgrw_4x16le__bgr_565; 30997| | 30998| 12| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (30998:5): [True: 12, False: 112] ------------------ 30999| 12| return wuffs_private_impl__swizzle_rgb__bgr_565; 31000| | 31001| 5| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 5|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31001:5): [True: 5, False: 119] ------------------ 31002| 26| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31002:5): [True: 21, False: 103] ------------------ 31003| 26| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31003:5): [True: 0, False: 124] ------------------ 31004| 26| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31004:5): [True: 0, False: 124] ------------------ 31005| 26| return wuffs_private_impl__swizzle_rgbw__bgr_565; 31006| 124| } 31007| 15| return NULL; 31008| 124|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr_565: 29661| 21| size_t src_len) { 29662| 21| size_t src_len2 = src_len / 2; 29663| 21| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (29663:16): [True: 3, False: 18] ------------------ 29664| 21| uint8_t* d = dst_ptr; 29665| 21| const uint8_t* s = src_ptr; 29666| 21| size_t n = len; 29667| | 29668| | // TODO: unroll. 29669| | 29670| 1.02k| while (n >= 1) { ------------------ | Branch (29670:10): [True: 1.00k, False: 21] ------------------ 29671| 1.00k| uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29672| 1.00k| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))); 29673| 1.00k| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 29674| | 29675| 1.00k| s += 1 * 2; 29676| 1.00k| d += 1 * 1; 29677| 1.00k| n -= 1; 29678| 1.00k| } 29679| | 29680| 21| return len; 29681| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgr_565: 26210| 13| size_t src_len) { 26211| 13| size_t dst_len3 = dst_len / 3; 26212| 13| size_t src_len2 = src_len / 2; 26213| 13| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (26213:16): [True: 4, False: 9] ------------------ 26214| 13| uint8_t* d = dst_ptr; 26215| 13| const uint8_t* s = src_ptr; 26216| 13| size_t n = len; 26217| | 26218| | // TODO: unroll. 26219| | 26220| 361| while (n >= 1) { ------------------ | Branch (26220:10): [True: 348, False: 13] ------------------ 26221| 348| uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 26222| 348| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))); 26223| 348| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26224| | 26225| 348| s += 1 * 2; 26226| 348| d += 1 * 3; 26227| 348| n -= 1; 26228| 348| } 26229| | 26230| 13| return len; 26231| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr_565: 28341| 16| size_t src_len) { 28342| 16| size_t dst_len4 = dst_len / 4; 28343| 16| size_t src_len2 = src_len / 2; 28344| 16| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28344:16): [True: 11, False: 5] ------------------ 28345| 16| uint8_t* d = dst_ptr; 28346| 16| const uint8_t* s = src_ptr; 28347| 16| size_t n = len; 28348| | 28349| | // TODO: unroll. 28350| | 28351| 258| while (n >= 1) { ------------------ | Branch (28351:10): [True: 242, False: 16] ------------------ 28352| 242| wuffs_base__poke_u32le__no_bounds_check( 28353| 242| d + (0 * 4), wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 28354| 242| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))); 28355| | 28356| 242| s += 1 * 2; 28357| 242| d += 1 * 4; 28358| 242| n -= 1; 28359| 242| } 28360| | 28361| 16| return len; 28362| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr_565: 28610| 15| size_t src_len) { 28611| 15| size_t dst_len8 = dst_len / 8; 28612| 15| size_t src_len2 = src_len / 2; 28613| 15| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (28613:16): [True: 10, False: 5] ------------------ 28614| 15| uint8_t* d = dst_ptr; 28615| 15| const uint8_t* s = src_ptr; 28616| 15| size_t n = len; 28617| | 28618| 133| while (n >= 1) { ------------------ | Branch (28618:10): [True: 118, False: 15] ------------------ 28619| 118| wuffs_base__poke_u64le__no_bounds_check( 28620| 118| d + (0 * 8), 28621| 118| wuffs_base__color_u32__as__color_u64( 28622| 118| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 28623| 118| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 28624| | 28625| 118| s += 1 * 2; 28626| 118| d += 1 * 8; 28627| 118| n -= 1; 28628| 118| } 28629| | 28630| 15| return len; 28631| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgb__bgr_565: 28711| 12| size_t src_len) { 28712| 12| size_t dst_len3 = dst_len / 3; 28713| 12| size_t src_len2 = src_len / 2; 28714| 12| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (28714:16): [True: 4, False: 8] ------------------ 28715| 12| uint8_t* d = dst_ptr; 28716| 12| const uint8_t* s = src_ptr; 28717| 12| size_t n = len; 28718| | 28719| | // TODO: unroll. 28720| | 28721| 185| while (n >= 1) { ------------------ | Branch (28721:10): [True: 173, False: 12] ------------------ 28722| 173| wuffs_base__poke_u24le__no_bounds_check( 28723| 173| d + (0 * 3), 28724| 173| wuffs_base__color_swap_u32_argb_abgr( 28725| 173| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 28726| 173| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 28727| | 28728| 173| s += 1 * 2; 28729| 173| d += 1 * 3; 28730| 173| n -= 1; 28731| 173| } 28732| | 28733| 12| return len; 28734| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgbw__bgr_565: 28870| 26| size_t src_len) { 28871| 26| size_t dst_len4 = dst_len / 4; 28872| 26| size_t src_len2 = src_len / 2; 28873| 26| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28873:16): [True: 12, False: 14] ------------------ 28874| 26| uint8_t* d = dst_ptr; 28875| 26| const uint8_t* s = src_ptr; 28876| 26| size_t n = len; 28877| | 28878| | // TODO: unroll. 28879| | 28880| 641| while (n >= 1) { ------------------ | Branch (28880:10): [True: 615, False: 26] ------------------ 28881| 615| wuffs_base__poke_u32le__no_bounds_check( 28882| 615| d + (0 * 4), 28883| 615| wuffs_base__color_swap_u32_argb_abgr( 28884| 615| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 28885| 615| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 28886| | 28887| 615| s += 1 * 2; 28888| 615| d += 1 * 4; 28889| 615| n -= 1; 28890| 615| } 28891| | 28892| 26| return len; 28893| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr: 31016| 149| wuffs_base__pixel_blend blend) { 31017| 149| switch (dst_pixfmt.repr) { ------------------ | Branch (31017:11): [True: 136, False: 13] ------------------ 31018| 22| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 22|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31018:5): [True: 22, False: 127] ------------------ 31019| 22| return wuffs_private_impl__swizzle_y__bgr; 31020| | 31021| 20| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31021:5): [True: 20, False: 129] ------------------ 31022| 20| return wuffs_private_impl__swizzle_bgr_565__bgr; 31023| | 31024| 10| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31024:5): [True: 10, False: 139] ------------------ 31025| 10| return wuffs_private_impl__swizzle_copy_3_3; 31026| | 31027| 5| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31027:5): [True: 5, False: 144] ------------------ 31028| 11| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31028:5): [True: 6, False: 143] ------------------ 31029| 11| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31029:5): [True: 0, False: 149] ------------------ 31030| 26| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 26|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31030:5): [True: 15, False: 134] ------------------ 31031| 26|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31032| 26| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31032:11): [True: 26, False: 0] ------------------ 31033| 26| return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42; 31034| 26| } 31035| 0|#endif 31036| 0| return wuffs_private_impl__swizzle_bgrw__bgr; 31037| | 31038| 14| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31038:5): [True: 14, False: 135] ------------------ 31039| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31039:5): [True: 3, False: 146] ------------------ 31040| 17| return wuffs_private_impl__swizzle_bgrw_4x16le__bgr; 31041| | 31042| 16| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31042:5): [True: 16, False: 133] ------------------ 31043| 16| return wuffs_private_impl__swizzle_swap_rgb_bgr; 31044| | 31045| 12| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31045:5): [True: 12, False: 137] ------------------ 31046| 25| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 25|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31046:5): [True: 13, False: 136] ------------------ 31047| 25| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 25|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31047:5): [True: 0, False: 149] ------------------ 31048| 25| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 25|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31048:5): [True: 0, False: 149] ------------------ 31049| 25|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31050| 25| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31050:11): [True: 25, False: 0] ------------------ 31051| 25| return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42; 31052| 25| } 31053| 0|#endif 31054| 0| return wuffs_private_impl__swizzle_bgrw__rgb; 31055| 149| } 31056| 13| return NULL; 31057| 149|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr: 29633| 22| size_t src_len) { 29634| 22| size_t src_len3 = src_len / 3; 29635| 22| size_t len = (dst_len < src_len3) ? dst_len : src_len3; ------------------ | Branch (29635:16): [True: 7, False: 15] ------------------ 29636| 22| uint8_t* d = dst_ptr; 29637| 22| const uint8_t* s = src_ptr; 29638| 22| size_t n = len; 29639| | 29640| | // TODO: unroll. 29641| | 29642| 582| while (n >= 1) { ------------------ | Branch (29642:10): [True: 560, False: 22] ------------------ 29643| 560| uint32_t s0 = 29644| 560| 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(s + (0 * 3)); 29645| 560| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 29646| | 29647| 560| s += 1 * 3; 29648| 560| d += 1 * 1; 29649| 560| n -= 1; 29650| 560| } 29651| | 29652| 22| return len; 29653| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgr: 25290| 20| size_t src_len) { 25291| 20| size_t dst_len2 = dst_len / 2; 25292| 20| size_t src_len3 = src_len / 3; 25293| 20| size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3; ------------------ | Branch (25293:16): [True: 8, False: 12] ------------------ 25294| 20| uint8_t* d = dst_ptr; 25295| 20| const uint8_t* s = src_ptr; 25296| 20| size_t n = len; 25297| | 25298| | // TODO: unroll. 25299| | 25300| 368| while (n >= 1) { ------------------ | Branch (25300:10): [True: 348, False: 20] ------------------ 25301| 348| uint32_t b5 = (uint32_t)(s[0] >> 3); 25302| 348| uint32_t g6 = (uint32_t)(s[1] >> 2); 25303| 348| uint32_t r5 = (uint32_t)(s[2] >> 3); 25304| 348| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 25305| 348| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 25306| | 25307| 348| s += 1 * 3; 25308| 348| d += 1 * 2; 25309| 348| n -= 1; 25310| 348| } 25311| | 25312| 20| return len; 25313| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_3_3: 25240| 16| size_t src_len) { 25241| 16| size_t dst_len3 = dst_len / 3; 25242| 16| size_t src_len3 = src_len / 3; 25243| 16| size_t len = (dst_len3 < src_len3) ? dst_len3 : src_len3; ------------------ | Branch (25243:16): [True: 6, False: 10] ------------------ 25244| 16| if (len > 0) { ------------------ | Branch (25244:7): [True: 14, False: 2] ------------------ 25245| 14| memmove(dst_ptr, src_ptr, len * 3); 25246| 14| } 25247| 16| return len; 25248| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42: 28402| 45| size_t src_len) { 28403| 45| size_t dst_len4 = dst_len / 4; 28404| 45| size_t src_len3 = src_len / 3; 28405| 45| size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3; ------------------ | Branch (28405:16): [True: 9, False: 36] ------------------ 28406| 45| uint8_t* d = dst_ptr; 28407| 45| const uint8_t* s = src_ptr; 28408| 45| size_t n = len; 28409| | 28410| 45| __m128i shuffle = _mm_set_epi8(+0x00, +0x0B, +0x0A, +0x09, // 28411| 45| +0x00, +0x08, +0x07, +0x06, // 28412| 45| +0x00, +0x05, +0x04, +0x03, // 28413| 45| +0x00, +0x02, +0x01, +0x00); 28414| 45| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 28415| 45| -0x01, +0x00, +0x00, +0x00, // 28416| 45| -0x01, +0x00, +0x00, +0x00, // 28417| 45| -0x01, +0x00, +0x00, +0x00); 28418| | 28419| 223| while (n >= 6) { ------------------ | Branch (28419:10): [True: 178, False: 45] ------------------ 28420| 178| __m128i x; 28421| 178| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 28422| 178| x = _mm_shuffle_epi8(x, shuffle); 28423| 178| x = _mm_or_si128(x, or_ff); 28424| 178| _mm_storeu_si128((__m128i*)(void*)d, x); 28425| | 28426| 178| s += 4 * 3; 28427| 178| d += 4 * 4; 28428| 178| n -= 4; 28429| 178| } 28430| | 28431| 177| while (n >= 1) { ------------------ | Branch (28431:10): [True: 132, False: 45] ------------------ 28432| 132| uint8_t b0 = s[0]; 28433| 132| uint8_t b1 = s[1]; 28434| 132| uint8_t b2 = s[2]; 28435| 132| d[0] = b0; 28436| 132| d[1] = b1; 28437| 132| d[2] = b2; 28438| 132| d[3] = 0xFF; 28439| | 28440| 132| s += 1 * 3; 28441| 132| d += 1 * 4; 28442| 132| n -= 1; 28443| 132| } 28444| | 28445| 45| return len; 28446| 45|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr: 28575| 17| size_t src_len) { 28576| 17| size_t dst_len8 = dst_len / 8; 28577| 17| size_t src_len3 = src_len / 3; 28578| 17| size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3; ------------------ | Branch (28578:16): [True: 5, False: 12] ------------------ 28579| 17| uint8_t* d = dst_ptr; 28580| 17| const uint8_t* s = src_ptr; 28581| 17| size_t n = len; 28582| | 28583| 235| while (n >= 1) { ------------------ | Branch (28583:10): [True: 218, False: 17] ------------------ 28584| 218| uint8_t s0 = s[0]; 28585| 218| uint8_t s1 = s[1]; 28586| 218| uint8_t s2 = s[2]; 28587| 218| d[0] = s0; 28588| 218| d[1] = s0; 28589| 218| d[2] = s1; 28590| 218| d[3] = s1; 28591| 218| d[4] = s2; 28592| 218| d[5] = s2; 28593| 218| d[6] = 0xFF; 28594| 218| d[7] = 0xFF; 28595| | 28596| 218| s += 1 * 3; 28597| 218| d += 1 * 8; 28598| 218| n -= 1; 28599| 218| } 28600| | 28601| 17| return len; 28602| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgb_bgr: 25073| 26| size_t src_len) { 25074| 26| size_t len = (dst_len < src_len ? dst_len : src_len) / 3; ------------------ | Branch (25074:17): [True: 3, False: 23] ------------------ 25075| 26| uint8_t* d = dst_ptr; 25076| 26| const uint8_t* s = src_ptr; 25077| | 25078| 26| size_t n = len; 25079| 733| while (n--) { ------------------ | Branch (25079:10): [True: 707, False: 26] ------------------ 25080| 707| uint8_t s0 = s[0]; 25081| 707| uint8_t s1 = s[1]; 25082| 707| uint8_t s2 = s[2]; 25083| 707| d[0] = s2; 25084| 707| d[1] = s1; 25085| 707| d[2] = s0; 25086| 707| s += 3; 25087| 707| d += 3; 25088| 707| } 25089| 26| return len; 25090| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42: 28455| 45| size_t src_len) { 28456| 45| size_t dst_len4 = dst_len / 4; 28457| 45| size_t src_len3 = src_len / 3; 28458| 45| size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3; ------------------ | Branch (28458:16): [True: 14, False: 31] ------------------ 28459| 45| uint8_t* d = dst_ptr; 28460| 45| const uint8_t* s = src_ptr; 28461| 45| size_t n = len; 28462| | 28463| 45| __m128i shuffle = _mm_set_epi8(+0x00, +0x09, +0x0A, +0x0B, // 28464| 45| +0x00, +0x06, +0x07, +0x08, // 28465| 45| +0x00, +0x03, +0x04, +0x05, // 28466| 45| +0x00, +0x00, +0x01, +0x02); 28467| 45| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 28468| 45| -0x01, +0x00, +0x00, +0x00, // 28469| 45| -0x01, +0x00, +0x00, +0x00, // 28470| 45| -0x01, +0x00, +0x00, +0x00); 28471| | 28472| 219| while (n >= 6) { ------------------ | Branch (28472:10): [True: 174, False: 45] ------------------ 28473| 174| __m128i x; 28474| 174| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 28475| 174| x = _mm_shuffle_epi8(x, shuffle); 28476| 174| x = _mm_or_si128(x, or_ff); 28477| 174| _mm_storeu_si128((__m128i*)(void*)d, x); 28478| | 28479| 174| s += 4 * 3; 28480| 174| d += 4 * 4; 28481| 174| n -= 4; 28482| 174| } 28483| | 28484| 176| while (n >= 1) { ------------------ | Branch (28484:10): [True: 131, False: 45] ------------------ 28485| 131| uint8_t b0 = s[0]; 28486| 131| uint8_t b1 = s[1]; 28487| 131| uint8_t b2 = s[2]; 28488| 131| d[0] = b2; 28489| 131| d[1] = b1; 28490| 131| d[2] = b0; 28491| 131| d[3] = 0xFF; 28492| | 28493| 131| s += 1 * 3; 28494| 131| d += 1 * 4; 28495| 131| n -= 1; 28496| 131| } 28497| | 28498| 45| return len; 28499| 45|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul: 31065| 250| wuffs_base__pixel_blend blend) { 31066| 250| switch (dst_pixfmt.repr) { ------------------ | Branch (31066:11): [True: 236, False: 14] ------------------ 31067| 41| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 41|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31067:5): [True: 41, False: 209] ------------------ 31068| 41| switch (blend) { ------------------ | Branch (31068:15): [True: 41, False: 0] ------------------ 31069| 22| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 22|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31069:9): [True: 22, False: 19] ------------------ 31070| 22| return wuffs_private_impl__swizzle_y__bgra_nonpremul__src; 31071| 19| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31071:9): [True: 19, False: 22] ------------------ 31072| 19| return wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over; 31073| 41| } 31074| 0| return NULL; 31075| | 31076| 32| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 32|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31076:5): [True: 32, False: 218] ------------------ 31077| 32| switch (blend) { ------------------ | Branch (31077:15): [True: 32, False: 0] ------------------ 31078| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31078:9): [True: 16, False: 16] ------------------ 31079| 16| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src; 31080| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31080:9): [True: 16, False: 16] ------------------ 31081| 16| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src_over; 31082| 32| } 31083| 0| return NULL; 31084| | 31085| 22| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31085:5): [True: 22, False: 228] ------------------ 31086| 22| switch (blend) { ------------------ | Branch (31086:15): [True: 22, False: 0] ------------------ 31087| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31087:9): [True: 1, False: 21] ------------------ 31088| 1| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src; 31089| 21| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 21|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31089:9): [True: 21, False: 1] ------------------ 31090| 21| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over; 31091| 22| } 31092| 0| return NULL; 31093| | 31094| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31094:5): [True: 18, False: 232] ------------------ 31095| 18| switch (blend) { ------------------ | Branch (31095:15): [True: 18, False: 0] ------------------ 31096| 0| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31096:9): [True: 0, False: 18] ------------------ 31097| 0| return wuffs_private_impl__swizzle_copy_4_4; 31098| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31098:9): [True: 18, False: 0] ------------------ 31099| 18| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over; 31100| 18| } 31101| 0| return NULL; 31102| | 31103| 42| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 42|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31103:5): [True: 42, False: 208] ------------------ 31104| 42| switch (blend) { ------------------ | Branch (31104:15): [True: 42, False: 0] ------------------ 31105| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31105:9): [True: 11, False: 31] ------------------ 31106| 11| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src; 31107| 31| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 31|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31107:9): [True: 31, False: 11] ------------------ 31108| 31| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over; 31109| 42| } 31110| 0| return NULL; 31111| | 31112| 5| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31112:5): [True: 5, False: 245] ------------------ 31113| 5| switch (blend) { ------------------ | Branch (31113:15): [True: 5, False: 0] ------------------ 31114| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31114:9): [True: 2, False: 3] ------------------ 31115| 2| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src; 31116| 3| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31116:9): [True: 3, False: 2] ------------------ 31117| 3| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over; 31118| 5| } 31119| 0| return NULL; 31120| | 31121| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31121:5): [True: 0, False: 250] ------------------ 31122| 7| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31122:5): [True: 7, False: 243] ------------------ 31123| | // TODO. 31124| 7| break; 31125| | 31126| 28| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 28|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31126:5): [True: 28, False: 222] ------------------ 31127| 28| switch (blend) { ------------------ | Branch (31127:15): [True: 28, False: 0] ------------------ 31128| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31128:9): [True: 11, False: 17] ------------------ 31129| 11| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src; 31130| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31130:9): [True: 17, False: 11] ------------------ 31131| 17| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over; 31132| 28| } 31133| 0| return NULL; 31134| | 31135| 18| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 18|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31135:5): [True: 18, False: 232] ------------------ 31136| 18| switch (blend) { ------------------ | Branch (31136:15): [True: 18, False: 0] ------------------ 31137| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31137:9): [True: 13, False: 5] ------------------ 31138| 13|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31139| 13| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31139:15): [True: 13, False: 0] ------------------ 31140| 13| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 31141| 13| } 31142| 0|#endif 31143| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 31144| 5| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31144:9): [True: 5, False: 13] ------------------ 31145| 5| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over; 31146| 18| } 31147| 0| return NULL; 31148| | 31149| 23| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31149:5): [True: 23, False: 227] ------------------ 31150| 23| switch (blend) { ------------------ | Branch (31150:15): [True: 23, False: 0] ------------------ 31151| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31151:9): [True: 7, False: 16] ------------------ 31152| 7| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src; 31153| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31153:9): [True: 16, False: 7] ------------------ 31154| 16| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over; 31155| 23| } 31156| 0| return NULL; 31157| | 31158| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31158:5): [True: 0, False: 250] ------------------ 31159| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31159:5): [True: 0, False: 250] ------------------ 31160| | // TODO. 31161| 0| break; 31162| 250| } 31163| 21| return NULL; 31164| 250|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src: 29689| 22| size_t src_len) { 29690| 22| size_t src_len4 = src_len / 4; 29691| 22| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (29691:16): [True: 2, False: 20] ------------------ 29692| 22| uint8_t* d = dst_ptr; 29693| 22| const uint8_t* s = src_ptr; 29694| 22| size_t n = len; 29695| | 29696| | // TODO: unroll. 29697| | 29698| 711| while (n >= 1) { ------------------ | Branch (29698:10): [True: 689, False: 22] ------------------ 29699| 689| uint32_t s0 = 29700| 689| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 29701| 689| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 29702| 689| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 29703| | 29704| 689| s += 1 * 4; 29705| 689| d += 1 * 1; 29706| 689| n -= 1; 29707| 689| } 29708| | 29709| 22| return len; 29710| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over: 29719| 19| size_t src_len) { 29720| 19| size_t src_len4 = src_len / 4; 29721| 19| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (29721:16): [True: 4, False: 15] ------------------ 29722| 19| uint8_t* d = dst_ptr; 29723| 19| const uint8_t* s = src_ptr; 29724| 19| size_t n = len; 29725| | 29726| | // TODO: unroll. 29727| | 29728| 493| while (n >= 1) { ------------------ | Branch (29728:10): [True: 474, False: 19] ------------------ 29729| 474| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 29730| 474| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 29731| 474| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 29732| 474| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 29733| | 29734| 474| s += 1 * 4; 29735| 474| d += 1 * 1; 29736| 474| n -= 1; 29737| 474| } 29738| | 29739| 19| return len; 29740| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src: 25353| 16| size_t src_len) { 25354| 16| size_t dst_len2 = dst_len / 2; 25355| 16| size_t src_len4 = src_len / 4; 25356| 16| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25356:16): [True: 1, False: 15] ------------------ 25357| 16| uint8_t* d = dst_ptr; 25358| 16| const uint8_t* s = src_ptr; 25359| 16| size_t n = len; 25360| | 25361| | // TODO: unroll. 25362| | 25363| 394| while (n >= 1) { ------------------ | Branch (25363:10): [True: 378, False: 16] ------------------ 25364| 378| wuffs_base__poke_u16le__no_bounds_check( 25365| 378| d + (0 * 2), 25366| 378| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 25367| 378| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 25368| 378| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 25369| | 25370| 378| s += 1 * 4; 25371| 378| d += 1 * 2; 25372| 378| n -= 1; 25373| 378| } 25374| | 25375| 16| return len; 25376| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src_over: 25417| 16| size_t src_len) { 25418| 16| size_t dst_len2 = dst_len / 2; 25419| 16| size_t src_len4 = src_len / 4; 25420| 16| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25420:16): [True: 1, False: 15] ------------------ 25421| 16| uint8_t* d = dst_ptr; 25422| 16| const uint8_t* s = src_ptr; 25423| 16| size_t n = len; 25424| | 25425| | // TODO: unroll. 25426| | 25427| 251| while (n >= 1) { ------------------ | Branch (25427:10): [True: 235, False: 16] ------------------ 25428| | // Extract 16-bit color components. 25429| 235| uint32_t sa = 0x101 * ((uint32_t)s[3]); 25430| 235| uint32_t sr = 0x101 * ((uint32_t)s[2]); 25431| 235| uint32_t sg = 0x101 * ((uint32_t)s[1]); 25432| 235| uint32_t sb = 0x101 * ((uint32_t)s[0]); 25433| | 25434| | // Convert from 565 color to 16-bit color. 25435| 235| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 25436| 235| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 25437| 235| uint32_t dr = (0x8421 * old_r5) >> 4; 25438| 235| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 25439| 235| uint32_t dg = (0x1041 * old_g6) >> 2; 25440| 235| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 25441| 235| uint32_t db = (0x8421 * old_b5) >> 4; 25442| | 25443| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25444| 235| uint32_t ia = 0xFFFF - sa; 25445| | 25446| | // Composite src (nonpremul) over dst (premul). 25447| 235| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25448| 235| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25449| 235| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25450| | 25451| | // Convert from 16-bit color to 565 color and combine the components. 25452| 235| uint32_t new_r5 = 0x1F & (dr >> 11); 25453| 235| uint32_t new_g6 = 0x3F & (dg >> 10); 25454| 235| uint32_t new_b5 = 0x1F & (db >> 11); 25455| 235| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 25456| 235| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 25457| | 25458| 235| s += 1 * 4; 25459| 235| d += 1 * 2; 25460| 235| n -= 1; 25461| 235| } 25462| | 25463| 16| return len; 25464| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src: 26239| 17| size_t src_len) { 26240| 17| size_t dst_len3 = dst_len / 3; 26241| 17| size_t src_len4 = src_len / 4; 26242| 17| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26242:16): [True: 1, False: 16] ------------------ 26243| 17| uint8_t* d = dst_ptr; 26244| 17| const uint8_t* s = src_ptr; 26245| 17| size_t n = len; 26246| | 26247| | // TODO: unroll. 26248| | 26249| 343| while (n >= 1) { ------------------ | Branch (26249:10): [True: 326, False: 17] ------------------ 26250| 326| uint32_t s0 = 26251| 326| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26252| 326| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 26253| 326| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26254| | 26255| 326| s += 1 * 4; 26256| 326| d += 1 * 3; 26257| 326| n -= 1; 26258| 326| } 26259| | 26260| 17| return len; 26261| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over: 26301| 21| size_t src_len) { 26302| 21| size_t dst_len3 = dst_len / 3; 26303| 21| size_t src_len4 = src_len / 4; 26304| 21| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26304:16): [True: 1, False: 20] ------------------ 26305| 21| uint8_t* d = dst_ptr; 26306| 21| const uint8_t* s = src_ptr; 26307| 21| size_t n = len; 26308| | 26309| | // TODO: unroll. 26310| | 26311| 477| while (n >= 1) { ------------------ | Branch (26311:10): [True: 456, False: 21] ------------------ 26312| | // Extract 16-bit color components. 26313| 456| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26314| 456| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26315| 456| uint32_t db = 0x101 * ((uint32_t)d[0]); 26316| 456| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26317| 456| uint32_t sr = 0x101 * ((uint32_t)s[2]); 26318| 456| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26319| 456| uint32_t sb = 0x101 * ((uint32_t)s[0]); 26320| | 26321| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26322| 456| uint32_t ia = 0xFFFF - sa; 26323| | 26324| | // Composite src (nonpremul) over dst (premul). 26325| 456| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26326| 456| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26327| 456| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26328| | 26329| | // Convert from 16-bit color to 8-bit color. 26330| 456| d[0] = (uint8_t)(db >> 8); 26331| 456| d[1] = (uint8_t)(dg >> 8); 26332| 456| d[2] = (uint8_t)(dr >> 8); 26333| | 26334| 456| s += 1 * 4; 26335| 456| d += 1 * 3; 26336| 456| n -= 1; 26337| 456| } 26338| | 26339| 21| return len; 26340| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_4_4: 25256| 20| size_t src_len) { 25257| 20| size_t dst_len4 = dst_len / 4; 25258| 20| size_t src_len4 = src_len / 4; 25259| 20| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (25259:16): [True: 5, False: 15] ------------------ 25260| 20| if (len > 0) { ------------------ | Branch (25260:7): [True: 16, False: 4] ------------------ 25261| 16| memmove(dst_ptr, src_ptr, len * 4); 25262| 16| } 25263| 20| return len; 25264| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over: 26895| 28| size_t src_len) { 26896| 28| size_t dst_len4 = dst_len / 4; 26897| 28| size_t src_len4 = src_len / 4; 26898| 28| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (26898:16): [True: 9, False: 19] ------------------ 26899| 28| uint8_t* d = dst_ptr; 26900| 28| const uint8_t* s = src_ptr; 26901| 28| size_t n = len; 26902| | 26903| 401| while (n >= 1) { ------------------ | Branch (26903:10): [True: 373, False: 28] ------------------ 26904| 373| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 26905| 373| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 26906| 373| wuffs_base__poke_u32le__no_bounds_check( 26907| 373| d + (0 * 4), 26908| 373| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 26909| | 26910| 373| s += 1 * 4; 26911| 373| d += 1 * 4; 26912| 373| n -= 1; 26913| 373| } 26914| | 26915| 28| return len; 26916| 28|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src: 27296| 11| size_t src_len) { 27297| 11| size_t dst_len8 = dst_len / 8; 27298| 11| size_t src_len4 = src_len / 4; 27299| 11| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27299:16): [True: 6, False: 5] ------------------ 27300| 11| uint8_t* d = dst_ptr; 27301| 11| const uint8_t* s = src_ptr; 27302| | 27303| 11| size_t n = len; 27304| 91| while (n >= 1) { ------------------ | Branch (27304:10): [True: 80, False: 11] ------------------ 27305| 80| uint8_t s0 = s[0]; 27306| 80| uint8_t s1 = s[1]; 27307| 80| uint8_t s2 = s[2]; 27308| 80| uint8_t s3 = s[3]; 27309| 80| d[0] = s0; 27310| 80| d[1] = s0; 27311| 80| d[2] = s1; 27312| 80| d[3] = s1; 27313| 80| d[4] = s2; 27314| 80| d[5] = s2; 27315| 80| d[6] = s3; 27316| 80| d[7] = s3; 27317| | 27318| 80| s += 1 * 4; 27319| 80| d += 1 * 8; 27320| 80| n -= 1; 27321| 80| } 27322| 11| return len; 27323| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over: 27332| 31| size_t src_len) { 27333| 31| size_t dst_len8 = dst_len / 8; 27334| 31| size_t src_len4 = src_len / 4; 27335| 31| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27335:16): [True: 10, False: 21] ------------------ 27336| 31| uint8_t* d = dst_ptr; 27337| 31| const uint8_t* s = src_ptr; 27338| | 27339| 31| size_t n = len; 27340| 241| while (n >= 1) { ------------------ | Branch (27340:10): [True: 210, False: 31] ------------------ 27341| 210| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27342| 210| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 27343| 210| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27344| 210| wuffs_base__poke_u64le__no_bounds_check( 27345| 210| d + (0 * 8), 27346| 210| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 27347| | 27348| 210| s += 1 * 4; 27349| 210| d += 1 * 8; 27350| 210| n -= 1; 27351| 210| } 27352| 31| return len; 27353| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over: 27789| 16| size_t src_len) { 27790| 16| size_t dst_len4 = dst_len / 4; 27791| 16| size_t src_len4 = src_len / 4; 27792| 16| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27792:16): [True: 2, False: 14] ------------------ 27793| 16| uint8_t* d = dst_ptr; 27794| 16| const uint8_t* s = src_ptr; 27795| 16| size_t n = len; 27796| | 27797| | // TODO: unroll. 27798| | 27799| 389| while (n >= 1) { ------------------ | Branch (27799:10): [True: 373, False: 16] ------------------ 27800| 373| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27801| 373| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27802| 373| wuffs_base__poke_u32le__no_bounds_check( 27803| 373| d + (0 * 4), 27804| 373| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 27805| | 27806| 373| s += 1 * 4; 27807| 373| d += 1 * 4; 27808| 373| n -= 1; 27809| 373| } 27810| | 27811| 16| return len; 27812| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src: 26549| 12| size_t src_len) { 26550| 12| size_t dst_len3 = dst_len / 3; 26551| 12| size_t src_len4 = src_len / 4; 26552| 12| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26552:16): [True: 1, False: 11] ------------------ 26553| 12| uint8_t* d = dst_ptr; 26554| 12| const uint8_t* s = src_ptr; 26555| 12| size_t n = len; 26556| | 26557| | // TODO: unroll. 26558| | 26559| 308| while (n >= 1) { ------------------ | Branch (26559:10): [True: 296, False: 12] ------------------ 26560| 296| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 26561| 296| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26562| 296| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 26563| 296| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26564| | 26565| 296| s += 1 * 4; 26566| 296| d += 1 * 3; 26567| 296| n -= 1; 26568| 296| } 26569| | 26570| 12| return len; 26571| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over: 26611| 26| size_t src_len) { 26612| 26| size_t dst_len3 = dst_len / 3; 26613| 26| size_t src_len4 = src_len / 4; 26614| 26| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26614:16): [True: 5, False: 21] ------------------ 26615| 26| uint8_t* d = dst_ptr; 26616| 26| const uint8_t* s = src_ptr; 26617| 26| size_t n = len; 26618| | 26619| | // TODO: unroll. 26620| | 26621| 485| while (n >= 1) { ------------------ | Branch (26621:10): [True: 459, False: 26] ------------------ 26622| | // Extract 16-bit color components. 26623| 459| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26624| 459| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26625| 459| uint32_t db = 0x101 * ((uint32_t)d[0]); 26626| 459| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26627| 459| uint32_t sb = 0x101 * ((uint32_t)s[2]); 26628| 459| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26629| 459| uint32_t sr = 0x101 * ((uint32_t)s[0]); 26630| | 26631| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26632| 459| uint32_t ia = 0xFFFF - sa; 26633| | 26634| | // Composite src (nonpremul) over dst (premul). 26635| 459| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26636| 459| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26637| 459| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26638| | 26639| | // Convert from 16-bit color to 8-bit color. 26640| 459| d[0] = (uint8_t)(db >> 8); 26641| 459| d[1] = (uint8_t)(dg >> 8); 26642| 459| d[2] = (uint8_t)(dr >> 8); 26643| | 26644| 459| s += 1 * 4; 26645| 459| d += 1 * 3; 26646| 459| n -= 1; 26647| 459| } 26648| | 26649| 26| return len; 26650| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42: 25101| 32| size_t src_len) { 25102| 32| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25102:17): [True: 9, False: 23] ------------------ 25103| 32| uint8_t* d = dst_ptr; 25104| 32| const uint8_t* s = src_ptr; 25105| 32| size_t n = len; 25106| | 25107| 32| __m128i shuffle = _mm_set_epi8(+0x0F, +0x0C, +0x0D, +0x0E, // 25108| 32| +0x0B, +0x08, +0x09, +0x0A, // 25109| 32| +0x07, +0x04, +0x05, +0x06, // 25110| 32| +0x03, +0x00, +0x01, +0x02); 25111| | 25112| 167| while (n >= 4) { ------------------ | Branch (25112:10): [True: 135, False: 32] ------------------ 25113| 135| __m128i x; 25114| 135| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 25115| 135| x = _mm_shuffle_epi8(x, shuffle); 25116| 135| _mm_storeu_si128((__m128i*)(void*)d, x); 25117| | 25118| 135| s += 4 * 4; 25119| 135| d += 4 * 4; 25120| 135| n -= 4; 25121| 135| } 25122| | 25123| 68| while (n--) { ------------------ | Branch (25123:10): [True: 36, False: 32] ------------------ 25124| 36| uint8_t s0 = s[0]; 25125| 36| uint8_t s1 = s[1]; 25126| 36| uint8_t s2 = s[2]; 25127| 36| uint8_t s3 = s[3]; 25128| 36| d[0] = s2; 25129| 36| d[1] = s1; 25130| 36| d[2] = s0; 25131| 36| d[3] = s3; 25132| 36| s += 4; 25133| 36| d += 4; 25134| 36| } 25135| 32| return len; 25136| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over: 27141| 32| size_t src_len) { 27142| 32| size_t dst_len4 = dst_len / 4; 27143| 32| size_t src_len4 = src_len / 4; 27144| 32| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27144:16): [True: 5, False: 27] ------------------ 27145| 32| uint8_t* d = dst_ptr; 27146| 32| const uint8_t* s = src_ptr; 27147| 32| size_t n = len; 27148| | 27149| 642| while (n >= 1) { ------------------ | Branch (27149:10): [True: 610, False: 32] ------------------ 27150| 610| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27151| 610| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27152| 610| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27153| 610| wuffs_base__poke_u32le__no_bounds_check( 27154| 610| d + (0 * 4), 27155| 610| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27156| | 27157| 610| s += 1 * 4; 27158| 610| d += 1 * 4; 27159| 610| n -= 1; 27160| 610| } 27161| | 27162| 32| return len; 27163| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over: 28019| 24| size_t src_len) { 28020| 24| size_t dst_len4 = dst_len / 4; 28021| 24| size_t src_len4 = src_len / 4; 28022| 24| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28022:16): [True: 2, False: 22] ------------------ 28023| 24| uint8_t* d = dst_ptr; 28024| 24| const uint8_t* s = src_ptr; 28025| 24| size_t n = len; 28026| | 28027| | // TODO: unroll. 28028| | 28029| 408| while (n >= 1) { ------------------ | Branch (28029:10): [True: 384, False: 24] ------------------ 28030| 384| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28031| 384| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28032| 384| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28033| 384| wuffs_base__poke_u32le__no_bounds_check( 28034| 384| d + (0 * 4), 28035| 384| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28036| | 28037| 384| s += 1 * 4; 28038| 384| d += 1 * 4; 28039| 384| n -= 1; 28040| 384| } 28041| | 28042| 24| return len; 28043| 24|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le: 31172| 313| wuffs_base__pixel_blend blend) { 31173| 313| switch (dst_pixfmt.repr) { ------------------ | Branch (31173:11): [True: 295, False: 18] ------------------ 31174| 20| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31174:5): [True: 20, False: 293] ------------------ 31175| 20| switch (blend) { ------------------ | Branch (31175:15): [True: 20, False: 0] ------------------ 31176| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31176:9): [True: 8, False: 12] ------------------ 31177| 8| return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src; 31178| 12| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31178:9): [True: 12, False: 8] ------------------ 31179| 12| return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over; 31180| 20| } 31181| 0| return NULL; 31182| | 31183| 37| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 37|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31183:5): [True: 37, False: 276] ------------------ 31184| 37| switch (blend) { ------------------ | Branch (31184:15): [True: 37, False: 0] ------------------ 31185| 21| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 21|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31185:9): [True: 21, False: 16] ------------------ 31186| 21| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src; 31187| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31187:9): [True: 16, False: 21] ------------------ 31188| 16| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over; 31189| 37| } 31190| 0| return NULL; 31191| | 31192| 22| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31192:5): [True: 22, False: 291] ------------------ 31193| 22| switch (blend) { ------------------ | Branch (31193:15): [True: 22, False: 0] ------------------ 31194| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31194:9): [True: 11, False: 11] ------------------ 31195| 11| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src; 31196| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31196:9): [True: 11, False: 11] ------------------ 31197| 11| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src_over; 31198| 22| } 31199| 0| return NULL; 31200| | 31201| 51| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 51|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31201:5): [True: 51, False: 262] ------------------ 31202| 51| switch (blend) { ------------------ | Branch (31202:15): [True: 51, False: 0] ------------------ 31203| 15| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31203:9): [True: 15, False: 36] ------------------ 31204| 15| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src; 31205| 36| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 36|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31205:9): [True: 36, False: 15] ------------------ 31206| 36| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over; 31207| 51| } 31208| 0| return NULL; 31209| | 31210| 38| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 38|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31210:5): [True: 38, False: 275] ------------------ 31211| 38| switch (blend) { ------------------ | Branch (31211:15): [True: 38, False: 0] ------------------ 31212| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31212:9): [True: 4, False: 34] ------------------ 31213| 4| return wuffs_private_impl__swizzle_copy_8_8; 31214| 34| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 34|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31214:9): [True: 34, False: 4] ------------------ 31215| 34| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over; 31216| 38| } 31217| 0| return NULL; 31218| | 31219| 23| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 23|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31219:5): [True: 23, False: 290] ------------------ 31220| 23| switch (blend) { ------------------ | Branch (31220:15): [True: 23, False: 0] ------------------ 31221| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31221:9): [True: 10, False: 13] ------------------ 31222| 10| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src; 31223| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31223:9): [True: 13, False: 10] ------------------ 31224| 13| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over; 31225| 23| } 31226| 0| return NULL; 31227| | 31228| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31228:5): [True: 0, False: 313] ------------------ 31229| 1| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 1|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31229:5): [True: 1, False: 312] ------------------ 31230| | // TODO. 31231| 1| break; 31232| | 31233| 27| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 27|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31233:5): [True: 27, False: 286] ------------------ 31234| 27| switch (blend) { ------------------ | Branch (31234:15): [True: 27, False: 0] ------------------ 31235| 14| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31235:9): [True: 14, False: 13] ------------------ 31236| 14| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src; 31237| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31237:9): [True: 13, False: 14] ------------------ 31238| 13| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over; 31239| 27| } 31240| 0| return NULL; 31241| | 31242| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31242:5): [True: 49, False: 264] ------------------ 31243| 49| switch (blend) { ------------------ | Branch (31243:15): [True: 49, False: 0] ------------------ 31244| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31244:9): [True: 18, False: 31] ------------------ 31245| 18| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src; 31246| 31| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 31|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31246:9): [True: 31, False: 18] ------------------ 31247| 31| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over; 31248| 49| } 31249| 0| break; 31250| | 31251| 27| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 27|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31251:5): [True: 27, False: 286] ------------------ 31252| 27| switch (blend) { ------------------ | Branch (31252:15): [True: 27, False: 0] ------------------ 31253| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31253:9): [True: 10, False: 17] ------------------ 31254| 10| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src; 31255| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31255:9): [True: 17, False: 10] ------------------ 31256| 17| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over; 31257| 27| } 31258| 0| return NULL; 31259| | 31260| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31260:5): [True: 0, False: 313] ------------------ 31261| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31261:5): [True: 0, False: 313] ------------------ 31262| | // TODO. 31263| 0| break; 31264| 313| } 31265| 19| return NULL; 31266| 313|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src: 29749| 8| size_t src_len) { 29750| 8| size_t src_len8 = src_len / 8; 29751| 8| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (29751:16): [True: 1, False: 7] ------------------ 29752| 8| uint8_t* d = dst_ptr; 29753| 8| const uint8_t* s = src_ptr; 29754| 8| size_t n = len; 29755| | 29756| | // TODO: unroll. 29757| | 29758| 81| while (n >= 1) { ------------------ | Branch (29758:10): [True: 73, False: 8] ------------------ 29759| 73| d[0] = wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray( 29760| 73| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 29761| | 29762| 73| s += 1 * 8; 29763| 73| d += 1 * 1; 29764| 73| n -= 1; 29765| 73| } 29766| | 29767| 8| return len; 29768| 8|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray: 4598| 73| uint64_t argb_nonpremul) { 4599| 73| uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); 4600| | 4601| 73| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); 4602| 73| r16 = (r16 * a16) / 0xFFFF; 4603| 73| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); 4604| 73| g16 = (g16 * a16) / 0xFFFF; 4605| 73| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); 4606| 73| b16 = (b16 * a16) / 0xFFFF; 4607| | 4608| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4609| | // as those given by the JFIF specification. 4610| | // 4611| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We 4612| | // shift by 24, not just by 16, because the return value is 8-bit color, not 4613| | // 16-bit color. 4614| 73| uint32_t weighted_average = 4615| 73| (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; 4616| 73| return (uint8_t)(weighted_average >> 24); 4617| 73|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over: 29777| 12| size_t src_len) { 29778| 12| size_t src_len8 = src_len / 8; 29779| 12| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (29779:16): [True: 1, False: 11] ------------------ 29780| 12| uint8_t* d = dst_ptr; 29781| 12| const uint8_t* s = src_ptr; 29782| 12| size_t n = len; 29783| | 29784| | // TODO: unroll. 29785| | 29786| 113| while (n >= 1) { ------------------ | Branch (29786:10): [True: 101, False: 12] ------------------ 29787| | // Extract 16-bit color components. 29788| 101| uint32_t dr = 0x101 * ((uint32_t)d[0]); 29789| 101| uint32_t dg = 0x101 * ((uint32_t)d[0]); 29790| 101| uint32_t db = 0x101 * ((uint32_t)d[0]); 29791| 101| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 29792| 101| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 29793| 101| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 29794| 101| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 29795| | 29796| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 29797| 101| uint32_t ia = 0xFFFF - sa; 29798| | 29799| | // Composite src (nonpremul) over dst (premul). 29800| 101| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 29801| 101| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 29802| 101| db = ((sb * sa) + (db * ia)) / 0xFFFF; 29803| | 29804| | // Convert to 16-bit color to 8-bit gray. 29805| 101| uint32_t weighted_average = 29806| 101| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 29807| 101| d[0] = (uint8_t)(weighted_average >> 24); 29808| | 29809| 101| s += 1 * 8; 29810| 101| d += 1 * 1; 29811| 101| n -= 1; 29812| 101| } 29813| | 29814| 12| return len; 29815| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src: 25385| 21| size_t src_len) { 25386| 21| size_t dst_len2 = dst_len / 2; 25387| 21| size_t src_len8 = src_len / 8; 25388| 21| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (25388:16): [True: 1, False: 20] ------------------ 25389| 21| uint8_t* d = dst_ptr; 25390| 21| const uint8_t* s = src_ptr; 25391| 21| size_t n = len; 25392| | 25393| | // TODO: unroll. 25394| | 25395| 261| while (n >= 1) { ------------------ | Branch (25395:10): [True: 240, False: 21] ------------------ 25396| 240| wuffs_base__poke_u16le__no_bounds_check( 25397| 240| d + (0 * 2), 25398| 240| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 25399| 240| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 25400| 240| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 25401| | 25402| 240| s += 1 * 8; 25403| 240| d += 1 * 2; 25404| 240| n -= 1; 25405| 240| } 25406| | 25407| 21| return len; 25408| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over: 25473| 16| size_t src_len) { 25474| 16| size_t dst_len2 = dst_len / 2; 25475| 16| size_t src_len8 = src_len / 8; 25476| 16| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (25476:16): [True: 3, False: 13] ------------------ 25477| 16| uint8_t* d = dst_ptr; 25478| 16| const uint8_t* s = src_ptr; 25479| 16| size_t n = len; 25480| | 25481| | // TODO: unroll. 25482| | 25483| 191| while (n >= 1) { ------------------ | Branch (25483:10): [True: 175, False: 16] ------------------ 25484| | // Extract 16-bit color components. 25485| 175| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 25486| 175| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 25487| 175| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 25488| 175| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 25489| | 25490| | // Convert from 565 color to 16-bit color. 25491| 175| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 25492| 175| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 25493| 175| uint32_t dr = (0x8421 * old_r5) >> 4; 25494| 175| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 25495| 175| uint32_t dg = (0x1041 * old_g6) >> 2; 25496| 175| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 25497| 175| uint32_t db = (0x8421 * old_b5) >> 4; 25498| | 25499| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25500| 175| uint32_t ia = 0xFFFF - sa; 25501| | 25502| | // Composite src (nonpremul) over dst (premul). 25503| 175| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25504| 175| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25505| 175| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25506| | 25507| | // Convert from 16-bit color to 565 color and combine the components. 25508| 175| uint32_t new_r5 = 0x1F & (dr >> 11); 25509| 175| uint32_t new_g6 = 0x3F & (dg >> 10); 25510| 175| uint32_t new_b5 = 0x1F & (db >> 11); 25511| 175| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 25512| 175| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 25513| | 25514| 175| s += 1 * 8; 25515| 175| d += 1 * 2; 25516| 175| n -= 1; 25517| 175| } 25518| | 25519| 16| return len; 25520| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src: 26270| 11| size_t src_len) { 26271| 11| size_t dst_len3 = dst_len / 3; 26272| 11| size_t src_len8 = src_len / 8; 26273| 11| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26273:16): [True: 1, False: 10] ------------------ 26274| 11| uint8_t* d = dst_ptr; 26275| 11| const uint8_t* s = src_ptr; 26276| 11| size_t n = len; 26277| | 26278| | // TODO: unroll. 26279| | 26280| 130| while (n >= 1) { ------------------ | Branch (26280:10): [True: 119, False: 11] ------------------ 26281| 119| uint32_t s0 = 26282| 119| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 26283| 119| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 26284| 119| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26285| | 26286| 119| s += 1 * 8; 26287| 119| d += 1 * 3; 26288| 119| n -= 1; 26289| 119| } 26290| | 26291| 11| return len; 26292| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src_over: 26349| 11| size_t src_len) { 26350| 11| size_t dst_len3 = dst_len / 3; 26351| 11| size_t src_len8 = src_len / 8; 26352| 11| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26352:16): [True: 2, False: 9] ------------------ 26353| 11| uint8_t* d = dst_ptr; 26354| 11| const uint8_t* s = src_ptr; 26355| 11| size_t n = len; 26356| | 26357| | // TODO: unroll. 26358| | 26359| 102| while (n >= 1) { ------------------ | Branch (26359:10): [True: 91, False: 11] ------------------ 26360| | // Extract 16-bit color components. 26361| 91| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26362| 91| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26363| 91| uint32_t db = 0x101 * ((uint32_t)d[0]); 26364| 91| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26365| 91| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26366| 91| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26367| 91| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 26368| | 26369| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26370| 91| uint32_t ia = 0xFFFF - sa; 26371| | 26372| | // Composite src (nonpremul) over dst (premul). 26373| 91| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26374| 91| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26375| 91| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26376| | 26377| | // Convert from 16-bit color to 8-bit color. 26378| 91| d[0] = (uint8_t)(db >> 8); 26379| 91| d[1] = (uint8_t)(dg >> 8); 26380| 91| d[2] = (uint8_t)(dr >> 8); 26381| | 26382| 91| s += 1 * 8; 26383| 91| d += 1 * 3; 26384| 91| n -= 1; 26385| 91| } 26386| | 26387| 11| return len; 26388| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src: 26925| 15| size_t src_len) { 26926| 15| size_t dst_len4 = dst_len / 4; 26927| 15| size_t src_len8 = src_len / 8; 26928| 15| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (26928:16): [True: 2, False: 13] ------------------ 26929| 15| uint8_t* d = dst_ptr; 26930| 15| const uint8_t* s = src_ptr; 26931| | 26932| 15| size_t n = len; 26933| 189| while (n >= 1) { ------------------ | Branch (26933:10): [True: 174, False: 15] ------------------ 26934| 174| wuffs_base__poke_u32le__no_bounds_check( 26935| 174| d + (0 * 4), wuffs_base__color_u64__as__color_u32( 26936| 174| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 26937| | 26938| 174| s += 1 * 8; 26939| 174| d += 1 * 4; 26940| 174| n -= 1; 26941| 174| } 26942| 15| return len; 26943| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over: 26952| 36| size_t src_len) { 26953| 36| size_t dst_len4 = dst_len / 4; 26954| 36| size_t src_len8 = src_len / 8; 26955| 36| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (26955:16): [True: 1, False: 35] ------------------ 26956| 36| uint8_t* d = dst_ptr; 26957| 36| const uint8_t* s = src_ptr; 26958| 36| size_t n = len; 26959| | 26960| 368| while (n >= 1) { ------------------ | Branch (26960:10): [True: 332, False: 36] ------------------ 26961| 332| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 26962| 332| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 26963| 332| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 26964| 332| wuffs_base__poke_u32le__no_bounds_check( 26965| 332| d + (0 * 4), 26966| 332| wuffs_base__color_u64__as__color_u32( 26967| 332| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, 26968| 332| s0))); 26969| | 26970| 332| s += 1 * 8; 26971| 332| d += 1 * 4; 26972| 332| n -= 1; 26973| 332| } 26974| | 26975| 36| return len; 26976| 36|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_8_8: 25272| 4| size_t src_len) { 25273| 4| size_t dst_len8 = dst_len / 8; 25274| 4| size_t src_len8 = src_len / 8; 25275| 4| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (25275:16): [True: 2, False: 2] ------------------ 25276| 4| if (len > 0) { ------------------ | Branch (25276:7): [True: 3, False: 1] ------------------ 25277| 3| memmove(dst_ptr, src_ptr, len * 8); 25278| 3| } 25279| 4| return len; 25280| 4|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over: 27362| 34| size_t src_len) { 27363| 34| size_t dst_len8 = dst_len / 8; 27364| 34| size_t src_len8 = src_len / 8; 27365| 34| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (27365:16): [True: 2, False: 32] ------------------ 27366| 34| uint8_t* d = dst_ptr; 27367| 34| const uint8_t* s = src_ptr; 27368| | 27369| 34| size_t n = len; 27370| 247| while (n >= 1) { ------------------ | Branch (27370:10): [True: 213, False: 34] ------------------ 27371| 213| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27372| 213| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27373| 213| wuffs_base__poke_u64le__no_bounds_check( 27374| 213| d + (0 * 8), 27375| 213| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 27376| | 27377| 213| s += 1 * 8; 27378| 213| d += 1 * 8; 27379| 213| n -= 1; 27380| 213| } 27381| 34| return len; 27382| 34|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src: 27758| 10| size_t src_len) { 27759| 10| size_t dst_len4 = dst_len / 4; 27760| 10| size_t src_len8 = src_len / 8; 27761| 10| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27761:16): [True: 3, False: 7] ------------------ 27762| 10| uint8_t* d = dst_ptr; 27763| 10| const uint8_t* s = src_ptr; 27764| 10| size_t n = len; 27765| | 27766| | // TODO: unroll. 27767| | 27768| 89| while (n >= 1) { ------------------ | Branch (27768:10): [True: 79, False: 10] ------------------ 27769| 79| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27770| 79| wuffs_base__poke_u32le__no_bounds_check( 27771| 79| d + (0 * 4), 27772| 79| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(s0)); 27773| | 27774| 79| s += 1 * 8; 27775| 79| d += 1 * 4; 27776| 79| n -= 1; 27777| 79| } 27778| | 27779| 10| return len; 27780| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over: 27821| 13| size_t src_len) { 27822| 13| size_t dst_len4 = dst_len / 4; 27823| 13| size_t src_len8 = src_len / 8; 27824| 13| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27824:16): [True: 1, False: 12] ------------------ 27825| 13| uint8_t* d = dst_ptr; 27826| 13| const uint8_t* s = src_ptr; 27827| 13| size_t n = len; 27828| | 27829| | // TODO: unroll. 27830| | 27831| 151| while (n >= 1) { ------------------ | Branch (27831:10): [True: 138, False: 13] ------------------ 27832| 138| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 27833| 138| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 27834| 138| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27835| 138| wuffs_base__poke_u32le__no_bounds_check( 27836| 138| d + (0 * 4), 27837| 138| wuffs_base__color_u64__as__color_u32( 27838| 138| wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0))); 27839| | 27840| 138| s += 1 * 8; 27841| 138| d += 1 * 4; 27842| 138| n -= 1; 27843| 138| } 27844| | 27845| 13| return len; 27846| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u64_axxx: 24924| 321| uint64_t src_nonpremul) { 24925| | // Extract components. 24926| 321| uint64_t da = 0xFFFF & (dst_premul >> 48); 24927| 321| uint64_t dr = 0xFFFF & (dst_premul >> 32); 24928| 321| uint64_t dg = 0xFFFF & (dst_premul >> 16); 24929| 321| uint64_t db = 0xFFFF & (dst_premul >> 0); 24930| 321| uint64_t sa = 0xFFFF & (src_nonpremul >> 48); 24931| 321| uint64_t sr = 0xFFFF & (src_nonpremul >> 32); 24932| 321| uint64_t sg = 0xFFFF & (src_nonpremul >> 16); 24933| 321| uint64_t sb = 0xFFFF & (src_nonpremul >> 0); 24934| | 24935| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24936| 321| uint64_t ia = 0xFFFF - sa; 24937| | 24938| | // Composite src (nonpremul) over dst (premul). 24939| 321| da = sa + ((da * ia) / 0xFFFF); 24940| 321| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 24941| 321| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 24942| 321| db = ((sb * sa) + (db * ia)) / 0xFFFF; 24943| | 24944| | // Combine components. 24945| 321| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 24946| 321|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src: 26580| 14| size_t src_len) { 26581| 14| size_t dst_len3 = dst_len / 3; 26582| 14| size_t src_len8 = src_len / 8; 26583| 14| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26583:16): [True: 2, False: 12] ------------------ 26584| 14| uint8_t* d = dst_ptr; 26585| 14| const uint8_t* s = src_ptr; 26586| 14| size_t n = len; 26587| | 26588| | // TODO: unroll. 26589| | 26590| 175| while (n >= 1) { ------------------ | Branch (26590:10): [True: 161, False: 14] ------------------ 26591| 161| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 26592| 161| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 26593| 161| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 26594| 161| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26595| | 26596| 161| s += 1 * 8; 26597| 161| d += 1 * 3; 26598| 161| n -= 1; 26599| 161| } 26600| | 26601| 14| return len; 26602| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over: 26659| 13| size_t src_len) { 26660| 13| size_t dst_len3 = dst_len / 3; 26661| 13| size_t src_len8 = src_len / 8; 26662| 13| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26662:16): [True: 2, False: 11] ------------------ 26663| 13| uint8_t* d = dst_ptr; 26664| 13| const uint8_t* s = src_ptr; 26665| 13| size_t n = len; 26666| | 26667| | // TODO: unroll. 26668| | 26669| 129| while (n >= 1) { ------------------ | Branch (26669:10): [True: 116, False: 13] ------------------ 26670| | // Extract 16-bit color components. 26671| 116| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26672| 116| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26673| 116| uint32_t db = 0x101 * ((uint32_t)d[0]); 26674| 116| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26675| 116| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26676| 116| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26677| 116| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 26678| | 26679| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26680| 116| uint32_t ia = 0xFFFF - sa; 26681| | 26682| | // Composite src (nonpremul) over dst (premul). 26683| 116| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26684| 116| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26685| 116| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26686| | 26687| | // Convert from 16-bit color to 8-bit color. 26688| 116| d[0] = (uint8_t)(db >> 8); 26689| 116| d[1] = (uint8_t)(dg >> 8); 26690| 116| d[2] = (uint8_t)(dr >> 8); 26691| | 26692| 116| s += 1 * 8; 26693| 116| d += 1 * 3; 26694| 116| n -= 1; 26695| 116| } 26696| | 26697| 13| return len; 26698| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src: 28745| 18| size_t src_len) { 28746| 18| size_t dst_len4 = dst_len / 4; 28747| 18| size_t src_len8 = src_len / 8; 28748| 18| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28748:16): [True: 6, False: 12] ------------------ 28749| 18| uint8_t* d = dst_ptr; 28750| 18| const uint8_t* s = src_ptr; 28751| | 28752| 18| size_t n = len; 28753| 226| while (n >= 1) { ------------------ | Branch (28753:10): [True: 208, False: 18] ------------------ 28754| 208| wuffs_base__poke_u32le__no_bounds_check( 28755| 208| d + (0 * 4), 28756| 208| wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr( 28757| 208| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 28758| | 28759| 208| s += 1 * 8; 28760| 208| d += 1 * 4; 28761| 208| n -= 1; 28762| 208| } 28763| 18| return len; 28764| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr: 24126| 543|wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) { 24127| 543| uint32_t a = ((uint32_t)(0xFF & (c >> 56))); 24128| 543| uint32_t r = ((uint32_t)(0xFF & (c >> 40))); 24129| 543| uint32_t g = ((uint32_t)(0xFF & (c >> 24))); 24130| 543| uint32_t b = ((uint32_t)(0xFF & (c >> 8))); 24131| 543| return (a << 24) | (b << 16) | (g << 8) | (r << 0); 24132| 543|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over: 28773| 31| size_t src_len) { 28774| 31| size_t dst_len4 = dst_len / 4; 28775| 31| size_t src_len8 = src_len / 8; 28776| 31| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28776:16): [True: 1, False: 30] ------------------ 28777| 31| uint8_t* d = dst_ptr; 28778| 31| const uint8_t* s = src_ptr; 28779| 31| size_t n = len; 28780| | 28781| 298| while (n >= 1) { ------------------ | Branch (28781:10): [True: 267, False: 31] ------------------ 28782| 267| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28783| 267| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28784| 267| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28785| 267| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28786| 267| wuffs_base__poke_u32le__no_bounds_check( 28787| 267| d + (0 * 4), 28788| 267| wuffs_base__color_u64__as__color_u32( 28789| 267| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, 28790| 267| s0))); 28791| | 28792| 267| s += 1 * 8; 28793| 267| d += 1 * 4; 28794| 267| n -= 1; 28795| 267| } 28796| | 28797| 31| return len; 28798| 31|} pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u64_argb_abgr: 4728| 786|wuffs_base__color_swap_u64_argb_abgr(uint64_t u) { 4729| 786| uint64_t o = u & 0xFFFF0000FFFF0000ull; 4730| 786| uint64_t r = u & 0x0000FFFF00000000ull; 4731| 786| uint64_t b = u & 0x000000000000FFFFull; 4732| 786| return o | (r >> 32) | (b << 32); 4733| 786|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src: 28052| 10| size_t src_len) { 28053| 10| size_t dst_len4 = dst_len / 4; 28054| 10| size_t src_len8 = src_len / 8; 28055| 10| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28055:16): [True: 2, False: 8] ------------------ 28056| 10| uint8_t* d = dst_ptr; 28057| 10| const uint8_t* s = src_ptr; 28058| 10| size_t n = len; 28059| | 28060| | // TODO: unroll. 28061| | 28062| 103| while (n >= 1) { ------------------ | Branch (28062:10): [True: 93, False: 10] ------------------ 28063| 93| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28064| 93| wuffs_base__poke_u32le__no_bounds_check( 28065| 93| d + (0 * 4), 28066| 93| wuffs_base__color_swap_u32_argb_abgr( 28067| 93| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 28068| 93| s0))); 28069| | 28070| 93| s += 1 * 8; 28071| 93| d += 1 * 4; 28072| 93| n -= 1; 28073| 93| } 28074| | 28075| 10| return len; 28076| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over: 28085| 17| size_t src_len) { 28086| 17| size_t dst_len4 = dst_len / 4; 28087| 17| size_t src_len8 = src_len / 8; 28088| 17| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28088:16): [True: 5, False: 12] ------------------ 28089| 17| uint8_t* d = dst_ptr; 28090| 17| const uint8_t* s = src_ptr; 28091| 17| size_t n = len; 28092| | 28093| | // TODO: unroll. 28094| | 28095| 200| while (n >= 1) { ------------------ | Branch (28095:10): [True: 183, False: 17] ------------------ 28096| 183| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28097| 183| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28098| 183| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28099| 183| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28100| 183| wuffs_base__poke_u32le__no_bounds_check( 28101| 183| d + (0 * 4), 28102| 183| wuffs_base__color_u64__as__color_u32( 28103| 183| wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0))); 28104| | 28105| 183| s += 1 * 8; 28106| 183| d += 1 * 4; 28107| 183| n -= 1; 28108| 183| } 28109| | 28110| 17| return len; 28111| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul: 31274| 286| wuffs_base__pixel_blend blend) { 31275| 286| switch (dst_pixfmt.repr) { ------------------ | Branch (31275:11): [True: 261, False: 25] ------------------ 31276| 36| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 36|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31276:5): [True: 36, False: 250] ------------------ 31277| 36| switch (blend) { ------------------ | Branch (31277:15): [True: 36, False: 0] ------------------ 31278| 19| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31278:9): [True: 19, False: 17] ------------------ 31279| 19| return wuffs_private_impl__swizzle_y__bgra_premul__src; 31280| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31280:9): [True: 17, False: 19] ------------------ 31281| 17| return wuffs_private_impl__swizzle_y__bgra_premul__src_over; 31282| 36| } 31283| 0| return NULL; 31284| | 31285| 21| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 21|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31285:5): [True: 21, False: 265] ------------------ 31286| 21| switch (blend) { ------------------ | Branch (31286:15): [True: 21, False: 0] ------------------ 31287| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31287:9): [True: 10, False: 11] ------------------ 31288| 10| return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src; 31289| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31289:9): [True: 11, False: 10] ------------------ 31290| 11| return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over; 31291| 21| } 31292| 0| return NULL; 31293| | 31294| 13| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31294:5): [True: 13, False: 273] ------------------ 31295| 13| switch (blend) { ------------------ | Branch (31295:15): [True: 13, False: 0] ------------------ 31296| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31296:9): [True: 5, False: 8] ------------------ 31297| 5| return wuffs_private_impl__swizzle_bgr__bgra_premul__src; 31298| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31298:9): [True: 8, False: 5] ------------------ 31299| 8| return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; 31300| 13| } 31301| 0| return NULL; 31302| | 31303| 34| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 34|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31303:5): [True: 34, False: 252] ------------------ 31304| 34| switch (blend) { ------------------ | Branch (31304:15): [True: 34, False: 0] ------------------ 31305| 22| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 22|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31305:9): [True: 22, False: 12] ------------------ 31306| 22| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src; 31307| 12| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31307:9): [True: 12, False: 22] ------------------ 31308| 12| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; 31309| 34| } 31310| 0| return NULL; 31311| | 31312| 66| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 66|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31312:5): [True: 66, False: 220] ------------------ 31313| 66| switch (blend) { ------------------ | Branch (31313:15): [True: 66, False: 0] ------------------ 31314| 33| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 33|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31314:9): [True: 33, False: 33] ------------------ 31315| 33| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src; 31316| 33| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 33|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31316:9): [True: 33, False: 33] ------------------ 31317| 33| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over; 31318| 66| } 31319| 0| return NULL; 31320| | 31321| 23| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 23|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31321:5): [True: 23, False: 263] ------------------ 31322| 23| switch (blend) { ------------------ | Branch (31322:15): [True: 23, False: 0] ------------------ 31323| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31323:9): [True: 13, False: 10] ------------------ 31324| 13| return wuffs_private_impl__swizzle_copy_4_4; 31325| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31325:9): [True: 10, False: 13] ------------------ 31326| 10| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; 31327| 23| } 31328| 0| return NULL; 31329| | 31330| 13| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 13|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31330:5): [True: 13, False: 273] ------------------ 31331| 13| switch (blend) { ------------------ | Branch (31331:15): [True: 13, False: 0] ------------------ 31332| 6| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31332:9): [True: 6, False: 7] ------------------ 31333| 6| return wuffs_private_impl__swizzle_bgr__rgba_premul__src; 31334| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31334:9): [True: 7, False: 6] ------------------ 31335| 7| return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; 31336| 13| } 31337| 0| return NULL; 31338| | 31339| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31339:5): [True: 49, False: 237] ------------------ 31340| 49| switch (blend) { ------------------ | Branch (31340:15): [True: 49, False: 0] ------------------ 31341| 28| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 28|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31341:9): [True: 28, False: 21] ------------------ 31342| 28| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src; 31343| 21| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 21|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31343:9): [True: 21, False: 28] ------------------ 31344| 21| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; 31345| 49| } 31346| 0| return NULL; 31347| | 31348| 6| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 6|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31348:5): [True: 6, False: 280] ------------------ 31349| 6| switch (blend) { ------------------ | Branch (31349:15): [True: 6, False: 0] ------------------ 31350| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31350:9): [True: 2, False: 4] ------------------ 31351| 2|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31352| 2| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31352:15): [True: 2, False: 0] ------------------ 31353| 2| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 31354| 2| } 31355| 0|#endif 31356| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 31357| 4| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31357:9): [True: 4, False: 2] ------------------ 31358| 4| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; 31359| 6| } 31360| 0| return NULL; 31361| 286| } 31362| 25| return NULL; 31363| 286|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src: 29823| 19| size_t src_len) { 29824| 19| size_t src_len4 = src_len / 4; 29825| 19| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (29825:16): [True: 2, False: 17] ------------------ 29826| 19| uint8_t* d = dst_ptr; 29827| 19| const uint8_t* s = src_ptr; 29828| 19| size_t n = len; 29829| | 29830| | // TODO: unroll. 29831| | 29832| 364| while (n >= 1) { ------------------ | Branch (29832:10): [True: 345, False: 19] ------------------ 29833| 345| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 29834| 345| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 29835| | 29836| 345| s += 1 * 4; 29837| 345| d += 1 * 1; 29838| 345| n -= 1; 29839| 345| } 29840| | 29841| 19| return len; 29842| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src_over: 29850| 17| size_t src_len) { 29851| 17| size_t src_len4 = src_len / 4; 29852| 17| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (29852:16): [True: 2, False: 15] ------------------ 29853| 17| uint8_t* d = dst_ptr; 29854| 17| const uint8_t* s = src_ptr; 29855| 17| size_t n = len; 29856| | 29857| | // TODO: unroll. 29858| | 29859| 210| while (n >= 1) { ------------------ | Branch (29859:10): [True: 193, False: 17] ------------------ 29860| | // Extract 16-bit color components. 29861| 193| uint32_t dr = 0x101 * ((uint32_t)d[0]); 29862| 193| uint32_t dg = 0x101 * ((uint32_t)d[0]); 29863| 193| uint32_t db = 0x101 * ((uint32_t)d[0]); 29864| 193| uint32_t sa = 0x101 * ((uint32_t)s[3]); 29865| 193| uint32_t sr = 0x101 * ((uint32_t)s[2]); 29866| 193| uint32_t sg = 0x101 * ((uint32_t)s[1]); 29867| 193| uint32_t sb = 0x101 * ((uint32_t)s[0]); 29868| | 29869| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 29870| 193| uint32_t ia = 0xFFFF - sa; 29871| | 29872| | // Composite src (premul) over dst (premul). 29873| 193| dr = sr + ((dr * ia) / 0xFFFF); 29874| 193| dg = sg + ((dg * ia) / 0xFFFF); 29875| 193| db = sb + ((db * ia) / 0xFFFF); 29876| | 29877| | // Convert to 16-bit color to 8-bit gray. 29878| 193| uint32_t weighted_average = 29879| 193| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 29880| 193| d[0] = (uint8_t)(weighted_average >> 24); 29881| | 29882| 193| s += 1 * 4; 29883| 193| d += 1 * 1; 29884| 193| n -= 1; 29885| 193| } 29886| | 29887| 17| return len; 29888| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src: 25528| 10| size_t src_len) { 25529| 10| size_t dst_len2 = dst_len / 2; 25530| 10| size_t src_len4 = src_len / 4; 25531| 10| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25531:16): [True: 3, False: 7] ------------------ 25532| 10| uint8_t* d = dst_ptr; 25533| 10| const uint8_t* s = src_ptr; 25534| 10| size_t n = len; 25535| | 25536| | // TODO: unroll. 25537| | 25538| 135| while (n >= 1) { ------------------ | Branch (25538:10): [True: 125, False: 10] ------------------ 25539| 125| wuffs_base__poke_u16le__no_bounds_check( 25540| 125| d + (0 * 2), wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 25541| 125| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 25542| | 25543| 125| s += 1 * 4; 25544| 125| d += 1 * 2; 25545| 125| n -= 1; 25546| 125| } 25547| | 25548| 10| return len; 25549| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over: 25590| 11| size_t src_len) { 25591| 11| size_t dst_len2 = dst_len / 2; 25592| 11| size_t src_len4 = src_len / 4; 25593| 11| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25593:16): [True: 2, False: 9] ------------------ 25594| 11| uint8_t* d = dst_ptr; 25595| 11| const uint8_t* s = src_ptr; 25596| 11| size_t n = len; 25597| | 25598| | // TODO: unroll. 25599| | 25600| 226| while (n >= 1) { ------------------ | Branch (25600:10): [True: 215, False: 11] ------------------ 25601| | // Extract 16-bit color components. 25602| 215| uint32_t sa = 0x101 * ((uint32_t)s[3]); 25603| 215| uint32_t sr = 0x101 * ((uint32_t)s[2]); 25604| 215| uint32_t sg = 0x101 * ((uint32_t)s[1]); 25605| 215| uint32_t sb = 0x101 * ((uint32_t)s[0]); 25606| | 25607| | // Convert from 565 color to 16-bit color. 25608| 215| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 25609| 215| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 25610| 215| uint32_t dr = (0x8421 * old_r5) >> 4; 25611| 215| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 25612| 215| uint32_t dg = (0x1041 * old_g6) >> 2; 25613| 215| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 25614| 215| uint32_t db = (0x8421 * old_b5) >> 4; 25615| | 25616| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25617| 215| uint32_t ia = 0xFFFF - sa; 25618| | 25619| | // Composite src (premul) over dst (premul). 25620| 215| dr = sr + ((dr * ia) / 0xFFFF); 25621| 215| dg = sg + ((dg * ia) / 0xFFFF); 25622| 215| db = sb + ((db * ia) / 0xFFFF); 25623| | 25624| | // Convert from 16-bit color to 565 color and combine the components. 25625| 215| uint32_t new_r5 = 0x1F & (dr >> 11); 25626| 215| uint32_t new_g6 = 0x3F & (dg >> 10); 25627| 215| uint32_t new_b5 = 0x1F & (db >> 11); 25628| 215| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 25629| 215| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 25630| | 25631| 215| s += 1 * 4; 25632| 215| d += 1 * 2; 25633| 215| n -= 1; 25634| 215| } 25635| | 25636| 11| return len; 25637| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src: 26396| 16| size_t src_len) { 26397| 16| size_t dst_len3 = dst_len / 3; 26398| 16| size_t src_len4 = src_len / 4; 26399| 16| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26399:16): [True: 2, False: 14] ------------------ 26400| 16| uint8_t* d = dst_ptr; 26401| 16| const uint8_t* s = src_ptr; 26402| 16| size_t n = len; 26403| | 26404| 339| while (n >= 1) { ------------------ | Branch (26404:10): [True: 323, False: 16] ------------------ 26405| 323| uint8_t s0 = s[0]; 26406| 323| uint8_t s1 = s[1]; 26407| 323| uint8_t s2 = s[2]; 26408| 323| d[0] = s0; 26409| 323| d[1] = s1; 26410| 323| d[2] = s2; 26411| | 26412| 323| s += 1 * 4; 26413| 323| d += 1 * 3; 26414| 323| n -= 1; 26415| 323| } 26416| | 26417| 16| return len; 26418| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src_over: 26456| 11| size_t src_len) { 26457| 11| size_t dst_len3 = dst_len / 3; 26458| 11| size_t src_len4 = src_len / 4; 26459| 11| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26459:16): [True: 1, False: 10] ------------------ 26460| 11| uint8_t* d = dst_ptr; 26461| 11| const uint8_t* s = src_ptr; 26462| 11| size_t n = len; 26463| | 26464| 179| while (n >= 1) { ------------------ | Branch (26464:10): [True: 168, False: 11] ------------------ 26465| | // Extract 16-bit color components. 26466| 168| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26467| 168| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26468| 168| uint32_t db = 0x101 * ((uint32_t)d[0]); 26469| 168| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26470| 168| uint32_t sr = 0x101 * ((uint32_t)s[2]); 26471| 168| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26472| 168| uint32_t sb = 0x101 * ((uint32_t)s[0]); 26473| | 26474| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26475| 168| uint32_t ia = 0xFFFF - sa; 26476| | 26477| | // Composite src (premul) over dst (premul). 26478| 168| dr = sr + ((dr * ia) / 0xFFFF); 26479| 168| dg = sg + ((dg * ia) / 0xFFFF); 26480| 168| db = sb + ((db * ia) / 0xFFFF); 26481| | 26482| | // Convert from 16-bit color to 8-bit color. 26483| 168| d[0] = (uint8_t)(db >> 8); 26484| 168| d[1] = (uint8_t)(dg >> 8); 26485| 168| d[2] = (uint8_t)(dr >> 8); 26486| | 26487| 168| s += 1 * 4; 26488| 168| d += 1 * 3; 26489| 168| n -= 1; 26490| 168| } 26491| | 26492| 11| return len; 26493| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src: 26985| 45| size_t src_len) { 26986| 45| size_t dst_len4 = dst_len / 4; 26987| 45| size_t src_len4 = src_len / 4; 26988| 45| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (26988:16): [True: 13, False: 32] ------------------ 26989| 45| uint8_t* d = dst_ptr; 26990| 45| const uint8_t* s = src_ptr; 26991| 45| size_t n = len; 26992| | 26993| 660| while (n >= 1) { ------------------ | Branch (26993:10): [True: 615, False: 45] ------------------ 26994| 615| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 26995| 615| wuffs_base__poke_u32le__no_bounds_check( 26996| 615| d + (0 * 4), 26997| 615| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0)); 26998| | 26999| 615| s += 1 * 4; 27000| 615| d += 1 * 4; 27001| 615| n -= 1; 27002| 615| } 27003| | 27004| 45| return len; 27005| 45|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over: 27014| 32| size_t src_len) { 27015| 32| size_t dst_len4 = dst_len / 4; 27016| 32| size_t src_len4 = src_len / 4; 27017| 32| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27017:16): [True: 7, False: 25] ------------------ 27018| 32| uint8_t* d = dst_ptr; 27019| 32| const uint8_t* s = src_ptr; 27020| 32| size_t n = len; 27021| | 27022| 430| while (n >= 1) { ------------------ | Branch (27022:10): [True: 398, False: 32] ------------------ 27023| 398| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27024| 398| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27025| 398| wuffs_base__poke_u32le__no_bounds_check( 27026| 398| d + (0 * 4), 27027| 398| wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0)); 27028| | 27029| 398| s += 1 * 4; 27030| 398| d += 1 * 4; 27031| 398| n -= 1; 27032| 398| } 27033| | 27034| 32| return len; 27035| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u32_axxx: 24808| 771| uint32_t src_premul) { 24809| | // Extract 16-bit color components. 24810| 771| uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24)); 24811| 771| uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16)); 24812| 771| uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8)); 24813| 771| uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0)); 24814| 771| uint32_t sa = 0x101 * (0xFF & (src_premul >> 24)); 24815| 771| uint32_t sr = 0x101 * (0xFF & (src_premul >> 16)); 24816| 771| uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)); 24817| 771| uint32_t sb = 0x101 * (0xFF & (src_premul >> 0)); 24818| | 24819| | // Convert dst from nonpremul to premul. 24820| 771| dr = (dr * da) / 0xFFFF; 24821| 771| dg = (dg * da) / 0xFFFF; 24822| 771| db = (db * da) / 0xFFFF; 24823| | 24824| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24825| 771| uint32_t ia = 0xFFFF - sa; 24826| | 24827| | // Composite src (premul) over dst (premul). 24828| 771| da = sa + ((da * ia) / 0xFFFF); 24829| 771| dr = sr + ((dr * ia) / 0xFFFF); 24830| 771| dg = sg + ((dg * ia) / 0xFFFF); 24831| 771| db = sb + ((db * ia) / 0xFFFF); 24832| | 24833| | // Convert dst from premul to nonpremul. 24834| 771| if (da != 0) { ------------------ | Branch (24834:7): [True: 639, False: 132] ------------------ 24835| 639| dr = (dr * 0xFFFF) / da; 24836| 639| dg = (dg * 0xFFFF) / da; 24837| 639| db = (db * 0xFFFF) / da; 24838| 639| } 24839| | 24840| | // Convert from 16-bit color to 8-bit color. 24841| 771| da >>= 8; 24842| 771| dr >>= 8; 24843| 771| dg >>= 8; 24844| 771| db >>= 8; 24845| | 24846| | // Combine components. 24847| 771| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 24848| 771|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src: 27391| 33| size_t src_len) { 27392| 33| size_t dst_len8 = dst_len / 8; 27393| 33| size_t src_len4 = src_len / 4; 27394| 33| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27394:16): [True: 16, False: 17] ------------------ 27395| 33| uint8_t* d = dst_ptr; 27396| 33| const uint8_t* s = src_ptr; 27397| | 27398| 33| size_t n = len; 27399| 206| while (n >= 1) { ------------------ | Branch (27399:10): [True: 173, False: 33] ------------------ 27400| 173| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 27401| 173| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 27402| 173| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 27403| 173| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 27404| | 27405| 173| s += 1 * 4; 27406| 173| d += 1 * 8; 27407| 173| n -= 1; 27408| 173| } 27409| 33| return len; 27410| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over: 27419| 33| size_t src_len) { 27420| 33| size_t dst_len8 = dst_len / 8; 27421| 33| size_t src_len4 = src_len / 4; 27422| 33| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27422:16): [True: 8, False: 25] ------------------ 27423| 33| uint8_t* d = dst_ptr; 27424| 33| const uint8_t* s = src_ptr; 27425| | 27426| 33| size_t n = len; 27427| 293| while (n >= 1) { ------------------ | Branch (27427:10): [True: 260, False: 33] ------------------ 27428| 260| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27429| 260| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 27430| 260| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27431| 260| wuffs_base__poke_u64le__no_bounds_check( 27432| 260| d + (0 * 8), 27433| 260| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 27434| | 27435| 260| s += 1 * 4; 27436| 260| d += 1 * 8; 27437| 260| n -= 1; 27438| 260| } 27439| 33| return len; 27440| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u64_axxx: 24852| 1.23k| uint64_t src_premul) { 24853| | // Extract components. 24854| 1.23k| uint64_t da = 0xFFFF & (dst_nonpremul >> 48); 24855| 1.23k| uint64_t dr = 0xFFFF & (dst_nonpremul >> 32); 24856| 1.23k| uint64_t dg = 0xFFFF & (dst_nonpremul >> 16); 24857| 1.23k| uint64_t db = 0xFFFF & (dst_nonpremul >> 0); 24858| 1.23k| uint64_t sa = 0xFFFF & (src_premul >> 48); 24859| 1.23k| uint64_t sr = 0xFFFF & (src_premul >> 32); 24860| 1.23k| uint64_t sg = 0xFFFF & (src_premul >> 16); 24861| 1.23k| uint64_t sb = 0xFFFF & (src_premul >> 0); 24862| | 24863| | // Convert dst from nonpremul to premul. 24864| 1.23k| dr = (dr * da) / 0xFFFF; 24865| 1.23k| dg = (dg * da) / 0xFFFF; 24866| 1.23k| db = (db * da) / 0xFFFF; 24867| | 24868| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24869| 1.23k| uint64_t ia = 0xFFFF - sa; 24870| | 24871| | // Composite src (premul) over dst (premul). 24872| 1.23k| da = sa + ((da * ia) / 0xFFFF); 24873| 1.23k| dr = sr + ((dr * ia) / 0xFFFF); 24874| 1.23k| dg = sg + ((dg * ia) / 0xFFFF); 24875| 1.23k| db = sb + ((db * ia) / 0xFFFF); 24876| | 24877| | // Convert dst from premul to nonpremul. 24878| 1.23k| if (da != 0) { ------------------ | Branch (24878:7): [True: 1.05k, False: 177] ------------------ 24879| 1.05k| dr = (dr * 0xFFFF) / da; 24880| 1.05k| dg = (dg * 0xFFFF) / da; 24881| 1.05k| db = (db * 0xFFFF) / da; 24882| 1.05k| } 24883| | 24884| | // Combine components. 24885| 1.23k| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 24886| 1.23k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over: 27885| 19| size_t src_len) { 27886| 19| size_t dst_len4 = dst_len / 4; 27887| 19| size_t src_len4 = src_len / 4; 27888| 19| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27888:16): [True: 6, False: 13] ------------------ 27889| 19| uint8_t* d = dst_ptr; 27890| 19| const uint8_t* s = src_ptr; 27891| 19| size_t n = len; 27892| | 27893| | // TODO: unroll. 27894| | 27895| 410| while (n >= 1) { ------------------ | Branch (27895:10): [True: 391, False: 19] ------------------ 27896| 391| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27897| 391| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27898| 391| wuffs_base__poke_u32le__no_bounds_check( 27899| 391| d + (0 * 4), 27900| 391| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 27901| | 27902| 391| s += 1 * 4; 27903| 391| d += 1 * 4; 27904| 391| n -= 1; 27905| 391| } 27906| | 27907| 19| return len; 27908| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u32_axxx: 24950| 1.18k| uint32_t src_premul) { 24951| | // Extract 16-bit color components. 24952| 1.18k| uint32_t da = 0x101 * (0xFF & (dst_premul >> 24)); 24953| 1.18k| uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16)); 24954| 1.18k| uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8)); 24955| 1.18k| uint32_t db = 0x101 * (0xFF & (dst_premul >> 0)); 24956| 1.18k| uint32_t sa = 0x101 * (0xFF & (src_premul >> 24)); 24957| 1.18k| uint32_t sr = 0x101 * (0xFF & (src_premul >> 16)); 24958| 1.18k| uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)); 24959| 1.18k| uint32_t sb = 0x101 * (0xFF & (src_premul >> 0)); 24960| | 24961| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24962| 1.18k| uint32_t ia = 0xFFFF - sa; 24963| | 24964| | // Composite src (premul) over dst (premul). 24965| 1.18k| da = sa + ((da * ia) / 0xFFFF); 24966| 1.18k| dr = sr + ((dr * ia) / 0xFFFF); 24967| 1.18k| dg = sg + ((dg * ia) / 0xFFFF); 24968| 1.18k| db = sb + ((db * ia) / 0xFFFF); 24969| | 24970| | // Convert from 16-bit color to 8-bit color. 24971| 1.18k| da >>= 8; 24972| 1.18k| dr >>= 8; 24973| 1.18k| dg >>= 8; 24974| 1.18k| db >>= 8; 24975| | 24976| | // Combine components. 24977| 1.18k| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 24978| 1.18k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul__src: 26706| 14| size_t src_len) { 26707| 14| size_t dst_len3 = dst_len / 3; 26708| 14| size_t src_len4 = src_len / 4; 26709| 14| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26709:16): [True: 3, False: 11] ------------------ 26710| 14| uint8_t* d = dst_ptr; 26711| 14| const uint8_t* s = src_ptr; 26712| 14| size_t n = len; 26713| | 26714| 204| while (n >= 1) { ------------------ | Branch (26714:10): [True: 190, False: 14] ------------------ 26715| 190| uint8_t s0 = s[0]; 26716| 190| uint8_t s1 = s[1]; 26717| 190| uint8_t s2 = s[2]; 26718| 190| d[0] = s2; 26719| 190| d[1] = s1; 26720| 190| d[2] = s0; 26721| | 26722| 190| s += 1 * 4; 26723| 190| d += 1 * 3; 26724| 190| n -= 1; 26725| 190| } 26726| | 26727| 14| return len; 26728| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul__src_over: 26767| 14| size_t src_len) { 26768| 14| size_t dst_len3 = dst_len / 3; 26769| 14| size_t src_len4 = src_len / 4; 26770| 14| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26770:16): [True: 3, False: 11] ------------------ 26771| 14| uint8_t* d = dst_ptr; 26772| 14| const uint8_t* s = src_ptr; 26773| 14| size_t n = len; 26774| | 26775| 345| while (n >= 1) { ------------------ | Branch (26775:10): [True: 331, False: 14] ------------------ 26776| | // Extract 16-bit color components. 26777| 331| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26778| 331| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26779| 331| uint32_t db = 0x101 * ((uint32_t)d[0]); 26780| 331| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26781| 331| uint32_t sb = 0x101 * ((uint32_t)s[2]); 26782| 331| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26783| 331| uint32_t sr = 0x101 * ((uint32_t)s[0]); 26784| | 26785| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26786| 331| uint32_t ia = 0xFFFF - sa; 26787| | 26788| | // Composite src (premul) over dst (premul). 26789| 331| dr = sr + ((dr * ia) / 0xFFFF); 26790| 331| dg = sg + ((dg * ia) / 0xFFFF); 26791| 331| db = sb + ((db * ia) / 0xFFFF); 26792| | 26793| | // Convert from 16-bit color to 8-bit color. 26794| 331| d[0] = (uint8_t)(db >> 8); 26795| 331| d[1] = (uint8_t)(dg >> 8); 26796| 331| d[2] = (uint8_t)(dr >> 8); 26797| | 26798| 331| s += 1 * 4; 26799| 331| d += 1 * 3; 26800| 331| n -= 1; 26801| 331| } 26802| | 26803| 14| return len; 26804| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src: 27172| 41| size_t src_len) { 27173| 41| size_t dst_len4 = dst_len / 4; 27174| 41| size_t src_len4 = src_len / 4; 27175| 41| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27175:16): [True: 5, False: 36] ------------------ 27176| 41| uint8_t* d = dst_ptr; 27177| 41| const uint8_t* s = src_ptr; 27178| 41| size_t n = len; 27179| | 27180| 571| while (n >= 1) { ------------------ | Branch (27180:10): [True: 530, False: 41] ------------------ 27181| 530| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27182| 530| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27183| 530| wuffs_base__poke_u32le__no_bounds_check( 27184| 530| d + (0 * 4), 27185| 530| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0)); 27186| | 27187| 530| s += 1 * 4; 27188| 530| d += 1 * 4; 27189| 530| n -= 1; 27190| 530| } 27191| | 27192| 41| return len; 27193| 41|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over: 27202| 31| size_t src_len) { 27203| 31| size_t dst_len4 = dst_len / 4; 27204| 31| size_t src_len4 = src_len / 4; 27205| 31| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27205:16): [True: 9, False: 22] ------------------ 27206| 31| uint8_t* d = dst_ptr; 27207| 31| const uint8_t* s = src_ptr; 27208| 31| size_t n = len; 27209| | 27210| 404| while (n >= 1) { ------------------ | Branch (27210:10): [True: 373, False: 31] ------------------ 27211| 373| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27212| 373| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27213| 373| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27214| 373| wuffs_base__poke_u32le__no_bounds_check( 27215| 373| d + (0 * 4), 27216| 373| wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0)); 27217| | 27218| 373| s += 1 * 4; 27219| 373| d += 1 * 4; 27220| 373| n -= 1; 27221| 373| } 27222| | 27223| 31| return len; 27224| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over: 28120| 19| size_t src_len) { 28121| 19| size_t dst_len4 = dst_len / 4; 28122| 19| size_t src_len4 = src_len / 4; 28123| 19| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28123:16): [True: 6, False: 13] ------------------ 28124| 19| uint8_t* d = dst_ptr; 28125| 19| const uint8_t* s = src_ptr; 28126| 19| size_t n = len; 28127| | 28128| 403| while (n >= 1) { ------------------ | Branch (28128:10): [True: 384, False: 19] ------------------ 28129| 384| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28130| 384| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28131| 384| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28132| 384| wuffs_base__poke_u32le__no_bounds_check( 28133| 384| d + (0 * 4), 28134| 384| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 28135| | 28136| 384| s += 1 * 4; 28137| 384| d += 1 * 4; 28138| 384| n -= 1; 28139| 384| } 28140| | 28141| 19| return len; 28142| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le: 31371| 434| wuffs_base__pixel_blend blend) { 31372| 434| switch (dst_pixfmt.repr) { ------------------ | Branch (31372:11): [True: 425, False: 9] ------------------ 31373| 27| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 27|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31373:5): [True: 27, False: 407] ------------------ 31374| 27| switch (blend) { ------------------ | Branch (31374:15): [True: 27, False: 0] ------------------ 31375| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31375:9): [True: 10, False: 17] ------------------ 31376| 10| return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src; 31377| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31377:9): [True: 17, False: 10] ------------------ 31378| 17| return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over; 31379| 27| } 31380| 0| return NULL; 31381| | 31382| 27| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 27|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31382:5): [True: 27, False: 407] ------------------ 31383| 27| switch (blend) { ------------------ | Branch (31383:15): [True: 27, False: 0] ------------------ 31384| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31384:9): [True: 10, False: 17] ------------------ 31385| 10| return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src; 31386| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31386:9): [True: 17, False: 10] ------------------ 31387| 17| return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over; 31388| 27| } 31389| 0| return NULL; 31390| | 31391| 22| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31391:5): [True: 22, False: 412] ------------------ 31392| 22| switch (blend) { ------------------ | Branch (31392:15): [True: 22, False: 0] ------------------ 31393| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31393:9): [True: 8, False: 14] ------------------ 31394| 8| return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src; 31395| 14| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31395:9): [True: 14, False: 8] ------------------ 31396| 14| return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over; 31397| 22| } 31398| 0| return NULL; 31399| | 31400| 86| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 86|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31400:5): [True: 86, False: 348] ------------------ 31401| 86| switch (blend) { ------------------ | Branch (31401:15): [True: 86, False: 0] ------------------ 31402| 54| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 54|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31402:9): [True: 54, False: 32] ------------------ 31403| 54| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src; 31404| 32| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31404:9): [True: 32, False: 54] ------------------ 31405| 32| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over; 31406| 86| } 31407| 0| return NULL; 31408| | 31409| 71| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 71|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31409:5): [True: 71, False: 363] ------------------ 31410| | 31411| 71| switch (blend) { ------------------ | Branch (31411:15): [True: 71, False: 0] ------------------ 31412| 44| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 44|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31412:9): [True: 44, False: 27] ------------------ 31413| 44| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src; 31414| 27| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 27|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31414:9): [True: 27, False: 44] ------------------ 31415| 27| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over; 31416| 71| } 31417| 0| return NULL; 31418| | 31419| 27| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 27|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31419:5): [True: 27, False: 407] ------------------ 31420| 27| switch (blend) { ------------------ | Branch (31420:15): [True: 27, False: 0] ------------------ 31421| 14| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31421:9): [True: 14, False: 13] ------------------ 31422| 14| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src; 31423| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31423:9): [True: 13, False: 14] ------------------ 31424| 13| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src_over; 31425| 27| } 31426| 0| return NULL; 31427| | 31428| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4851| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31428:5): [True: 17, False: 417] ------------------ 31429| 17| switch (blend) { ------------------ | Branch (31429:15): [True: 17, False: 0] ------------------ 31430| 0| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31430:9): [True: 0, False: 17] ------------------ 31431| 0| return wuffs_private_impl__swizzle_copy_8_8; 31432| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31432:9): [True: 17, False: 0] ------------------ 31433| 17| return wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over; 31434| 17| } 31435| 0| return NULL; 31436| | 31437| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31437:5): [True: 0, False: 434] ------------------ 31438| 5| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31438:5): [True: 5, False: 429] ------------------ 31439| | // TODO. 31440| 5| break; 31441| | 31442| 29| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 29|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31442:5): [True: 29, False: 405] ------------------ 31443| 29| switch (blend) { ------------------ | Branch (31443:15): [True: 29, False: 0] ------------------ 31444| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31444:9): [True: 11, False: 18] ------------------ 31445| 11| return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src; 31446| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31446:9): [True: 18, False: 11] ------------------ 31447| 18| return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over; 31448| 29| } 31449| 0| return NULL; 31450| | 31451| 84| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 84|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31451:5): [True: 84, False: 350] ------------------ 31452| 84| switch (blend) { ------------------ | Branch (31452:15): [True: 84, False: 0] ------------------ 31453| 52| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 52|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31453:9): [True: 52, False: 32] ------------------ 31454| 52| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src; 31455| 32| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31455:9): [True: 32, False: 52] ------------------ 31456| 32| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over; 31457| 84| } 31458| 0| break; 31459| | 31460| 30| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 30|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31460:5): [True: 30, False: 404] ------------------ 31461| 30| switch (blend) { ------------------ | Branch (31461:15): [True: 30, False: 0] ------------------ 31462| 19| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31462:9): [True: 19, False: 11] ------------------ 31463| 19| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src; 31464| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31464:9): [True: 11, False: 19] ------------------ 31465| 11| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src_over; 31466| 30| } 31467| 0| return NULL; 31468| | 31469| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31469:5): [True: 0, False: 434] ------------------ 31470| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31470:5): [True: 0, False: 434] ------------------ 31471| | // TODO. 31472| 0| break; 31473| 434| } 31474| 14| return NULL; 31475| 434|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src: 29896| 10| size_t src_len) { 29897| 10| size_t src_len8 = src_len / 8; 29898| 10| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (29898:16): [True: 1, False: 9] ------------------ 29899| 10| uint8_t* d = dst_ptr; 29900| 10| const uint8_t* s = src_ptr; 29901| 10| size_t n = len; 29902| | 29903| | // TODO: unroll. 29904| | 29905| 114| while (n >= 1) { ------------------ | Branch (29905:10): [True: 104, False: 10] ------------------ 29906| 104| d[0] = wuffs_base__color_u64_argb_premul__as__color_u8_gray( 29907| 104| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 29908| | 29909| 104| s += 1 * 8; 29910| 104| d += 1 * 1; 29911| 104| n -= 1; 29912| 104| } 29913| | 29914| 10| return len; 29915| 10|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u8_gray: 4560| 104|wuffs_base__color_u64_argb_premul__as__color_u8_gray(uint64_t argb_premul) { 4561| 104| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_premul >> 32))); 4562| 104| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_premul >> 16))); 4563| 104| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_premul >> 0))); 4564| | 4565| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4566| | // as those given by the JFIF specification. 4567| | // 4568| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We 4569| | // shift by 24, not just by 16, because the return value is 8-bit color, not 4570| | // 16-bit color. 4571| 104| uint32_t weighted_average = 4572| 104| (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; 4573| 104| return (uint8_t)(weighted_average >> 24); 4574| 104|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over: 29924| 17| size_t src_len) { 29925| 17| size_t src_len8 = src_len / 8; 29926| 17| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (29926:16): [True: 3, False: 14] ------------------ 29927| 17| uint8_t* d = dst_ptr; 29928| 17| const uint8_t* s = src_ptr; 29929| 17| size_t n = len; 29930| | 29931| | // TODO: unroll. 29932| | 29933| 177| while (n >= 1) { ------------------ | Branch (29933:10): [True: 160, False: 17] ------------------ 29934| | // Extract 16-bit color components. 29935| 160| uint32_t dr = 0x101 * ((uint32_t)d[0]); 29936| 160| uint32_t dg = 0x101 * ((uint32_t)d[0]); 29937| 160| uint32_t db = 0x101 * ((uint32_t)d[0]); 29938| 160| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 29939| 160| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 29940| 160| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 29941| 160| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 29942| | 29943| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 29944| 160| uint32_t ia = 0xFFFF - sa; 29945| | 29946| | // Composite src (premul) over dst (premul). 29947| 160| dr = sr + ((dr * ia) / 0xFFFF); 29948| 160| dg = sg + ((dg * ia) / 0xFFFF); 29949| 160| db = sb + ((db * ia) / 0xFFFF); 29950| | 29951| | // Convert to 16-bit color to 8-bit gray. 29952| 160| uint32_t weighted_average = 29953| 160| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 29954| 160| d[0] = (uint8_t)(weighted_average >> 24); 29955| | 29956| 160| s += 1 * 8; 29957| 160| d += 1 * 1; 29958| 160| n -= 1; 29959| 160| } 29960| | 29961| 17| return len; 29962| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src: 25558| 10| size_t src_len) { 25559| 10| size_t dst_len2 = dst_len / 2; 25560| 10| size_t src_len8 = src_len / 8; 25561| 10| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (25561:16): [True: 5, False: 5] ------------------ 25562| 10| uint8_t* d = dst_ptr; 25563| 10| const uint8_t* s = src_ptr; 25564| 10| size_t n = len; 25565| | 25566| | // TODO: unroll. 25567| | 25568| 81| while (n >= 1) { ------------------ | Branch (25568:10): [True: 71, False: 10] ------------------ 25569| 71| wuffs_base__poke_u16le__no_bounds_check( 25570| 71| d + (0 * 2), 25571| 71| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 25572| 71| wuffs_base__color_u64__as__color_u32( 25573| 71| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 25574| | 25575| 71| s += 1 * 8; 25576| 71| d += 1 * 2; 25577| 71| n -= 1; 25578| 71| } 25579| | 25580| 10| return len; 25581| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over: 25646| 17| size_t src_len) { 25647| 17| size_t dst_len2 = dst_len / 2; 25648| 17| size_t src_len8 = src_len / 8; 25649| 17| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (25649:16): [True: 1, False: 16] ------------------ 25650| 17| uint8_t* d = dst_ptr; 25651| 17| const uint8_t* s = src_ptr; 25652| 17| size_t n = len; 25653| | 25654| | // TODO: unroll. 25655| | 25656| 193| while (n >= 1) { ------------------ | Branch (25656:10): [True: 176, False: 17] ------------------ 25657| | // Extract 16-bit color components. 25658| 176| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 25659| 176| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 25660| 176| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 25661| 176| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 25662| | 25663| | // Convert from 565 color to 16-bit color. 25664| 176| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 25665| 176| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 25666| 176| uint32_t dr = (0x8421 * old_r5) >> 4; 25667| 176| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 25668| 176| uint32_t dg = (0x1041 * old_g6) >> 2; 25669| 176| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 25670| 176| uint32_t db = (0x8421 * old_b5) >> 4; 25671| | 25672| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25673| 176| uint32_t ia = 0xFFFF - sa; 25674| | 25675| | // Composite src (premul) over dst (premul). 25676| 176| dr = sr + ((dr * ia) / 0xFFFF); 25677| 176| dg = sg + ((dg * ia) / 0xFFFF); 25678| 176| db = sb + ((db * ia) / 0xFFFF); 25679| | 25680| | // Convert from 16-bit color to 565 color and combine the components. 25681| 176| uint32_t new_r5 = 0x1F & (dr >> 11); 25682| 176| uint32_t new_g6 = 0x3F & (dg >> 10); 25683| 176| uint32_t new_b5 = 0x1F & (db >> 11); 25684| 176| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 25685| 176| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 25686| | 25687| 176| s += 1 * 8; 25688| 176| d += 1 * 2; 25689| 176| n -= 1; 25690| 176| } 25691| | 25692| 17| return len; 25693| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src: 26427| 8| size_t src_len) { 26428| 8| size_t dst_len3 = dst_len / 3; 26429| 8| size_t src_len8 = src_len / 8; 26430| 8| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26430:16): [True: 1, False: 7] ------------------ 26431| 8| uint8_t* d = dst_ptr; 26432| 8| const uint8_t* s = src_ptr; 26433| 8| size_t n = len; 26434| | 26435| | // TODO: unroll. 26436| | 26437| 55| while (n >= 1) { ------------------ | Branch (26437:10): [True: 47, False: 8] ------------------ 26438| 47| uint32_t s0 = wuffs_base__color_u64__as__color_u32( 26439| 47| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 26440| 47| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26441| | 26442| 47| s += 1 * 8; 26443| 47| d += 1 * 3; 26444| 47| n -= 1; 26445| 47| } 26446| | 26447| 8| return len; 26448| 8|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over: 26502| 14| size_t src_len) { 26503| 14| size_t dst_len3 = dst_len / 3; 26504| 14| size_t src_len8 = src_len / 8; 26505| 14| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26505:16): [True: 2, False: 12] ------------------ 26506| 14| uint8_t* d = dst_ptr; 26507| 14| const uint8_t* s = src_ptr; 26508| 14| size_t n = len; 26509| | 26510| | // TODO: unroll. 26511| | 26512| 166| while (n >= 1) { ------------------ | Branch (26512:10): [True: 152, False: 14] ------------------ 26513| | // Extract 16-bit color components. 26514| 152| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26515| 152| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26516| 152| uint32_t db = 0x101 * ((uint32_t)d[0]); 26517| 152| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26518| 152| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26519| 152| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26520| 152| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 26521| | 26522| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26523| 152| uint32_t ia = 0xFFFF - sa; 26524| | 26525| | // Composite src (premul) over dst (premul). 26526| 152| dr = sr + ((dr * ia) / 0xFFFF); 26527| 152| dg = sg + ((dg * ia) / 0xFFFF); 26528| 152| db = sb + ((db * ia) / 0xFFFF); 26529| | 26530| | // Convert from 16-bit color to 8-bit color. 26531| 152| d[0] = (uint8_t)(db >> 8); 26532| 152| d[1] = (uint8_t)(dg >> 8); 26533| 152| d[2] = (uint8_t)(dr >> 8); 26534| | 26535| 152| s += 1 * 8; 26536| 152| d += 1 * 3; 26537| 152| n -= 1; 26538| 152| } 26539| | 26540| 14| return len; 26541| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src: 27044| 54| size_t src_len) { 27045| 54| size_t dst_len4 = dst_len / 4; 27046| 54| size_t src_len8 = src_len / 8; 27047| 54| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27047:16): [True: 7, False: 47] ------------------ 27048| 54| uint8_t* d = dst_ptr; 27049| 54| const uint8_t* s = src_ptr; 27050| | 27051| 54| size_t n = len; 27052| 467| while (n >= 1) { ------------------ | Branch (27052:10): [True: 413, False: 54] ------------------ 27053| 413| wuffs_base__poke_u32le__no_bounds_check( 27054| 413| d + (0 * 4), 27055| 413| wuffs_base__color_u64__as__color_u32( 27056| 413| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul( 27057| 413| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 27058| | 27059| 413| s += 1 * 8; 27060| 413| d += 1 * 4; 27061| 413| n -= 1; 27062| 413| } 27063| 54| return len; 27064| 54|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul: 4578| 961| uint64_t argb_premul) { 4579| 961| uint64_t a = 0xFFFF & (argb_premul >> 48); 4580| 961| if (a == 0xFFFF) { ------------------ | Branch (4580:7): [True: 117, False: 844] ------------------ 4581| 117| return argb_premul; 4582| 844| } else if (a == 0) { ------------------ | Branch (4582:14): [True: 122, False: 722] ------------------ 4583| 122| return 0; 4584| 122| } 4585| | 4586| 722| uint64_t r = 0xFFFF & (argb_premul >> 32); 4587| 722| r = (r * 0xFFFF) / a; 4588| 722| uint64_t g = 0xFFFF & (argb_premul >> 16); 4589| 722| g = (g * 0xFFFF) / a; 4590| 722| uint64_t b = 0xFFFF & (argb_premul >> 0); 4591| 722| b = (b * 0xFFFF) / a; 4592| | 4593| 722| return (a << 48) | (r << 32) | (g << 16) | (b << 0); 4594| 961|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over: 27073| 32| size_t src_len) { 27074| 32| size_t dst_len4 = dst_len / 4; 27075| 32| size_t src_len8 = src_len / 8; 27076| 32| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27076:16): [True: 1, False: 31] ------------------ 27077| 32| uint8_t* d = dst_ptr; 27078| 32| const uint8_t* s = src_ptr; 27079| 32| size_t n = len; 27080| | 27081| 283| while (n >= 1) { ------------------ | Branch (27081:10): [True: 251, False: 32] ------------------ 27082| 251| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 27083| 251| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 27084| 251| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27085| 251| wuffs_base__poke_u32le__no_bounds_check( 27086| 251| d + (0 * 4), 27087| 251| wuffs_base__color_u64__as__color_u32( 27088| 251| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0))); 27089| | 27090| 251| s += 1 * 8; 27091| 251| d += 1 * 4; 27092| 251| n -= 1; 27093| 251| } 27094| | 27095| 32| return len; 27096| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src: 27449| 44| size_t src_len) { 27450| 44| size_t dst_len8 = dst_len / 8; 27451| 44| size_t src_len8 = src_len / 8; 27452| 44| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (27452:16): [True: 12, False: 32] ------------------ 27453| 44| uint8_t* d = dst_ptr; 27454| 44| const uint8_t* s = src_ptr; 27455| | 27456| 44| size_t n = len; 27457| 257| while (n >= 1) { ------------------ | Branch (27457:10): [True: 213, False: 44] ------------------ 27458| 213| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27459| 213| wuffs_base__poke_u64le__no_bounds_check( 27460| 213| d + (0 * 8), 27461| 213| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(s0)); 27462| | 27463| 213| s += 1 * 8; 27464| 213| d += 1 * 8; 27465| 213| n -= 1; 27466| 213| } 27467| 44| return len; 27468| 44|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over: 27477| 27| size_t src_len) { 27478| 27| size_t dst_len8 = dst_len / 8; 27479| 27| size_t src_len8 = src_len / 8; 27480| 27| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (27480:16): [True: 2, False: 25] ------------------ 27481| 27| uint8_t* d = dst_ptr; 27482| 27| const uint8_t* s = src_ptr; 27483| | 27484| 27| size_t n = len; 27485| 254| while (n >= 1) { ------------------ | Branch (27485:10): [True: 227, False: 27] ------------------ 27486| 227| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27487| 227| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27488| 227| wuffs_base__poke_u64le__no_bounds_check( 27489| 227| d + (0 * 8), 27490| 227| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 27491| | 27492| 227| s += 1 * 8; 27493| 227| d += 1 * 8; 27494| 227| n -= 1; 27495| 227| } 27496| 27| return len; 27497| 27|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src: 27855| 14| size_t src_len) { 27856| 14| size_t dst_len4 = dst_len / 4; 27857| 14| size_t src_len8 = src_len / 8; 27858| 14| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27858:16): [True: 1, False: 13] ------------------ 27859| 14| uint8_t* d = dst_ptr; 27860| 14| const uint8_t* s = src_ptr; 27861| 14| size_t n = len; 27862| | 27863| | // TODO: unroll. 27864| | 27865| 177| while (n >= 1) { ------------------ | Branch (27865:10): [True: 163, False: 14] ------------------ 27866| 163| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27867| 163| wuffs_base__poke_u32le__no_bounds_check( 27868| 163| d + (0 * 4), wuffs_base__color_u64__as__color_u32(s0)); 27869| | 27870| 163| s += 1 * 8; 27871| 163| d += 1 * 4; 27872| 163| n -= 1; 27873| 163| } 27874| | 27875| 14| return len; 27876| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src_over: 27917| 13| size_t src_len) { 27918| 13| size_t dst_len4 = dst_len / 4; 27919| 13| size_t src_len8 = src_len / 8; 27920| 13| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27920:16): [True: 1, False: 12] ------------------ 27921| 13| uint8_t* d = dst_ptr; 27922| 13| const uint8_t* s = src_ptr; 27923| 13| size_t n = len; 27924| | 27925| | // TODO: unroll. 27926| | 27927| 151| while (n >= 1) { ------------------ | Branch (27927:10): [True: 138, False: 13] ------------------ 27928| 138| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 27929| 138| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 27930| 138| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27931| 138| wuffs_base__poke_u32le__no_bounds_check( 27932| 138| d + (0 * 4), 27933| 138| wuffs_base__color_u64__as__color_u32( 27934| 138| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0))); 27935| | 27936| 138| s += 1 * 8; 27937| 138| d += 1 * 4; 27938| 138| n -= 1; 27939| 138| } 27940| | 27941| 13| return len; 27942| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u64_axxx: 24982| 403| uint64_t src_premul) { 24983| | // Extract components. 24984| 403| uint64_t da = 0xFFFF & (dst_premul >> 48); 24985| 403| uint64_t dr = 0xFFFF & (dst_premul >> 32); 24986| 403| uint64_t dg = 0xFFFF & (dst_premul >> 16); 24987| 403| uint64_t db = 0xFFFF & (dst_premul >> 0); 24988| 403| uint64_t sa = 0xFFFF & (src_premul >> 48); 24989| 403| uint64_t sr = 0xFFFF & (src_premul >> 32); 24990| 403| uint64_t sg = 0xFFFF & (src_premul >> 16); 24991| 403| uint64_t sb = 0xFFFF & (src_premul >> 0); 24992| | 24993| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 24994| 403| uint64_t ia = 0xFFFF - sa; 24995| | 24996| | // Composite src (premul) over dst (premul). 24997| 403| da = sa + ((da * ia) / 0xFFFF); 24998| 403| dr = sr + ((dr * ia) / 0xFFFF); 24999| 403| dg = sg + ((dg * ia) / 0xFFFF); 25000| 403| db = sb + ((db * ia) / 0xFFFF); 25001| | 25002| | // Combine components. 25003| 403| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25004| 403|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over: 28282| 17| size_t src_len) { 28283| 17| size_t dst_len8 = dst_len / 8; 28284| 17| size_t src_len8 = src_len / 8; 28285| 17| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (28285:16): [True: 5, False: 12] ------------------ 28286| 17| uint8_t* d = dst_ptr; 28287| 17| const uint8_t* s = src_ptr; 28288| | 28289| 17| size_t n = len; 28290| 178| while (n >= 1) { ------------------ | Branch (28290:10): [True: 161, False: 17] ------------------ 28291| 161| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28292| 161| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28293| 161| wuffs_base__poke_u64le__no_bounds_check( 28294| 161| d + (0 * 8), 28295| 161| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0)); 28296| | 28297| 161| s += 1 * 8; 28298| 161| d += 1 * 8; 28299| 161| n -= 1; 28300| 161| } 28301| 17| return len; 28302| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src: 26737| 11| size_t src_len) { 26738| 11| size_t dst_len3 = dst_len / 3; 26739| 11| size_t src_len8 = src_len / 8; 26740| 11| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26740:16): [True: 1, False: 10] ------------------ 26741| 11| uint8_t* d = dst_ptr; 26742| 11| const uint8_t* s = src_ptr; 26743| 11| size_t n = len; 26744| | 26745| | // TODO: unroll. 26746| | 26747| 171| while (n >= 1) { ------------------ | Branch (26747:10): [True: 160, False: 11] ------------------ 26748| 160| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 26749| 160| wuffs_base__color_u64__as__color_u32( 26750| 160| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 26751| 160| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26752| | 26753| 160| s += 1 * 8; 26754| 160| d += 1 * 3; 26755| 160| n -= 1; 26756| 160| } 26757| | 26758| 11| return len; 26759| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over: 26813| 18| size_t src_len) { 26814| 18| size_t dst_len3 = dst_len / 3; 26815| 18| size_t src_len8 = src_len / 8; 26816| 18| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26816:16): [True: 1, False: 17] ------------------ 26817| 18| uint8_t* d = dst_ptr; 26818| 18| const uint8_t* s = src_ptr; 26819| 18| size_t n = len; 26820| | 26821| | // TODO: unroll. 26822| | 26823| 194| while (n >= 1) { ------------------ | Branch (26823:10): [True: 176, False: 18] ------------------ 26824| | // Extract 16-bit color components. 26825| 176| uint32_t dr = 0x101 * ((uint32_t)d[2]); 26826| 176| uint32_t dg = 0x101 * ((uint32_t)d[1]); 26827| 176| uint32_t db = 0x101 * ((uint32_t)d[0]); 26828| 176| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26829| 176| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26830| 176| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26831| 176| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 26832| | 26833| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26834| 176| uint32_t ia = 0xFFFF - sa; 26835| | 26836| | // Composite src (premul) over dst (premul). 26837| 176| dr = sr + ((dr * ia) / 0xFFFF); 26838| 176| dg = sg + ((dg * ia) / 0xFFFF); 26839| 176| db = sb + ((db * ia) / 0xFFFF); 26840| | 26841| | // Convert from 16-bit color to 8-bit color. 26842| 176| d[0] = (uint8_t)(db >> 8); 26843| 176| d[1] = (uint8_t)(dg >> 8); 26844| 176| d[2] = (uint8_t)(dr >> 8); 26845| | 26846| 176| s += 1 * 8; 26847| 176| d += 1 * 3; 26848| 176| n -= 1; 26849| 176| } 26850| | 26851| 18| return len; 26852| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src: 28807| 52| size_t src_len) { 28808| 52| size_t dst_len4 = dst_len / 4; 28809| 52| size_t src_len8 = src_len / 8; 28810| 52| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28810:16): [True: 3, False: 49] ------------------ 28811| 52| uint8_t* d = dst_ptr; 28812| 52| const uint8_t* s = src_ptr; 28813| | 28814| 52| size_t n = len; 28815| 387| while (n >= 1) { ------------------ | Branch (28815:10): [True: 335, False: 52] ------------------ 28816| 335| wuffs_base__poke_u32le__no_bounds_check( 28817| 335| d + (0 * 4), 28818| 335| wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr( 28819| 335| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul( 28820| 335| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 28821| | 28822| 335| s += 1 * 8; 28823| 335| d += 1 * 4; 28824| 335| n -= 1; 28825| 335| } 28826| 52| return len; 28827| 52|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over: 28836| 32| size_t src_len) { 28837| 32| size_t dst_len4 = dst_len / 4; 28838| 32| size_t src_len8 = src_len / 8; 28839| 32| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28839:16): [True: 2, False: 30] ------------------ 28840| 32| uint8_t* d = dst_ptr; 28841| 32| const uint8_t* s = src_ptr; 28842| 32| size_t n = len; 28843| | 28844| 264| while (n >= 1) { ------------------ | Branch (28844:10): [True: 232, False: 32] ------------------ 28845| 232| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28846| 232| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28847| 232| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28848| 232| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28849| 232| wuffs_base__poke_u32le__no_bounds_check( 28850| 232| d + (0 * 4), 28851| 232| wuffs_base__color_u64__as__color_u32( 28852| 232| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0))); 28853| | 28854| 232| s += 1 * 8; 28855| 232| d += 1 * 4; 28856| 232| n -= 1; 28857| 232| } 28858| | 28859| 32| return len; 28860| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src: 28151| 19| size_t src_len) { 28152| 19| size_t dst_len4 = dst_len / 4; 28153| 19| size_t src_len8 = src_len / 8; 28154| 19| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28154:16): [True: 1, False: 18] ------------------ 28155| 19| uint8_t* d = dst_ptr; 28156| 19| const uint8_t* s = src_ptr; 28157| 19| size_t n = len; 28158| | 28159| | // TODO: unroll. 28160| | 28161| 208| while (n >= 1) { ------------------ | Branch (28161:10): [True: 189, False: 19] ------------------ 28162| 189| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28163| 189| wuffs_base__poke_u32le__no_bounds_check( 28164| 189| d + (0 * 4), wuffs_base__color_swap_u32_argb_abgr( 28165| 189| wuffs_base__color_u64__as__color_u32(s0))); 28166| | 28167| 189| s += 1 * 8; 28168| 189| d += 1 * 4; 28169| 189| n -= 1; 28170| 189| } 28171| | 28172| 19| return len; 28173| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src_over: 28182| 11| size_t src_len) { 28183| 11| size_t dst_len4 = dst_len / 4; 28184| 11| size_t src_len8 = src_len / 8; 28185| 11| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28185:16): [True: 4, False: 7] ------------------ 28186| 11| uint8_t* d = dst_ptr; 28187| 11| const uint8_t* s = src_ptr; 28188| 11| size_t n = len; 28189| | 28190| | // TODO: unroll. 28191| | 28192| 115| while (n >= 1) { ------------------ | Branch (28192:10): [True: 104, False: 11] ------------------ 28193| 104| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28194| 104| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28195| 104| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28196| 104| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28197| 104| wuffs_base__poke_u32le__no_bounds_check( 28198| 104| d + (0 * 4), 28199| 104| wuffs_base__color_u64__as__color_u32( 28200| 104| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0))); 28201| | 28202| 104| s += 1 * 8; 28203| 104| d += 1 * 4; 28204| 104| n -= 1; 28205| 104| } 28206| | 28207| 11| return len; 28208| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgrx: 31586| 141| wuffs_base__pixel_blend blend) { 31587| 141| switch (dst_pixfmt.repr) { ------------------ | Branch (31587:11): [True: 122, False: 19] ------------------ 31588| 23| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 23|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31588:5): [True: 23, False: 118] ------------------ 31589| 23| return wuffs_private_impl__swizzle_y__bgrx; 31590| | 31591| 14| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 14|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31591:5): [True: 14, False: 127] ------------------ 31592| 14| return wuffs_private_impl__swizzle_bgr_565__bgrx; 31593| | 31594| 8| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 8|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31594:5): [True: 8, False: 133] ------------------ 31595| 8| return wuffs_private_impl__swizzle_xxx__xxxx; 31596| | 31597| 8| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31597:5): [True: 8, False: 133] ------------------ 31598| 22| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31598:5): [True: 14, False: 127] ------------------ 31599| 22| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31599:5): [True: 0, False: 141] ------------------ 31600| 22| return wuffs_private_impl__swizzle_bgrw__bgrx; 31601| | 31602| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31602:5): [True: 13, False: 128] ------------------ 31603| 13| return wuffs_private_impl__swizzle_bgrw_4x16le__bgrx; 31604| | 31605| 3| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 3|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31605:5): [True: 3, False: 138] ------------------ 31606| 3| return wuffs_private_impl__swizzle_copy_4_4; 31607| | 31608| 13| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 13|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31608:5): [True: 13, False: 128] ------------------ 31609| 13| return wuffs_private_impl__swizzle_bgr__rgbx; 31610| | 31611| 23| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31611:5): [True: 23, False: 118] ------------------ 31612| 26| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31612:5): [True: 3, False: 138] ------------------ 31613| 26| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31613:5): [True: 0, False: 141] ------------------ 31614| 26| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31614:5): [True: 0, False: 141] ------------------ 31615| 26| return wuffs_private_impl__swizzle_bgrw__rgbx; 31616| 141| } 31617| 19| return NULL; 31618| 141|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgrx: 29970| 23| size_t src_len) { 29971| 23| size_t src_len4 = src_len / 4; 29972| 23| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (29972:16): [True: 1, False: 22] ------------------ 29973| 23| uint8_t* d = dst_ptr; 29974| 23| const uint8_t* s = src_ptr; 29975| 23| size_t n = len; 29976| | 29977| | // TODO: unroll. 29978| | 29979| 472| while (n >= 1) { ------------------ | Branch (29979:10): [True: 449, False: 23] ------------------ 29980| 449| uint32_t s0 = 29981| 449| 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 29982| 449| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 29983| | 29984| 449| s += 1 * 4; 29985| 449| d += 1 * 1; 29986| 449| n -= 1; 29987| 449| } 29988| | 29989| 23| return len; 29990| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgrx: 25321| 14| size_t src_len) { 25322| 14| size_t dst_len2 = dst_len / 2; 25323| 14| size_t src_len4 = src_len / 4; 25324| 14| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25324:16): [True: 2, False: 12] ------------------ 25325| 14| uint8_t* d = dst_ptr; 25326| 14| const uint8_t* s = src_ptr; 25327| 14| size_t n = len; 25328| | 25329| | // TODO: unroll. 25330| | 25331| 310| while (n >= 1) { ------------------ | Branch (25331:10): [True: 296, False: 14] ------------------ 25332| 296| uint32_t b5 = (uint32_t)(s[0] >> 3); 25333| 296| uint32_t g6 = (uint32_t)(s[1] >> 2); 25334| 296| uint32_t r5 = (uint32_t)(s[2] >> 3); 25335| 296| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 25336| 296| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 25337| | 25338| 296| s += 1 * 4; 25339| 296| d += 1 * 2; 25340| 296| n -= 1; 25341| 296| } 25342| | 25343| 14| return len; 25344| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__xxxx: 29060| 8| size_t src_len) { 29061| 8| size_t dst_len3 = dst_len / 3; 29062| 8| size_t src_len4 = src_len / 4; 29063| 8| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (29063:16): [True: 4, False: 4] ------------------ 29064| 8| uint8_t* d = dst_ptr; 29065| 8| const uint8_t* s = src_ptr; 29066| 8| size_t n = len; 29067| | 29068| | // TODO: unroll. 29069| | 29070| 106| while (n >= 1) { ------------------ | Branch (29070:10): [True: 98, False: 8] ------------------ 29071| 98| wuffs_base__poke_u24le__no_bounds_check( 29072| 98| d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 29073| | 29074| 98| s += 1 * 4; 29075| 98| d += 1 * 3; 29076| 98| n -= 1; 29077| 98| } 29078| | 29079| 8| return len; 29080| 8|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgrx: 28370| 22| size_t src_len) { 28371| 22| size_t dst_len4 = dst_len / 4; 28372| 22| size_t src_len4 = src_len / 4; 28373| 22| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28373:16): [True: 3, False: 19] ------------------ 28374| 22| uint8_t* d = dst_ptr; 28375| 22| const uint8_t* s = src_ptr; 28376| 22| size_t n = len; 28377| | 28378| | // TODO: unroll. 28379| | 28380| 286| while (n >= 1) { ------------------ | Branch (28380:10): [True: 264, False: 22] ------------------ 28381| 264| wuffs_base__poke_u32le__no_bounds_check( 28382| 264| d + (0 * 4), 28383| 264| 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28384| | 28385| 264| s += 1 * 4; 28386| 264| d += 1 * 4; 28387| 264| n -= 1; 28388| 264| } 28389| | 28390| 22| return len; 28391| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgrx: 28639| 13| size_t src_len) { 28640| 13| size_t dst_len8 = dst_len / 8; 28641| 13| size_t src_len4 = src_len / 4; 28642| 13| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28642:16): [True: 6, False: 7] ------------------ 28643| 13| uint8_t* d = dst_ptr; 28644| 13| const uint8_t* s = src_ptr; 28645| 13| size_t n = len; 28646| | 28647| 134| while (n >= 1) { ------------------ | Branch (28647:10): [True: 121, False: 13] ------------------ 28648| 121| uint8_t s0 = s[0]; 28649| 121| uint8_t s1 = s[1]; 28650| 121| uint8_t s2 = s[2]; 28651| 121| d[0] = s0; 28652| 121| d[1] = s0; 28653| 121| d[2] = s1; 28654| 121| d[3] = s1; 28655| 121| d[4] = s2; 28656| 121| d[5] = s2; 28657| 121| d[6] = 0xFF; 28658| 121| d[7] = 0xFF; 28659| | 28660| 121| s += 1 * 4; 28661| 121| d += 1 * 8; 28662| 121| n -= 1; 28663| 121| } 28664| | 28665| 13| return len; 28666| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgbx: 26860| 13| size_t src_len) { 26861| 13| size_t dst_len3 = dst_len / 3; 26862| 13| size_t src_len4 = src_len / 4; 26863| 13| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26863:16): [True: 2, False: 11] ------------------ 26864| 13| uint8_t* d = dst_ptr; 26865| 13| const uint8_t* s = src_ptr; 26866| 13| size_t n = len; 26867| | 26868| | // TODO: unroll. 26869| | 26870| 234| while (n >= 1) { ------------------ | Branch (26870:10): [True: 221, False: 13] ------------------ 26871| 221| uint8_t b0 = s[0]; 26872| 221| uint8_t b1 = s[1]; 26873| 221| uint8_t b2 = s[2]; 26874| 221| d[0] = b2; 26875| 221| d[1] = b1; 26876| 221| d[2] = b0; 26877| | 26878| 221| s += 1 * 4; 26879| 221| d += 1 * 3; 26880| 221| n -= 1; 26881| 221| } 26882| | 26883| 13| return len; 26884| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgbx: 28540| 26| size_t src_len) { 28541| 26| size_t dst_len4 = dst_len / 4; 28542| 26| size_t src_len4 = src_len / 4; 28543| 26| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28543:16): [True: 2, False: 24] ------------------ 28544| 26| uint8_t* d = dst_ptr; 28545| 26| const uint8_t* s = src_ptr; 28546| 26| size_t n = len; 28547| | 28548| | // TODO: unroll. 28549| | 28550| 545| while (n >= 1) { ------------------ | Branch (28550:10): [True: 519, False: 26] ------------------ 28551| 519| uint8_t b0 = s[0]; 28552| 519| uint8_t b1 = s[1]; 28553| 519| uint8_t b2 = s[2]; 28554| 519| d[0] = b2; 28555| 519| d[1] = b1; 28556| 519| d[2] = b0; 28557| 519| d[3] = 0xFF; 28558| | 28559| 519| s += 1 * 4; 28560| 519| d += 1 * 4; 28561| 519| n -= 1; 28562| 519| } 28563| | 28564| 26| return len; 28565| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgb: 31626| 115| wuffs_base__pixel_blend blend) { 31627| 115| switch (dst_pixfmt.repr) { ------------------ | Branch (31627:11): [True: 102, False: 13] ------------------ 31628| 13| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 13|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31628:5): [True: 13, False: 102] ------------------ 31629| 13| return wuffs_private_impl__swizzle_y__rgb; 31630| | 31631| 16| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31631:5): [True: 16, False: 99] ------------------ 31632| 16| return wuffs_private_impl__swizzle_bgr_565__rgb; 31633| | 31634| 10| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31634:5): [True: 10, False: 105] ------------------ 31635| 10| return wuffs_private_impl__swizzle_swap_rgb_bgr; 31636| | 31637| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31637:5): [True: 13, False: 102] ------------------ 31638| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31638:5): [True: 4, False: 111] ------------------ 31639| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31639:5): [True: 0, False: 115] ------------------ 31640| 20| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31640:5): [True: 3, False: 112] ------------------ 31641| 20|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31642| 20| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31642:11): [True: 20, False: 0] ------------------ 31643| 20| return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42; 31644| 20| } 31645| 0|#endif 31646| 0| return wuffs_private_impl__swizzle_bgrw__rgb; 31647| | 31648| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31648:5): [True: 18, False: 97] ------------------ 31649| 18| return wuffs_private_impl__swizzle_bgrw_4x16le__rgb; 31650| | 31651| 6| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 6|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31651:5): [True: 6, False: 109] ------------------ 31652| 6| return wuffs_private_impl__swizzle_copy_3_3; 31653| | 31654| 8| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 8|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31654:5): [True: 8, False: 107] ------------------ 31655| 19| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 19|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31655:5): [True: 11, False: 104] ------------------ 31656| 19| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 19|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31656:5): [True: 0, False: 115] ------------------ 31657| 19| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 19|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31657:5): [True: 0, False: 115] ------------------ 31658| 19|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31659| 19| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31659:11): [True: 19, False: 0] ------------------ 31660| 19| return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42; 31661| 19| } 31662| 0|#endif 31663| 0| return wuffs_private_impl__swizzle_bgrw__bgr; 31664| 115| } 31665| 13| return NULL; 31666| 115|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgb: 29998| 13| size_t src_len) { 29999| 13| size_t src_len3 = src_len / 3; 30000| 13| size_t len = (dst_len < src_len3) ? dst_len : src_len3; ------------------ | Branch (30000:16): [True: 4, False: 9] ------------------ 30001| 13| uint8_t* d = dst_ptr; 30002| 13| const uint8_t* s = src_ptr; 30003| 13| size_t n = len; 30004| | 30005| | // TODO: unroll. 30006| | 30007| 295| while (n >= 1) { ------------------ | Branch (30007:10): [True: 282, False: 13] ------------------ 30008| 282| uint32_t s0 = 30009| 282| 0xFF000000 | wuffs_base__peek_u24be__no_bounds_check(s + (0 * 3)); 30010| 282| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30011| | 30012| 282| s += 1 * 3; 30013| 282| d += 1 * 1; 30014| 282| n -= 1; 30015| 282| } 30016| | 30017| 13| return len; 30018| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgb: 25701| 16| size_t src_len) { 25702| 16| size_t dst_len2 = dst_len / 2; 25703| 16| size_t src_len3 = src_len / 3; 25704| 16| size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3; ------------------ | Branch (25704:16): [True: 2, False: 14] ------------------ 25705| 16| uint8_t* d = dst_ptr; 25706| 16| const uint8_t* s = src_ptr; 25707| 16| size_t n = len; 25708| | 25709| | // TODO: unroll. 25710| | 25711| 348| while (n >= 1) { ------------------ | Branch (25711:10): [True: 332, False: 16] ------------------ 25712| 332| uint32_t r5 = (uint32_t)(s[0] >> 3); 25713| 332| uint32_t g6 = (uint32_t)(s[1] >> 2); 25714| 332| uint32_t b5 = (uint32_t)(s[2] >> 3); 25715| 332| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 25716| 332| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 25717| | 25718| 332| s += 1 * 3; 25719| 332| d += 1 * 2; 25720| 332| n -= 1; 25721| 332| } 25722| | 25723| 16| return len; 25724| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__rgb: 28674| 18| size_t src_len) { 28675| 18| size_t dst_len8 = dst_len / 8; 28676| 18| size_t src_len3 = src_len / 3; 28677| 18| size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3; ------------------ | Branch (28677:16): [True: 8, False: 10] ------------------ 28678| 18| uint8_t* d = dst_ptr; 28679| 18| const uint8_t* s = src_ptr; 28680| 18| size_t n = len; 28681| | 28682| 205| while (n >= 1) { ------------------ | Branch (28682:10): [True: 187, False: 18] ------------------ 28683| 187| uint8_t s0 = s[0]; 28684| 187| uint8_t s1 = s[1]; 28685| 187| uint8_t s2 = s[2]; 28686| 187| d[0] = s2; 28687| 187| d[1] = s2; 28688| 187| d[2] = s1; 28689| 187| d[3] = s1; 28690| 187| d[4] = s0; 28691| 187| d[5] = s0; 28692| 187| d[6] = 0xFF; 28693| 187| d[7] = 0xFF; 28694| | 28695| 187| s += 1 * 3; 28696| 187| d += 1 * 8; 28697| 187| n -= 1; 28698| 187| } 28699| | 28700| 18| return len; 28701| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgba_nonpremul: 31674| 230| wuffs_base__pixel_blend blend) { 31675| 230| switch (dst_pixfmt.repr) { ------------------ | Branch (31675:11): [True: 211, False: 19] ------------------ 31676| 24| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 24|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31676:5): [True: 24, False: 206] ------------------ 31677| 24| switch (blend) { ------------------ | Branch (31677:15): [True: 24, False: 0] ------------------ 31678| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31678:9): [True: 13, False: 11] ------------------ 31679| 13| return wuffs_private_impl__swizzle_y__rgba_nonpremul__src; 31680| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31680:9): [True: 11, False: 13] ------------------ 31681| 11| return wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over; 31682| 24| } 31683| 0| return NULL; 31684| | 31685| 25| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31685:5): [True: 25, False: 205] ------------------ 31686| 25| switch (blend) { ------------------ | Branch (31686:15): [True: 25, False: 0] ------------------ 31687| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31687:9): [True: 10, False: 15] ------------------ 31688| 10| return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src; 31689| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31689:9): [True: 15, False: 10] ------------------ 31690| 15| return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over; 31691| 25| } 31692| 0| return NULL; 31693| | 31694| 10| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31694:5): [True: 10, False: 220] ------------------ 31695| 10| switch (blend) { ------------------ | Branch (31695:15): [True: 10, False: 0] ------------------ 31696| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31696:9): [True: 1, False: 9] ------------------ 31697| 1| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src; 31698| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31698:9): [True: 9, False: 1] ------------------ 31699| 9| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over; 31700| 10| } 31701| 0| return NULL; 31702| | 31703| 38| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 38|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31703:5): [True: 38, False: 192] ------------------ 31704| 38| switch (blend) { ------------------ | Branch (31704:15): [True: 38, False: 0] ------------------ 31705| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31705:9): [True: 11, False: 27] ------------------ 31706| 11|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31707| 11| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31707:15): [True: 11, False: 0] ------------------ 31708| 11| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 31709| 11| } 31710| 0|#endif 31711| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 31712| 27| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 27|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31712:9): [True: 27, False: 11] ------------------ 31713| 27| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over; 31714| 38| } 31715| 0| return NULL; 31716| | 31717| 37| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 37|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31717:5): [True: 37, False: 193] ------------------ 31718| 37| switch (blend) { ------------------ | Branch (31718:15): [True: 37, False: 0] ------------------ 31719| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31719:9): [True: 9, False: 28] ------------------ 31720| 9| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src; 31721| 28| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 28|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31721:9): [True: 28, False: 9] ------------------ 31722| 28| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over; 31723| 37| } 31724| 0| return NULL; 31725| | 31726| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31726:5): [True: 18, False: 212] ------------------ 31727| 18| switch (blend) { ------------------ | Branch (31727:15): [True: 18, False: 0] ------------------ 31728| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31728:9): [True: 10, False: 8] ------------------ 31729| 10| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src; 31730| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31730:9): [True: 8, False: 10] ------------------ 31731| 8| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over; 31732| 18| } 31733| 0| return NULL; 31734| | 31735| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4852| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31735:5): [True: 0, False: 230] ------------------ 31736| 3| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4853| 3|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31736:5): [True: 3, False: 227] ------------------ 31737| | // TODO. 31738| 3| break; 31739| | 31740| 16| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31740:5): [True: 16, False: 214] ------------------ 31741| 16| switch (blend) { ------------------ | Branch (31741:15): [True: 16, False: 0] ------------------ 31742| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31742:9): [True: 16, False: 0] ------------------ 31743| 16| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src; 31744| 0| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31744:9): [True: 0, False: 16] ------------------ 31745| 0| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over; 31746| 16| } 31747| 0| return NULL; 31748| | 31749| 11| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31749:5): [True: 11, False: 219] ------------------ 31750| 11| switch (blend) { ------------------ | Branch (31750:15): [True: 11, False: 0] ------------------ 31751| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31751:9): [True: 1, False: 10] ------------------ 31752| 1| return wuffs_private_impl__swizzle_copy_4_4; 31753| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31753:9): [True: 10, False: 1] ------------------ 31754| 10| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over; 31755| 11| } 31756| 0| return NULL; 31757| | 31758| 29| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 29|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31758:5): [True: 29, False: 201] ------------------ 31759| 29| switch (blend) { ------------------ | Branch (31759:15): [True: 29, False: 0] ------------------ 31760| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31760:9): [True: 16, False: 13] ------------------ 31761| 16| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src; 31762| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31762:9): [True: 13, False: 16] ------------------ 31763| 13| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over; 31764| 29| } 31765| 0| return NULL; 31766| | 31767| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4860| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31767:5): [True: 0, False: 230] ------------------ 31768| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4861| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31768:5): [True: 0, False: 230] ------------------ 31769| | // TODO. 31770| 0| break; 31771| 230| } 31772| 22| return NULL; 31773| 230|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src: 30026| 13| size_t src_len) { 30027| 13| size_t src_len4 = src_len / 4; 30028| 13| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30028:16): [True: 2, False: 11] ------------------ 30029| 13| uint8_t* d = dst_ptr; 30030| 13| const uint8_t* s = src_ptr; 30031| 13| size_t n = len; 30032| | 30033| | // TODO: unroll. 30034| | 30035| 257| while (n >= 1) { ------------------ | Branch (30035:10): [True: 244, False: 13] ------------------ 30036| 244| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30037| 244| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 30038| 244| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 30039| 244| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30040| | 30041| 244| s += 1 * 4; 30042| 244| d += 1 * 1; 30043| 244| n -= 1; 30044| 244| } 30045| | 30046| 13| return len; 30047| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over: 30056| 11| size_t src_len) { 30057| 11| size_t src_len4 = src_len / 4; 30058| 11| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30058:16): [True: 1, False: 10] ------------------ 30059| 11| uint8_t* d = dst_ptr; 30060| 11| const uint8_t* s = src_ptr; 30061| 11| size_t n = len; 30062| | 30063| | // TODO: unroll. 30064| | 30065| 175| while (n >= 1) { ------------------ | Branch (30065:10): [True: 164, False: 11] ------------------ 30066| 164| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30067| 164| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30068| 164| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30069| 164| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30070| 164| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 30071| | 30072| 164| s += 1 * 4; 30073| 164| d += 1 * 1; 30074| 164| n -= 1; 30075| 164| } 30076| | 30077| 11| return len; 30078| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src: 25733| 10| size_t src_len) { 25734| 10| size_t dst_len2 = dst_len / 2; 25735| 10| size_t src_len4 = src_len / 4; 25736| 10| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25736:16): [True: 1, False: 9] ------------------ 25737| 10| uint8_t* d = dst_ptr; 25738| 10| const uint8_t* s = src_ptr; 25739| 10| size_t n = len; 25740| | 25741| | // TODO: unroll. 25742| | 25743| 156| while (n >= 1) { ------------------ | Branch (25743:10): [True: 146, False: 10] ------------------ 25744| 146| wuffs_base__poke_u16le__no_bounds_check( 25745| 146| d + (0 * 2), 25746| 146| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 25747| 146| wuffs_base__color_swap_u32_argb_abgr( 25748| 146| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 25749| 146| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))))); 25750| | 25751| 146| s += 1 * 4; 25752| 146| d += 1 * 2; 25753| 146| n -= 1; 25754| 146| } 25755| | 25756| 10| return len; 25757| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over: 25766| 15| size_t src_len) { 25767| 15| size_t dst_len2 = dst_len / 2; 25768| 15| size_t src_len4 = src_len / 4; 25769| 15| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25769:16): [True: 4, False: 11] ------------------ 25770| 15| uint8_t* d = dst_ptr; 25771| 15| const uint8_t* s = src_ptr; 25772| 15| size_t n = len; 25773| | 25774| | // TODO: unroll. 25775| | 25776| 281| while (n >= 1) { ------------------ | Branch (25776:10): [True: 266, False: 15] ------------------ 25777| | // Extract 16-bit color components. 25778| 266| uint32_t sa = 0x101 * ((uint32_t)s[3]); 25779| 266| uint32_t sb = 0x101 * ((uint32_t)s[2]); 25780| 266| uint32_t sg = 0x101 * ((uint32_t)s[1]); 25781| 266| uint32_t sr = 0x101 * ((uint32_t)s[0]); 25782| | 25783| | // Convert from 565 color to 16-bit color. 25784| 266| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 25785| 266| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 25786| 266| uint32_t dr = (0x8421 * old_r5) >> 4; 25787| 266| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 25788| 266| uint32_t dg = (0x1041 * old_g6) >> 2; 25789| 266| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 25790| 266| uint32_t db = (0x8421 * old_b5) >> 4; 25791| | 25792| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25793| 266| uint32_t ia = 0xFFFF - sa; 25794| | 25795| | // Composite src (nonpremul) over dst (premul). 25796| 266| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25797| 266| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25798| 266| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25799| | 25800| | // Convert from 16-bit color to 565 color and combine the components. 25801| 266| uint32_t new_r5 = 0x1F & (dr >> 11); 25802| 266| uint32_t new_g6 = 0x3F & (dg >> 10); 25803| 266| uint32_t new_b5 = 0x1F & (db >> 11); 25804| 266| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 25805| 266| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 25806| | 25807| 266| s += 1 * 4; 25808| 266| d += 1 * 2; 25809| 266| n -= 1; 25810| 266| } 25811| | 25812| 15| return len; 25813| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src: 27541| 9| size_t src_len) { 27542| 9| size_t dst_len8 = dst_len / 8; 27543| 9| size_t src_len4 = src_len / 4; 27544| 9| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27544:16): [True: 3, False: 6] ------------------ 27545| 9| uint8_t* d = dst_ptr; 27546| 9| const uint8_t* s = src_ptr; 27547| | 27548| 9| size_t n = len; 27549| 65| while (n >= 1) { ------------------ | Branch (27549:10): [True: 56, False: 9] ------------------ 27550| 56| uint8_t s0 = s[0]; 27551| 56| uint8_t s1 = s[1]; 27552| 56| uint8_t s2 = s[2]; 27553| 56| uint8_t s3 = s[3]; 27554| 56| d[0] = s2; 27555| 56| d[1] = s2; 27556| 56| d[2] = s1; 27557| 56| d[3] = s1; 27558| 56| d[4] = s0; 27559| 56| d[5] = s0; 27560| 56| d[6] = s3; 27561| 56| d[7] = s3; 27562| | 27563| 56| s += 1 * 4; 27564| 56| d += 1 * 8; 27565| 56| n -= 1; 27566| 56| } 27567| 9| return len; 27568| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over: 27577| 28| size_t src_len) { 27578| 28| size_t dst_len8 = dst_len / 8; 27579| 28| size_t src_len4 = src_len / 4; 27580| 28| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27580:16): [True: 10, False: 18] ------------------ 27581| 28| uint8_t* d = dst_ptr; 27582| 28| const uint8_t* s = src_ptr; 27583| | 27584| 28| size_t n = len; 27585| 177| while (n >= 1) { ------------------ | Branch (27585:10): [True: 149, False: 28] ------------------ 27586| 149| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27587| 149| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 27588| 149| wuffs_base__color_swap_u32_argb_abgr( 27589| 149| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 27590| 149| wuffs_base__poke_u64le__no_bounds_check( 27591| 149| d + (0 * 8), 27592| 149| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 27593| | 27594| 149| s += 1 * 4; 27595| 149| d += 1 * 8; 27596| 149| n -= 1; 27597| 149| } 27598| 28| return len; 27599| 28|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgba_premul: 31781| 267| wuffs_base__pixel_blend blend) { 31782| 267| switch (dst_pixfmt.repr) { ------------------ | Branch (31782:11): [True: 244, False: 23] ------------------ 31783| 36| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4827| 36|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31783:5): [True: 36, False: 231] ------------------ 31784| 36| switch (blend) { ------------------ | Branch (31784:15): [True: 36, False: 0] ------------------ 31785| 17| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31785:9): [True: 17, False: 19] ------------------ 31786| 17| return wuffs_private_impl__swizzle_y__rgba_premul__src; 31787| 19| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31787:9): [True: 19, False: 17] ------------------ 31788| 19| return wuffs_private_impl__swizzle_y__rgba_premul__src_over; 31789| 36| } 31790| 0| return NULL; 31791| | 31792| 25| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4846| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31792:5): [True: 25, False: 242] ------------------ 31793| 25| switch (blend) { ------------------ | Branch (31793:15): [True: 25, False: 0] ------------------ 31794| 17| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31794:9): [True: 17, False: 8] ------------------ 31795| 17| return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src; 31796| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31796:9): [True: 8, False: 17] ------------------ 31797| 8| return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over; 31798| 25| } 31799| 0| return NULL; 31800| | 31801| 15| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4847| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31801:5): [True: 15, False: 252] ------------------ 31802| 15| switch (blend) { ------------------ | Branch (31802:15): [True: 15, False: 0] ------------------ 31803| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31803:9): [True: 8, False: 7] ------------------ 31804| 8| return wuffs_private_impl__swizzle_bgr__rgba_premul__src; 31805| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31805:9): [True: 7, False: 8] ------------------ 31806| 7| return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; 31807| 15| } 31808| 0| return NULL; 31809| | 31810| 23| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4848| 23|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31810:5): [True: 23, False: 244] ------------------ 31811| 23| switch (blend) { ------------------ | Branch (31811:15): [True: 23, False: 0] ------------------ 31812| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31812:9): [True: 13, False: 10] ------------------ 31813| 13| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src; 31814| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31814:9): [True: 10, False: 13] ------------------ 31815| 10| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; 31816| 23| } 31817| 0| return NULL; 31818| | 31819| 55| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4849| 55|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31819:5): [True: 55, False: 212] ------------------ 31820| 55| switch (blend) { ------------------ | Branch (31820:15): [True: 55, False: 0] ------------------ 31821| 26| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 26|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31821:9): [True: 26, False: 29] ------------------ 31822| 26| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src; 31823| 29| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 29|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31823:9): [True: 29, False: 26] ------------------ 31824| 29| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src_over; 31825| 55| } 31826| 0| return NULL; 31827| | 31828| 21| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4850| 21|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31828:5): [True: 21, False: 246] ------------------ 31829| 21| switch (blend) { ------------------ | Branch (31829:15): [True: 21, False: 0] ------------------ 31830| 6| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31830:9): [True: 6, False: 15] ------------------ 31831| 6|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31832| 6| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31832:15): [True: 6, False: 0] ------------------ 31833| 6| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 31834| 6| } 31835| 0|#endif 31836| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 31837| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31837:9): [True: 15, False: 6] ------------------ 31838| 15| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; 31839| 21| } 31840| 0| return NULL; 31841| | 31842| 14| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4855| 14|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31842:5): [True: 14, False: 253] ------------------ 31843| 14| switch (blend) { ------------------ | Branch (31843:15): [True: 14, False: 0] ------------------ 31844| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31844:9): [True: 11, False: 3] ------------------ 31845| 11| return wuffs_private_impl__swizzle_bgr__bgra_premul__src; 31846| 3| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31846:9): [True: 3, False: 11] ------------------ 31847| 3| return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; 31848| 14| } 31849| 0| return NULL; 31850| | 31851| 43| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4856| 43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31851:5): [True: 43, False: 224] ------------------ 31852| 43| switch (blend) { ------------------ | Branch (31852:15): [True: 43, False: 0] ------------------ 31853| 23| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 23|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31853:9): [True: 23, False: 20] ------------------ 31854| 23| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src; 31855| 20| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31855:9): [True: 20, False: 23] ------------------ 31856| 20| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; 31857| 43| } 31858| 0| return NULL; 31859| | 31860| 12| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4858| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31860:5): [True: 12, False: 255] ------------------ 31861| 12| switch (blend) { ------------------ | Branch (31861:15): [True: 12, False: 0] ------------------ 31862| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4744| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31862:9): [True: 3, False: 9] ------------------ 31863| 3| return wuffs_private_impl__swizzle_copy_4_4; 31864| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4745| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31864:9): [True: 9, False: 3] ------------------ 31865| 9| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; 31866| 12| } 31867| 0| return NULL; 31868| 267| } 31869| 23| return NULL; 31870| 267|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src: 30086| 17| size_t src_len) { 30087| 17| size_t src_len4 = src_len / 4; 30088| 17| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30088:16): [True: 1, False: 16] ------------------ 30089| 17| uint8_t* d = dst_ptr; 30090| 17| const uint8_t* s = src_ptr; 30091| 17| size_t n = len; 30092| | 30093| | // TODO: unroll. 30094| | 30095| 400| while (n >= 1) { ------------------ | Branch (30095:10): [True: 383, False: 17] ------------------ 30096| 383| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30097| 383| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30098| 383| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30099| | 30100| 383| s += 1 * 4; 30101| 383| d += 1 * 1; 30102| 383| n -= 1; 30103| 383| } 30104| | 30105| 17| return len; 30106| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src_over: 30114| 19| size_t src_len) { 30115| 19| size_t src_len4 = src_len / 4; 30116| 19| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30116:16): [True: 2, False: 17] ------------------ 30117| 19| uint8_t* d = dst_ptr; 30118| 19| const uint8_t* s = src_ptr; 30119| 19| size_t n = len; 30120| | 30121| | // TODO: unroll. 30122| | 30123| 425| while (n >= 1) { ------------------ | Branch (30123:10): [True: 406, False: 19] ------------------ 30124| 406| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30125| 406| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30126| 406| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30127| 406| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30128| 406| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 30129| | 30130| 406| s += 1 * 4; 30131| 406| d += 1 * 1; 30132| 406| n -= 1; 30133| 406| } 30134| | 30135| 19| return len; 30136| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src: 25821| 17| size_t src_len) { 25822| 17| size_t dst_len2 = dst_len / 2; 25823| 17| size_t src_len4 = src_len / 4; 25824| 17| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25824:16): [True: 5, False: 12] ------------------ 25825| 17| uint8_t* d = dst_ptr; 25826| 17| const uint8_t* s = src_ptr; 25827| 17| size_t n = len; 25828| | 25829| | // TODO: unroll. 25830| | 25831| 305| while (n >= 1) { ------------------ | Branch (25831:10): [True: 288, False: 17] ------------------ 25832| 288| wuffs_base__poke_u16le__no_bounds_check( 25833| 288| d + (0 * 2), 25834| 288| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 25835| 288| wuffs_base__color_swap_u32_argb_abgr( 25836| 288| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 25837| | 25838| 288| s += 1 * 4; 25839| 288| d += 1 * 2; 25840| 288| n -= 1; 25841| 288| } 25842| | 25843| 17| return len; 25844| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over: 25853| 8| size_t src_len) { 25854| 8| size_t dst_len2 = dst_len / 2; 25855| 8| size_t src_len4 = src_len / 4; 25856| 8| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (25856:16): [True: 1, False: 7] ------------------ 25857| 8| uint8_t* d = dst_ptr; 25858| 8| const uint8_t* s = src_ptr; 25859| 8| size_t n = len; 25860| | 25861| | // TODO: unroll. 25862| | 25863| 103| while (n >= 1) { ------------------ | Branch (25863:10): [True: 95, False: 8] ------------------ 25864| | // Extract 16-bit color components. 25865| 95| uint32_t sa = 0x101 * ((uint32_t)s[3]); 25866| 95| uint32_t sb = 0x101 * ((uint32_t)s[2]); 25867| 95| uint32_t sg = 0x101 * ((uint32_t)s[1]); 25868| 95| uint32_t sr = 0x101 * ((uint32_t)s[0]); 25869| | 25870| | // Convert from 565 color to 16-bit color. 25871| 95| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 25872| 95| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 25873| 95| uint32_t dr = (0x8421 * old_r5) >> 4; 25874| 95| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 25875| 95| uint32_t dg = (0x1041 * old_g6) >> 2; 25876| 95| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 25877| 95| uint32_t db = (0x8421 * old_b5) >> 4; 25878| | 25879| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25880| 95| uint32_t ia = 0xFFFF - sa; 25881| | 25882| | // Composite src (premul) over dst (premul). 25883| 95| dr = sr + ((dr * ia) / 0xFFFF); 25884| 95| dg = sg + ((dg * ia) / 0xFFFF); 25885| 95| db = sb + ((db * ia) / 0xFFFF); 25886| | 25887| | // Convert from 16-bit color to 565 color and combine the components. 25888| 95| uint32_t new_r5 = 0x1F & (dr >> 11); 25889| 95| uint32_t new_g6 = 0x3F & (dg >> 10); 25890| 95| uint32_t new_b5 = 0x1F & (db >> 11); 25891| 95| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 25892| 95| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 25893| | 25894| 95| s += 1 * 4; 25895| 95| d += 1 * 2; 25896| 95| n -= 1; 25897| 95| } 25898| | 25899| 8| return len; 25900| 8|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src: 27608| 26| size_t src_len) { 27609| 26| size_t dst_len8 = dst_len / 8; 27610| 26| size_t src_len4 = src_len / 4; 27611| 26| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27611:16): [True: 10, False: 16] ------------------ 27612| 26| uint8_t* d = dst_ptr; 27613| 26| const uint8_t* s = src_ptr; 27614| | 27615| 26| size_t n = len; 27616| 214| while (n >= 1) { ------------------ | Branch (27616:10): [True: 188, False: 26] ------------------ 27617| 188| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 27618| 188| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 27619| 188| wuffs_base__color_swap_u32_argb_abgr( 27620| 188| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 27621| 188| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 27622| | 27623| 188| s += 1 * 4; 27624| 188| d += 1 * 8; 27625| 188| n -= 1; 27626| 188| } 27627| 26| return len; 27628| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src_over: 27637| 29| size_t src_len) { 27638| 29| size_t dst_len8 = dst_len / 8; 27639| 29| size_t src_len4 = src_len / 4; 27640| 29| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (27640:16): [True: 12, False: 17] ------------------ 27641| 29| uint8_t* d = dst_ptr; 27642| 29| const uint8_t* s = src_ptr; 27643| | 27644| 29| size_t n = len; 27645| 290| while (n >= 1) { ------------------ | Branch (27645:10): [True: 261, False: 29] ------------------ 27646| 261| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 27647| 261| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 27648| 261| wuffs_base__color_swap_u32_argb_abgr( 27649| 261| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 27650| 261| wuffs_base__poke_u64le__no_bounds_check( 27651| 261| d + (0 * 8), 27652| 261| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 27653| | 27654| 261| s += 1 * 4; 27655| 261| d += 1 * 8; 27656| 261| n -= 1; 27657| 261| } 27658| 29| return len; 27659| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__max_of_4: 32187| 7.33k| uint32_t d) { 32188| 7.33k| return wuffs_base__u32__max( // 32189| 7.33k| wuffs_base__u32__max(a, b), // 32190| 7.33k| wuffs_base__u32__max(c, d)); 32191| 7.33k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__width: 5197| 2.40k|wuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) { 5198| 2.40k| return c ? c->private_impl.width : 0; ------------------ | Branch (5198:10): [True: 2.40k, False: 0] ------------------ 5199| 2.40k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__min_of_5: 32198| 4.80k| uint32_t e) { 32199| 4.80k| return wuffs_base__u32__min( // 32200| 4.80k| wuffs_base__u32__min( // 32201| 4.80k| wuffs_base__u32__min(a, b), // 32202| 4.80k| wuffs_base__u32__min(c, d)), // 32203| 4.80k| e); 32204| 4.80k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__height: 5202| 2.40k|wuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) { 5203| 2.40k| return c ? c->private_impl.height : 0; ------------------ | Branch (5203:10): [True: 2.40k, False: 0] ------------------ 5204| 2.40k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_flattened_length: 33314| 7.66k| uint32_t inv_v) { 33315| 7.66k| uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1u)) / inv_h; 33316| 7.66k| uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1u)) / inv_v; 33317| 7.66k| if (scaled_height <= 0u) { ------------------ | Branch (33317:7): [True: 0, False: 7.66k] ------------------ 33318| 0| return 0u; 33319| 0| } 33320| 7.66k| return ((scaled_height - 1u) * stride) + scaled_width; 33321| 7.66k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgb__convert_3_general: 32290| 10.0k| const uint8_t* up2) { 32291| 289k| for (; x < x_end; x++) { ------------------ | Branch (32291:10): [True: 279k, False: 10.0k] ------------------ 32292| 279k| uint32_t color = 0xFF000000u | // 32293| 279k| (((uint32_t)(*up0++)) << 16u) | // 32294| 279k| (((uint32_t)(*up1++)) << 8u) | // 32295| 279k| (((uint32_t)(*up2++)) << 0u); 32296| 279k| wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color); 32297| 279k| } 32298| 10.0k|} pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_avx2: 289| 1.04k|wuffs_base__cpu_arch__have_x86_avx2(void) { 290| |#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) && \ 291| | defined(__AVX2__) 292| | return true; 293| |#else 294| 1.04k|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) 295| | // GCC defines these macros but MSVC does not. 296| | // - bit_AVX2 = (1 << 5) 297| 1.04k| const unsigned int avx2_ebx7 = 0x00000020; 298| | // GCC defines these macros but MSVC does not. 299| | // - bit_PCLMUL = (1 << 1) 300| | // - bit_POPCNT = (1 << 23) 301| | // - bit_SSE4_2 = (1 << 20) 302| 1.04k| const unsigned int avx2_ecx1 = 0x00900002; 303| | 304| | // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). 305| 1.04k|#if defined(__GNUC__) 306| 1.04k| unsigned int eax7 = 0; 307| 1.04k| unsigned int ebx7 = 0; 308| 1.04k| unsigned int ecx7 = 0; 309| 1.04k| unsigned int edx7 = 0; 310| 1.04k| if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) && ------------------ | Branch (310:7): [True: 1.04k, False: 0] ------------------ 311| 1.04k| ((ebx7 & avx2_ebx7) == avx2_ebx7)) { ------------------ | Branch (311:7): [True: 1.04k, False: 0] ------------------ 312| 1.04k| unsigned int eax1 = 0; 313| 1.04k| unsigned int ebx1 = 0; 314| 1.04k| unsigned int ecx1 = 0; 315| 1.04k| unsigned int edx1 = 0; 316| 1.04k| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && ------------------ | Branch (316:9): [True: 1.04k, False: 0] ------------------ 317| 1.04k| ((ecx1 & avx2_ecx1) == avx2_ecx1)) { ------------------ | Branch (317:9): [True: 1.04k, False: 0] ------------------ 318| 1.04k| return true; 319| 1.04k| } 320| 1.04k| } 321| |#elif defined(_MSC_VER) // defined(__GNUC__) 322| | int x7[4]; 323| | __cpuidex(x7, 7, 0); 324| | if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) { 325| | int x1[4]; 326| | __cpuid(x1, 1); 327| | if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) { 328| | return true; 329| | } 330| | } 331| |#else 332| |#error "WUFFS_PRIVATE_IMPL__CPU_ARCH__ETC combined with an unsupported compiler" 333| |#endif // defined(__GNUC__); defined(_MSC_VER) 334| 0|#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) 335| 0| return false; 336| 1.04k|#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) && 337| | // defined(__AVX2__) 338| 1.04k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__convert_3_bgrx: 32324| 4.74k| const uint8_t* up2) { 32325| 4.74k| size_t dst_stride = dst->private_impl.planes[0].stride; 32326| 4.74k| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 32327| 4.74k| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 32328| | 32329| 72.2k| for (; x < x_end; x++) { ------------------ | Branch (32329:10): [True: 67.4k, False: 4.74k] ------------------ 32330| 67.4k| uint32_t color = // 32331| 67.4k| wuffs_base__color_ycc__as__color_u32( // 32332| 67.4k| *up0++, *up1++, *up2++); 32333| 67.4k| wuffs_base__poke_u32le__no_bounds_check(dst_iter, color); 32334| 67.4k| dst_iter += 4u; 32335| 67.4k| } 32336| 4.74k|} pixel_swizzler_fuzzer.c:wuffs_base__color_ycc__as__color_u32: 4640| 314k|wuffs_base__color_ycc__as__color_u32(uint8_t yy, uint8_t cb, uint8_t cr) { 4641| | // Work in 16.16 fixed point arithmetic (so that 'one half' is (1 << 15)) and 4642| | // bias the chroma values by 0x80. 4643| 314k| uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15); 4644| 314k| uint32_t cb32 = (((uint32_t)cb) - 0x80); 4645| 314k| uint32_t cr32 = (((uint32_t)cr) - 0x80); 4646| | 4647| | // The formulae: 4648| | // 4649| | // R = Y + 1.40200 * Cr 4650| | // G = Y - 0.34414 * Cb - 0.71414 * Cr 4651| | // B = Y + 1.77200 * Cb 4652| | // 4653| | // When scaled by 1<<16: 4654| | // 4655| | // 0.34414 becomes 0x0581A = 22554. 4656| | // 0.71414 becomes 0x0B6D2 = 46802. 4657| | // 1.40200 becomes 0x166E9 = 91881. 4658| | // 1.77200 becomes 0x1C5A2 = 116130. 4659| | // 4660| | // Since we're working in 16.16 fixed point arithmetic, masking by 0x00FF0000 4661| | // (possibly followed by a shift) gives the relevant 8 bits per channel. 4662| | // 4663| | // However, we need to saturate for overflow (above 0x00FFFFFF, but not so 4664| | // high that the MSB Most Significant Bit is set) or for underflow (below 4665| | // 0x00000000 as int32_t, which means that the MSB is set as uint32_t). In 4666| | // both cases, some of the high 8 bits (bits 24 ..= 31) will be set. 4667| | // 4668| | // "((uint32_t)(((int32_t)x) >> 31))" just replicates x's MSB across all 32 4669| | // bits. Prepending that with "~" inverts those bits. Thus, "~(etc)" is 4670| | // either 0xFFFFFFFF (for overflow) or 0x00000000 (for underflow). 4671| 314k| uint32_t rr32 = yy32 + (0x166E9 * cr32); 4672| 314k| uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32); 4673| 314k| uint32_t bb32 = yy32 + (0x1C5A2 * cb32); 4674| 314k| if (rr32 >> 24) { ------------------ | Branch (4674:7): [True: 108k, False: 205k] ------------------ 4675| 108k| rr32 = ~((uint32_t)(((int32_t)rr32) >> 31)); 4676| 108k| } 4677| 314k| if (gg32 >> 24) { ------------------ | Branch (4677:7): [True: 58.1k, False: 256k] ------------------ 4678| 58.1k| gg32 = ~((uint32_t)(((int32_t)gg32) >> 31)); 4679| 58.1k| } 4680| 314k| if (bb32 >> 24) { ------------------ | Branch (4680:7): [True: 140k, False: 174k] ------------------ 4681| 140k| bb32 = ~((uint32_t)(((int32_t)bb32) >> 31)); 4682| 140k| } 4683| 314k| return 0xFF000000 | // 4684| 314k| ((0x00FF0000 & rr32) >> 0) | // 4685| 314k| ((0x00FF0000 & gg32) >> 8) | // 4686| 314k| ((0x00FF0000 & bb32) >> 16); 4687| 314k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__convert_3_rgbx: 32345| 4.29k| const uint8_t* up2) { 32346| 4.29k| size_t dst_stride = dst->private_impl.planes[0].stride; 32347| 4.29k| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 32348| 4.29k| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 32349| | 32350| 61.0k| for (; x < x_end; x++) { ------------------ | Branch (32350:10): [True: 56.7k, False: 4.29k] ------------------ 32351| 56.7k| uint32_t color = // 32352| 56.7k| wuffs_base__color_ycc__as__color_u32_abgr( // 32353| 56.7k| *up0++, *up1++, *up2++); 32354| 56.7k| wuffs_base__poke_u32le__no_bounds_check(dst_iter, color); 32355| 56.7k| dst_iter += 4u; 32356| 56.7k| } 32357| 4.29k|} pixel_swizzler_fuzzer.c:wuffs_base__color_ycc__as__color_u32_abgr: 4693| 56.7k|wuffs_base__color_ycc__as__color_u32_abgr(uint8_t yy, uint8_t cb, uint8_t cr) { 4694| 56.7k| uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15); 4695| 56.7k| uint32_t cb32 = (((uint32_t)cb) - 0x80); 4696| 56.7k| uint32_t cr32 = (((uint32_t)cr) - 0x80); 4697| 56.7k| uint32_t rr32 = yy32 + (0x166E9 * cr32); 4698| 56.7k| uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32); 4699| 56.7k| uint32_t bb32 = yy32 + (0x1C5A2 * cb32); 4700| 56.7k| if (rr32 >> 24) { ------------------ | Branch (4700:7): [True: 22.6k, False: 34.1k] ------------------ 4701| 22.6k| rr32 = ~((uint32_t)(((int32_t)rr32) >> 31)); 4702| 22.6k| } 4703| 56.7k| if (gg32 >> 24) { ------------------ | Branch (4703:7): [True: 14.0k, False: 42.7k] ------------------ 4704| 14.0k| gg32 = ~((uint32_t)(((int32_t)gg32) >> 31)); 4705| 14.0k| } 4706| 56.7k| if (bb32 >> 24) { ------------------ | Branch (4706:7): [True: 33.8k, False: 22.9k] ------------------ 4707| 33.8k| bb32 = ~((uint32_t)(((int32_t)bb32) >> 31)); 4708| 33.8k| } 4709| 56.7k| return 0xFF000000 | // 4710| 56.7k| ((0x00FF0000 & bb32) >> 0) | // 4711| 56.7k| ((0x00FF0000 & gg32) >> 8) | // 4712| 56.7k| ((0x00FF0000 & rr32) >> 16); 4713| 56.7k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__convert_3_general: 32308| 11.3k| const uint8_t* up2) { 32309| 258k| for (; x < x_end; x++) { ------------------ | Branch (32309:10): [True: 247k, False: 11.3k] ------------------ 32310| 247k| uint32_t color = // 32311| 247k| wuffs_base__color_ycc__as__color_u32( // 32312| 247k| *up0++, *up1++, *up2++); 32313| 247k| wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color); 32314| 247k| } 32315| 11.3k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__box_filter: 33155| 1.37k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 33156| 1.37k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = 33157| 1.37k| (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; 33158| 1.37k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = 33159| 1.37k| (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u]; 33160| 1.37k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 = 33161| 1.37k| (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; 33162| | 33163| 1.37k| uint32_t y; 33164| 24.3k| for (y = y_min_incl; y < y_max_excl; y++) { ------------------ | Branch (33164:24): [True: 22.9k, False: 1.37k] ------------------ 33165| 22.9k| const uint8_t* src0_major = 33166| 22.9k| src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0); 33167| 22.9k| const uint8_t* src1_major = 33168| 22.9k| src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1); 33169| 22.9k| const uint8_t* src2_major = 33170| 22.9k| src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2); 33171| | 33172| 22.9k| uint32_t x = x_min_incl; 33173| 45.9k| while (x < x_max_excl) { ------------------ | Branch (33173:12): [True: 22.9k, False: 22.9k] ------------------ 33174| 22.9k| uint32_t end = x + 672u; 33175| 22.9k| if (end > x_max_excl) { ------------------ | Branch (33175:11): [True: 22.9k, False: 0] ------------------ 33176| 22.9k| end = x_max_excl; 33177| 22.9k| } 33178| | 33179| 22.9k| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 33180| 22.9k| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 33181| 22.9k| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 33182| | 33183| 22.9k| const uint8_t* up0 = (*upfunc0)( // 33184| 22.9k| scratch_buffer_2k_ptr + (0u * 672u), // 33185| 22.9k| src0_major + ((x - x_min_incl) / inv_h0), // 33186| 22.9k| src0_major + ((x - x_min_incl) / inv_h0), // 33187| 22.9k| src_len0, // 33188| 22.9k| 0u, false, false); 33189| | 33190| 22.9k| const uint8_t* up1 = (*upfunc1)( // 33191| 22.9k| scratch_buffer_2k_ptr + (1u * 672u), // 33192| 22.9k| src1_major + ((x - x_min_incl) / inv_h1), // 33193| 22.9k| src1_major + ((x - x_min_incl) / inv_h1), // 33194| 22.9k| src_len1, // 33195| 22.9k| 0u, false, false); 33196| | 33197| 22.9k| const uint8_t* up2 = (*upfunc2)( // 33198| 22.9k| scratch_buffer_2k_ptr + (2u * 672u), // 33199| 22.9k| src2_major + ((x - x_min_incl) / inv_h2), // 33200| 22.9k| src2_major + ((x - x_min_incl) / inv_h2), // 33201| 22.9k| src_len2, // 33202| 22.9k| 0u, false, false); 33203| | 33204| 22.9k| (*conv3func)(dst, x, end, y, up0, up1, up2); 33205| 22.9k| x = end; 33206| 22.9k| } 33207| 22.9k| } 33208| 1.37k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box: 32402| 53.6k| bool last_column_ignored) { 32403| 53.6k| return src_ptr_major; 32404| 53.6k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box: 32414| 5.23k| bool last_column_ignored) { 32415| 5.23k| uint8_t* dp = dst_ptr; 32416| 5.23k| const uint8_t* sp = src_ptr_major; 32417| 59.4k| while (src_len--) { ------------------ | Branch (32417:10): [True: 54.2k, False: 5.23k] ------------------ 32418| 54.2k| uint8_t sv = *sp++; 32419| 54.2k| *dp++ = sv; 32420| 54.2k| *dp++ = sv; 32421| 54.2k| } 32422| 5.23k| return dst_ptr; 32423| 5.23k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box: 32433| 12.5k| bool last_column_ignored) { 32434| 12.5k| uint8_t* dp = dst_ptr; 32435| 12.5k| const uint8_t* sp = src_ptr_major; 32436| 117k| while (src_len--) { ------------------ | Branch (32436:10): [True: 104k, False: 12.5k] ------------------ 32437| 104k| uint8_t sv = *sp++; 32438| 104k| *dp++ = sv; 32439| 104k| *dp++ = sv; 32440| 104k| *dp++ = sv; 32441| 104k| } 32442| 12.5k| return dst_ptr; 32443| 12.5k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box: 32453| 9.54k| bool last_column_ignored) { 32454| 9.54k| uint8_t* dp = dst_ptr; 32455| 9.54k| const uint8_t* sp = src_ptr_major; 32456| 80.4k| while (src_len--) { ------------------ | Branch (32456:10): [True: 70.9k, False: 9.54k] ------------------ 32457| 70.9k| uint8_t sv = *sp++; 32458| 70.9k| *dp++ = sv; 32459| 70.9k| *dp++ = sv; 32460| 70.9k| *dp++ = sv; 32461| 70.9k| *dp++ = sv; 32462| 70.9k| } 32463| 9.54k| return dst_ptr; 32464| 9.54k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_has_triangle_upsampler: 32638| 2.86k| uint32_t inv_v) { 32639| 2.86k| if (inv_h == 1u) { ------------------ | Branch (32639:7): [True: 1.34k, False: 1.52k] ------------------ 32640| 1.34k| return inv_v == 2u; 32641| 1.52k| } else if (inv_h == 2u) { ------------------ | Branch (32641:14): [True: 284, False: 1.23k] ------------------ 32642| 284| return (inv_v == 1u) || (inv_v == 2u); ------------------ | Branch (32642:12): [True: 152, False: 132] | Branch (32642:29): [True: 77, False: 55] ------------------ 32643| 284| } 32644| 1.23k| return false; 32645| 2.86k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter: 33018| 409| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 33019| 409| if ((x_min_incl != 0) || (y_min_incl != 0)) { ------------------ | Branch (33019:7): [True: 0, False: 409] | Branch (33019:28): [True: 0, False: 409] ------------------ 33020| 0| return; 33021| 0| } 33022| | 33023| 409| wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = 33024| 409| (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; 33025| 409| wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = 33026| 409| (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u]; 33027| 409| wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 = 33028| 409| (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; 33029| | 33030| | // First row. 33031| 409| uint32_t h1v2_bias = 1u; 33032| 409| wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( 33033| 409| dst, x_max_excl, 0u, // 33034| 409| src_ptr0, src_ptr1, src_ptr2, // 33035| 409| stride0, stride1, stride2, // 33036| 409| inv_h0, inv_h1, inv_h2, // 33037| 409| inv_v0, inv_v1, inv_v2, // 33038| 409| half_width_for_2to1, // 33039| 409| h1v2_bias, // 33040| 409| scratch_buffer_2k_ptr, // 33041| 409| upfunc0, upfunc1, upfunc2, conv3func); 33042| 409| h1v2_bias = 2u; 33043| | 33044| | // Middle rows. 33045| 409| bool last_row = y_max_excl == 2u * half_height_for_2to1; 33046| 409| uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl; ------------------ | Branch (33046:32): [True: 266, False: 143] ------------------ 33047| 409| uint32_t y; 33048| 8.71k| for (y = 1u; y < middle_y_max_excl; y++) { ------------------ | Branch (33048:16): [True: 8.31k, False: 409] ------------------ 33049| 8.31k| const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); 33050| 8.31k| const uint8_t* src0_minor = 33051| 8.31k| (inv_v0 != 2u) ------------------ | Branch (33051:9): [True: 5.23k, False: 3.07k] ------------------ 33052| 8.31k| ? src0_major 33053| 8.31k| : ((y & 1u) ? (src0_major + stride0) : (src0_major - stride0)); ------------------ | Branch (33053:16): [True: 1.53k, False: 1.53k] ------------------ 33054| 8.31k| const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); 33055| 8.31k| const uint8_t* src1_minor = 33056| 8.31k| (inv_v1 != 2u) ------------------ | Branch (33056:9): [True: 3.43k, False: 4.87k] ------------------ 33057| 8.31k| ? src1_major 33058| 8.31k| : ((y & 1u) ? (src1_major + stride1) : (src1_major - stride1)); ------------------ | Branch (33058:16): [True: 2.43k, False: 2.43k] ------------------ 33059| 8.31k| const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); 33060| 8.31k| const uint8_t* src2_minor = 33061| 8.31k| (inv_v2 != 2u) ------------------ | Branch (33061:9): [True: 6.36k, False: 1.94k] ------------------ 33062| 8.31k| ? src2_major 33063| 8.31k| : ((y & 1u) ? (src2_major + stride2) : (src2_major - stride2)); ------------------ | Branch (33063:16): [True: 973, False: 973] ------------------ 33064| 8.31k| uint32_t total_src_len0 = 0u; 33065| 8.31k| uint32_t total_src_len1 = 0u; 33066| 8.31k| uint32_t total_src_len2 = 0u; 33067| | 33068| 8.31k| uint32_t x = 0u; 33069| 16.6k| while (x < x_max_excl) { ------------------ | Branch (33069:12): [True: 8.31k, False: 8.31k] ------------------ 33070| 8.31k| bool first_column = x == 0u; 33071| 8.31k| uint32_t end = x + 672u; 33072| 8.31k| if (end > x_max_excl) { ------------------ | Branch (33072:11): [True: 8.31k, False: 0] ------------------ 33073| 8.31k| end = x_max_excl; 33074| 8.31k| } 33075| | 33076| 8.31k| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 33077| 8.31k| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 33078| 8.31k| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 33079| 8.31k| total_src_len0 += src_len0; 33080| 8.31k| total_src_len1 += src_len1; 33081| 8.31k| total_src_len2 += src_len2; 33082| | 33083| 8.31k| const uint8_t* up0 = (*upfunc0)( // 33084| 8.31k| scratch_buffer_2k_ptr + (0u * 672u), // 33085| 8.31k| src0_major + (x / inv_h0), // 33086| 8.31k| src0_minor + (x / inv_h0), // 33087| 8.31k| src_len0, // 33088| 8.31k| h1v2_bias, // 33089| 8.31k| first_column, // 33090| 8.31k| (total_src_len0 >= half_width_for_2to1)); 33091| | 33092| 8.31k| const uint8_t* up1 = (*upfunc1)( // 33093| 8.31k| scratch_buffer_2k_ptr + (1u * 672u), // 33094| 8.31k| src1_major + (x / inv_h1), // 33095| 8.31k| src1_minor + (x / inv_h1), // 33096| 8.31k| src_len1, // 33097| 8.31k| h1v2_bias, // 33098| 8.31k| first_column, // 33099| 8.31k| (total_src_len1 >= half_width_for_2to1)); 33100| | 33101| 8.31k| const uint8_t* up2 = (*upfunc2)( // 33102| 8.31k| scratch_buffer_2k_ptr + (2u * 672u), // 33103| 8.31k| src2_major + (x / inv_h2), // 33104| 8.31k| src2_minor + (x / inv_h2), // 33105| 8.31k| src_len2, // 33106| 8.31k| h1v2_bias, // 33107| 8.31k| first_column, // 33108| 8.31k| (total_src_len2 >= half_width_for_2to1)); 33109| | 33110| 8.31k| (*conv3func)(dst, x, end, y, up0, up1, up2); 33111| 8.31k| x = end; 33112| 8.31k| } 33113| | 33114| 8.31k| h1v2_bias ^= 3u; 33115| 8.31k| } 33116| | 33117| | // Last row. 33118| 409| if (middle_y_max_excl != y_max_excl) { ------------------ | Branch (33118:7): [True: 266, False: 143] ------------------ 33119| 266| wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( 33120| 266| dst, x_max_excl, middle_y_max_excl, // 33121| 266| src_ptr0, src_ptr1, src_ptr2, // 33122| 266| stride0, stride1, stride2, // 33123| 266| inv_h0, inv_h1, inv_h2, // 33124| 266| inv_v0, inv_v1, inv_v2, // 33125| 266| half_width_for_2to1, // 33126| 266| h1v2_bias, // 33127| 266| scratch_buffer_2k_ptr, // 33128| 266| upfunc0, upfunc1, upfunc2, conv3func); 33129| 266| } 33130| 409|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row: 32937| 675| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 32938| 675| const uint8_t* src0 = src_ptr0 + ((y / inv_v0) * (size_t)stride0); 32939| 675| const uint8_t* src1 = src_ptr1 + ((y / inv_v1) * (size_t)stride1); 32940| 675| const uint8_t* src2 = src_ptr2 + ((y / inv_v2) * (size_t)stride2); 32941| 675| uint32_t total_src_len0 = 0u; 32942| 675| uint32_t total_src_len1 = 0u; 32943| 675| uint32_t total_src_len2 = 0u; 32944| | 32945| 675| uint32_t x = 0u; 32946| 1.35k| while (x < width) { ------------------ | Branch (32946:10): [True: 675, False: 675] ------------------ 32947| 675| bool first_column = x == 0u; 32948| 675| uint32_t end = x + 672u; 32949| 675| if (end > width) { ------------------ | Branch (32949:9): [True: 675, False: 0] ------------------ 32950| 675| end = width; 32951| 675| } 32952| | 32953| 675| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 32954| 675| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 32955| 675| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 32956| 675| total_src_len0 += src_len0; 32957| 675| total_src_len1 += src_len1; 32958| 675| total_src_len2 += src_len2; 32959| | 32960| 675| const uint8_t* src_ptr_x0 = src0 + (x / inv_h0); 32961| 675| const uint8_t* up0 = (*upfunc0)( // 32962| 675| scratch_buffer_2k_ptr + (0u * 672u), // 32963| 675| src_ptr_x0, // 32964| 675| src_ptr_x0, // 32965| 675| src_len0, // 32966| 675| h1v2_bias, // 32967| 675| first_column, // 32968| 675| (total_src_len0 >= half_width_for_2to1)); 32969| | 32970| 675| const uint8_t* src_ptr_x1 = src1 + (x / inv_h1); 32971| 675| const uint8_t* up1 = (*upfunc1)( // 32972| 675| scratch_buffer_2k_ptr + (1u * 672u), // 32973| 675| src_ptr_x1, // 32974| 675| src_ptr_x1, // 32975| 675| src_len1, // 32976| 675| h1v2_bias, // 32977| 675| first_column, // 32978| 675| (total_src_len1 >= half_width_for_2to1)); 32979| | 32980| 675| const uint8_t* src_ptr_x2 = src2 + (x / inv_h2); 32981| 675| const uint8_t* up2 = (*upfunc2)( // 32982| 675| scratch_buffer_2k_ptr + (2u * 672u), // 32983| 675| src_ptr_x2, // 32984| 675| src_ptr_x2, // 32985| 675| src_len2, // 32986| 675| h1v2_bias, // 32987| 675| first_column, // 32988| 675| (total_src_len2 >= half_width_for_2to1)); 32989| | 32990| 675| (*conv3func)(dst, x, end, y, up0, up1, up2); 32991| 675| x = end; 32992| 675| } 32993| 675|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle: 32474| 6.48k| bool last_column) { 32475| 6.48k| uint8_t* dp = dst_ptr; 32476| 6.48k| const uint8_t* sp_major = src_ptr_major; 32477| 6.48k| const uint8_t* sp_minor = src_ptr_minor; 32478| 181k| while (src_len--) { ------------------ | Branch (32478:10): [True: 175k, False: 6.48k] ------------------ 32479| 175k| *dp++ = (uint8_t)(((3u * ((uint32_t)(*sp_major++))) + // 32480| 175k| (1u * ((uint32_t)(*sp_minor++))) + // 32481| 175k| h1v2_bias) >> 32482| 175k| 2u); 32483| 175k| } 32484| 6.48k| return dst_ptr; 32485| 6.48k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle: 32495| 5.51k| bool last_column) { 32496| 5.51k| uint8_t* dp = dst_ptr; 32497| 5.51k| const uint8_t* sp = src_ptr_major; 32498| | 32499| 5.51k| if (first_column) { ------------------ | Branch (32499:7): [True: 5.51k, False: 0] ------------------ 32500| 5.51k| src_len--; 32501| 5.51k| if ((src_len <= 0u) && last_column) { ------------------ | Branch (32501:9): [True: 375, False: 5.13k] | Branch (32501:28): [True: 375, False: 0] ------------------ 32502| 375| uint8_t sv = *sp++; 32503| 375| *dp++ = sv; 32504| 375| *dp++ = sv; 32505| 375| return dst_ptr; 32506| 375| } 32507| 5.13k| uint32_t svp1 = sp[+1]; 32508| 5.13k| uint8_t sv = *sp++; 32509| 5.13k| *dp++ = sv; 32510| 5.13k| *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svp1 + 2u) >> 2u); 32511| 5.13k| if (src_len <= 0u) { ------------------ | Branch (32511:9): [True: 0, False: 5.13k] ------------------ 32512| 0| return dst_ptr; 32513| 0| } 32514| 5.13k| } 32515| | 32516| 5.13k| if (last_column) { ------------------ | Branch (32516:7): [True: 5.13k, False: 0] ------------------ 32517| 5.13k| src_len--; 32518| 5.13k| } 32519| | 32520| 59.6k| for (; src_len > 0u; src_len--) { ------------------ | Branch (32520:10): [True: 54.5k, False: 5.13k] ------------------ 32521| 54.5k| uint32_t svm1 = sp[-1]; 32522| 54.5k| uint32_t svp1 = sp[+1]; 32523| 54.5k| uint32_t sv3 = 3u * (uint32_t)(*sp++); 32524| 54.5k| *dp++ = (uint8_t)((sv3 + svm1 + 1u) >> 2u); 32525| 54.5k| *dp++ = (uint8_t)((sv3 + svp1 + 2u) >> 2u); 32526| 54.5k| } 32527| | 32528| 5.13k| if (last_column) { ------------------ | Branch (32528:7): [True: 5.13k, False: 0] ------------------ 32529| 5.13k| uint32_t svm1 = sp[-1]; 32530| 5.13k| uint8_t sv = *sp++; 32531| 5.13k| *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svm1 + 1u) >> 2u); 32532| 5.13k| *dp++ = sv; 32533| 5.13k| } 32534| | 32535| 5.13k| return dst_ptr; 32536| 5.51k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2: 33734| 5.57k| const uint8_t* up2) { 33735| 5.57k| if ((x + 32u) > x_end) { ------------------ | Branch (33735:7): [True: 4.74k, False: 824] ------------------ 33736| 4.74k| wuffs_private_impl__swizzle_ycc__convert_3_bgrx( // 33737| 4.74k| dst, x, x_end, y, up0, up1, up2); 33738| 4.74k| return; 33739| 4.74k| } 33740| | 33741| 824| size_t dst_stride = dst->private_impl.planes[0].stride; 33742| 824| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 33743| 824| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 33744| | 33745| | // u0001 = u16x16 [0x0001 .. 0x0001] 33746| | // u00FF = u16x16 [0x00FF .. 0x00FF] 33747| | // uFF80 = u16x16 [0xFF80 .. 0xFF80] 33748| | // uFFFF = u16x16 [0xFFFF .. 0xFFFF] 33749| 824| const __m256i u0001 = _mm256_set1_epi16(+0x0001); 33750| 824| const __m256i u00FF = _mm256_set1_epi16(+0x00FF); 33751| 824| const __m256i uFF80 = _mm256_set1_epi16(-0x0080); 33752| 824| const __m256i uFFFF = _mm256_set1_epi16(-0x0001); 33753| | 33754| | // p8000_p0000 = u16x16 [0x8000 0x0000 .. 0x8000 0x0000] 33755| 824| const __m256i p8000_p0000 = _mm256_set_epi16( // 33756| 824| +0x0000, -0x8000, +0x0000, -0x8000, // 33757| 824| +0x0000, -0x8000, +0x0000, -0x8000, // 33758| 824| +0x0000, -0x8000, +0x0000, -0x8000, // 33759| 824| +0x0000, -0x8000, +0x0000, -0x8000); 33760| | 33761| | // Per wuffs_base__color_ycc__as__color_u32, the formulae: 33762| | // 33763| | // R = Y + 1.40200 * Cr 33764| | // G = Y - 0.34414 * Cb - 0.71414 * Cr 33765| | // B = Y + 1.77200 * Cb 33766| | // 33767| | // When scaled by 1<<16: 33768| | // 33769| | // 0.34414 becomes 0x0581A = 22554. 33770| | // 0.71414 becomes 0x0B6D2 = 46802. 33771| | // 1.40200 becomes 0x166E9 = 91881. 33772| | // 1.77200 becomes 0x1C5A2 = 116130. 33773| | // 33774| | // Separate the integer and fractional parts, since we work with signed 33775| | // 16-bit SIMD lanes. The fractional parts range from -0.5 .. +0.5 (as 33776| | // floating-point) which is from -0x8000 .. +0x8000 (as fixed-point). 33777| | // 33778| | // -0x3A5E = -0x20000 + 0x1C5A2 The B:Cb factor. 33779| | // +0x66E9 = -0x10000 + 0x166E9 The R:Cr factor. 33780| | // -0x581A = +0x00000 - 0x0581A The G:Cb factor. 33781| | // +0x492E = +0x10000 - 0x0B6D2 The G:Cr factor. 33782| 824| const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E); 33783| 824| const __m256i p66E9 = _mm256_set1_epi16(+0x66E9); 33784| 824| const __m256i m581A_p492E = _mm256_set_epi16( // 33785| 824| +0x492E, -0x581A, +0x492E, -0x581A, // 33786| 824| +0x492E, -0x581A, +0x492E, -0x581A, // 33787| 824| +0x492E, -0x581A, +0x492E, -0x581A, // 33788| 824| +0x492E, -0x581A, +0x492E, -0x581A); 33789| | 33790| 2.18k| while (x < x_end) { ------------------ | Branch (33790:10): [True: 1.36k, False: 824] ------------------ 33791| | // Load chroma values in even and odd columns (the high 8 bits of each 33792| | // u16x16 element are zero) and then subtract 0x0080. 33793| | // 33794| | // cb_all = u8x32 [cb.00 cb.01 cb.02 cb.03 .. cb.1C cb.1D cb.1E cb.1F] 33795| | // cb_eve = i16x16 [cb.00-0x80 cb.02-0x80 .. cb.1C-0x80 cb.1E-0x80 ] 33796| | // cb_odd = i16x16 [cb.01-0x80 cb.03-0x80 .. cb.1D-0x80 cb.1F-0x80 ] 33797| | // 33798| | // Ditto for the cr_xxx Chroma-Red values. 33799| 1.36k| __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1); 33800| 1.36k| __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2); 33801| 1.36k| __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF)); 33802| 1.36k| __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF)); 33803| 1.36k| __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8)); 33804| 1.36k| __m256i cr_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cr_all, 8)); 33805| | 33806| | // ---- 33807| | 33808| | // Calculate: 33809| | // 33810| | // B-Y = (+1.77200 * Cb) as floating-point 33811| | // R-Y = (+1.40200 * Cr) as floating-point 33812| | // 33813| | // B-Y = ((0x2_0000 - 0x3A5E) * Cb) as fixed-point 33814| | // R-Y = ((0x1_0000 + 0x66E9) * Cr) as fixed-point 33815| | // 33816| | // B-Y = ((-0x3A5E * Cb) + ("2.0" * Cb)) 33817| | // R-Y = ((+0x66E9 * Cr) + ("1.0" * Cr)) 33818| | 33819| | // Multiply by m3A5E or p66E9, taking the high 16 bits. There's also a 33820| | // doubling (add x to itself), adding-of-1 and halving (shift right by 1). 33821| | // That makes multiply-and-take-high round to nearest (instead of down). 33822| 1.36k| __m256i tmp_by_eve = _mm256_srai_epi16( 33823| 1.36k| _mm256_add_epi16( 33824| 1.36k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001), 33825| 1.36k| 1); 33826| 1.36k| __m256i tmp_by_odd = _mm256_srai_epi16( 33827| 1.36k| _mm256_add_epi16( 33828| 1.36k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001), 33829| 1.36k| 1); 33830| 1.36k| __m256i tmp_ry_eve = _mm256_srai_epi16( 33831| 1.36k| _mm256_add_epi16( 33832| 1.36k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001), 33833| 1.36k| 1); 33834| 1.36k| __m256i tmp_ry_odd = _mm256_srai_epi16( 33835| 1.36k| _mm256_add_epi16( 33836| 1.36k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001), 33837| 1.36k| 1); 33838| | 33839| | // Add (2 * Cb) and (1 * Cr). 33840| 1.36k| __m256i by_eve = 33841| 1.36k| _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve)); 33842| 1.36k| __m256i by_odd = 33843| 1.36k| _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd)); 33844| 1.36k| __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve); 33845| 1.36k| __m256i ry_odd = _mm256_add_epi16(tmp_ry_odd, cr_odd); 33846| | 33847| | // ---- 33848| | 33849| | // Calculate: 33850| | // 33851| | // G-Y = (-0.34414 * Cb) + 33852| | // (-0.71414 * Cr) as floating-point 33853| | // 33854| | // G-Y = ((+0x0_0000 - 0x581A) * Cb) + 33855| | // ((-0x1_0000 + 0x492E) * Cr) as fixed-point 33856| | // 33857| | // G-Y = (-0x581A * Cb) + 33858| | // (+0x492E * Cr) - ("1.0" * Cr) 33859| | 33860| | // Multiply-add to get ((-0x581A * Cb) + (+0x492E * Cr)). 33861| 1.36k| __m256i tmp0_gy_eve_lo = _mm256_madd_epi16( // 33862| 1.36k| _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E); 33863| 1.36k| __m256i tmp0_gy_eve_hi = _mm256_madd_epi16( // 33864| 1.36k| _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E); 33865| 1.36k| __m256i tmp0_gy_odd_lo = _mm256_madd_epi16( // 33866| 1.36k| _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E); 33867| 1.36k| __m256i tmp0_gy_odd_hi = _mm256_madd_epi16( // 33868| 1.36k| _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E); 33869| | 33870| | // Divide the i32x8 vectors by (1 << 16), rounding to nearest. 33871| 1.36k| __m256i tmp1_gy_eve_lo = 33872| 1.36k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16); 33873| 1.36k| __m256i tmp1_gy_eve_hi = 33874| 1.36k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16); 33875| 1.36k| __m256i tmp1_gy_odd_lo = 33876| 1.36k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16); 33877| 1.36k| __m256i tmp1_gy_odd_hi = 33878| 1.36k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_hi, p8000_p0000), 16); 33879| | 33880| | // Pack the ((-0x581A * Cb) + (+0x492E * Cr)) as i16x16 and subtract Cr. 33881| 1.36k| __m256i gy_eve = _mm256_sub_epi16( 33882| 1.36k| _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve); 33883| 1.36k| __m256i gy_odd = _mm256_sub_epi16( 33884| 1.36k| _mm256_packs_epi32(tmp1_gy_odd_lo, tmp1_gy_odd_hi), cr_odd); 33885| | 33886| | // ---- 33887| | 33888| | // Add Y to (B-Y), (G-Y) and (R-Y) to produce B, G and R. 33889| | // 33890| | // For the resultant packed_x_xxx vectors, only elements 0 ..= 7 and 16 ..= 33891| | // 23 of the 32-element vectors matter (since we'll unpacklo but not 33892| | // unpackhi them). Let … denote 8 ignored consecutive u8 values and let % 33893| | // denote 0xFF. We'll end this section with: 33894| | // 33895| | // packed_b_eve = u8x32 [b00 b02 .. b0C b0E … b10 b12 .. b1C b1E …] 33896| | // packed_b_odd = u8x32 [b01 b03 .. b0D b0F … b11 b13 .. b1D b1F …] 33897| | // packed_g_eve = u8x32 [g00 g02 .. g0C g0E … g10 g12 .. g1C g1E …] 33898| | // packed_g_odd = u8x32 [g01 g03 .. g0D g0F … g11 g13 .. g1D g1F …] 33899| | // packed_r_eve = u8x32 [r00 r02 .. r0C r0E … r10 r12 .. r1C r1E …] 33900| | // packed_r_odd = u8x32 [r01 r03 .. r0D r0F … r11 r13 .. r1D r1F …] 33901| | // uFFFF = u8x32 [ % % .. % % … % % .. % % …] 33902| | 33903| 1.36k| __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0); 33904| 1.36k| __m256i yy_eve = _mm256_and_si256(yy_all, u00FF); 33905| 1.36k| __m256i yy_odd = _mm256_srli_epi16(yy_all, 8); 33906| | 33907| 1.36k| __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve); 33908| 1.36k| __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd); 33909| 1.36k| __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve); 33910| 1.36k| __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd); 33911| | 33912| 1.36k| __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve); 33913| 1.36k| __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd); 33914| 1.36k| __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve); 33915| 1.36k| __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd); 33916| | 33917| 1.36k| __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve); 33918| 1.36k| __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd); 33919| 1.36k| __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve); 33920| 1.36k| __m256i packed_r_odd = _mm256_packus_epi16(loose_r_odd, loose_r_odd); 33921| | 33922| | // ---- 33923| | 33924| | // Mix those values (unpacking in 8, 16 and then 32 bit units) to get the 33925| | // desired BGRX/RGBX order. 33926| | // 33927| | // From here onwards, all of our __m256i registers are u8x32. 33928| | 33929| | // mix00 = [b00 g00 b02 g02 .. b0E g0E b10 g10 .. b1C g1C b1E g1E] 33930| | // mix01 = [b01 g01 b03 g03 .. b0F g0F b11 g11 .. b1D g1D b1F g1F] 33931| | // mix02 = [r00 % r02 % .. r0E % r10 % .. r1C % r1E %] 33932| | // mix03 = [r01 % r03 % .. r0F % r11 % .. r1D % r1F %] 33933| | // 33934| | // See also § below. 33935| 1.36k| __m256i mix00 = _mm256_unpacklo_epi8(packed_b_eve, packed_g_eve); 33936| 1.36k| __m256i mix01 = _mm256_unpacklo_epi8(packed_b_odd, packed_g_odd); 33937| 1.36k| __m256i mix02 = _mm256_unpacklo_epi8(packed_r_eve, uFFFF); 33938| 1.36k| __m256i mix03 = _mm256_unpacklo_epi8(packed_r_odd, uFFFF); 33939| | 33940| | // mix10 = [b00 g00 r00 % b02 g02 r02 % b04 g04 r04 % b06 g06 r06 % 33941| | // b10 g10 r10 % b12 g12 r12 % b14 g14 r14 % b16 g16 r16 %] 33942| | // mix11 = [b01 g01 r01 % b03 g03 r03 % b05 g05 r05 % b07 g07 r07 % 33943| | // b11 g11 r11 % b13 g13 r13 % b15 g15 r15 % b17 g17 r17 %] 33944| | // mix12 = [b08 g08 r08 % b0A g0A r0A % b0C g0C r0C % b0E g0E r0E % 33945| | // b18 g18 r18 % b1A g1A r1A % b1C g1C r1C % b1E g1E r1E %] 33946| | // mix13 = [b09 g09 r09 % b0B g0B r0B % b0D g0D r0D % b0F g0F r0F % 33947| | // b19 g19 r19 % b1B g1B r1B % b1D g1D r1D % b1F g1F r1F %] 33948| 1.36k| __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02); 33949| 1.36k| __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03); 33950| 1.36k| __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02); 33951| 1.36k| __m256i mix13 = _mm256_unpackhi_epi16(mix01, mix03); 33952| | 33953| | // mix20 = [b00 g00 r00 % b01 g01 r01 % b02 g02 r02 % b03 g03 r03 % 33954| | // b10 g10 r10 % b11 g11 r11 % b12 g12 r12 % b13 g13 r13 %] 33955| | // mix21 = [b04 g04 r04 % b05 g05 r05 % b06 g06 r06 % b07 g07 r07 % 33956| | // b14 g14 r14 % b15 g15 r15 % b16 g16 r16 % b17 g17 r17 %] 33957| | // mix22 = [b08 g08 r08 % b09 g09 r09 % b0A g0A r0A % b0B g0B r0B % 33958| | // b18 g18 r18 % b19 g19 r19 % b1A g1A r1A % b1B g1B r1B %] 33959| | // mix23 = [b0C g0C r0C % b0D g0D r0D % b0E g0E r0E % b0F g0F r0F % 33960| | // b1C g1C r1C % b1D g1D r1D % b1E g1E r1E % b1F g1F r1F %] 33961| 1.36k| __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11); 33962| 1.36k| __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11); 33963| 1.36k| __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13); 33964| 1.36k| __m256i mix23 = _mm256_unpackhi_epi32(mix12, mix13); 33965| | 33966| | // mix30 = [b00 g00 r00 % b01 g01 r01 % b02 g02 r02 % b03 g03 r03 % 33967| | // b04 g04 r04 % b05 g05 r05 % b06 g06 r06 % b07 g07 r07 %] 33968| | // mix31 = [b08 g08 r08 % b09 g09 r09 % b0A g0A r0A % b0B g0B r0B % 33969| | // b0C g0C r0C % b0D g0D r0D % b0E g0E r0E % b0F g0F r0F %] 33970| | // mix32 = [b10 g10 r10 % b11 g11 r11 % b12 g12 r12 % b13 g13 r13 % 33971| | // b14 g14 r14 % b15 g15 r15 % b16 g16 r16 % b17 g17 r17 %] 33972| | // mix33 = [b18 g18 r18 % b19 g19 r19 % b1A g1A r1A % b1B g1B r1B % 33973| | // b1C g1C r1C % b1D g1D r1D % b1E g1E r1E % b1F g1F r1F %] 33974| 1.36k| __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20); 33975| 1.36k| __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20); 33976| 1.36k| __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31); 33977| 1.36k| __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31); 33978| | 33979| | // Write out four u8x32 SIMD registers (128 bytes, 32 BGRX/RGBX pixels). 33980| 1.36k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30); 33981| 1.36k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31); 33982| 1.36k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32); 33983| 1.36k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x60), mix33); 33984| | 33985| | // Advance by up to 32 pixels. The first iteration might be smaller than 32 33986| | // so that all of the remaining steps are exactly 32. 33987| 1.36k| uint32_t n = 32u - (31u & (x - x_end)); 33988| 1.36k| dst_iter += 4u * n; 33989| 1.36k| up0 += n; 33990| 1.36k| up1 += n; 33991| 1.36k| up2 += n; 33992| 1.36k| x += n; 33993| 1.36k| } 33994| 824|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__convert_3_rgbx_x86_avx2: 34007| 4.95k| const uint8_t* up2) { 34008| 4.95k| if ((x + 32u) > x_end) { ------------------ | Branch (34008:7): [True: 4.29k, False: 654] ------------------ 34009| 4.29k| wuffs_private_impl__swizzle_ycc__convert_3_rgbx( // 34010| 4.29k| dst, x, x_end, y, up0, up1, up2); 34011| 4.29k| return; 34012| 4.29k| } 34013| | 34014| 654| size_t dst_stride = dst->private_impl.planes[0].stride; 34015| 654| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 34016| 654| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 34017| | 34018| 654| const __m256i u0001 = _mm256_set1_epi16(+0x0001); 34019| 654| const __m256i u00FF = _mm256_set1_epi16(+0x00FF); 34020| 654| const __m256i uFF80 = _mm256_set1_epi16(-0x0080); 34021| 654| const __m256i uFFFF = _mm256_set1_epi16(-0x0001); 34022| | 34023| 654| const __m256i p8000_p0000 = _mm256_set_epi16( // 34024| 654| +0x0000, -0x8000, +0x0000, -0x8000, // 34025| 654| +0x0000, -0x8000, +0x0000, -0x8000, // 34026| 654| +0x0000, -0x8000, +0x0000, -0x8000, // 34027| 654| +0x0000, -0x8000, +0x0000, -0x8000); 34028| | 34029| 654| const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E); 34030| 654| const __m256i p66E9 = _mm256_set1_epi16(+0x66E9); 34031| 654| const __m256i m581A_p492E = _mm256_set_epi16( // 34032| 654| +0x492E, -0x581A, +0x492E, -0x581A, // 34033| 654| +0x492E, -0x581A, +0x492E, -0x581A, // 34034| 654| +0x492E, -0x581A, +0x492E, -0x581A, // 34035| 654| +0x492E, -0x581A, +0x492E, -0x581A); 34036| | 34037| 1.86k| while (x < x_end) { ------------------ | Branch (34037:10): [True: 1.21k, False: 654] ------------------ 34038| 1.21k| __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1); 34039| 1.21k| __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2); 34040| 1.21k| __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF)); 34041| 1.21k| __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF)); 34042| 1.21k| __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8)); 34043| 1.21k| __m256i cr_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cr_all, 8)); 34044| | 34045| 1.21k| __m256i tmp_by_eve = _mm256_srai_epi16( 34046| 1.21k| _mm256_add_epi16( 34047| 1.21k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001), 34048| 1.21k| 1); 34049| 1.21k| __m256i tmp_by_odd = _mm256_srai_epi16( 34050| 1.21k| _mm256_add_epi16( 34051| 1.21k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001), 34052| 1.21k| 1); 34053| 1.21k| __m256i tmp_ry_eve = _mm256_srai_epi16( 34054| 1.21k| _mm256_add_epi16( 34055| 1.21k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001), 34056| 1.21k| 1); 34057| 1.21k| __m256i tmp_ry_odd = _mm256_srai_epi16( 34058| 1.21k| _mm256_add_epi16( 34059| 1.21k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001), 34060| 1.21k| 1); 34061| | 34062| 1.21k| __m256i by_eve = 34063| 1.21k| _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve)); 34064| 1.21k| __m256i by_odd = 34065| 1.21k| _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd)); 34066| 1.21k| __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve); 34067| 1.21k| __m256i ry_odd = _mm256_add_epi16(tmp_ry_odd, cr_odd); 34068| | 34069| 1.21k| __m256i tmp0_gy_eve_lo = _mm256_madd_epi16( // 34070| 1.21k| _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E); 34071| 1.21k| __m256i tmp0_gy_eve_hi = _mm256_madd_epi16( // 34072| 1.21k| _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E); 34073| 1.21k| __m256i tmp0_gy_odd_lo = _mm256_madd_epi16( // 34074| 1.21k| _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E); 34075| 1.21k| __m256i tmp0_gy_odd_hi = _mm256_madd_epi16( // 34076| 1.21k| _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E); 34077| | 34078| 1.21k| __m256i tmp1_gy_eve_lo = 34079| 1.21k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16); 34080| 1.21k| __m256i tmp1_gy_eve_hi = 34081| 1.21k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16); 34082| 1.21k| __m256i tmp1_gy_odd_lo = 34083| 1.21k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16); 34084| 1.21k| __m256i tmp1_gy_odd_hi = 34085| 1.21k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_hi, p8000_p0000), 16); 34086| | 34087| 1.21k| __m256i gy_eve = _mm256_sub_epi16( 34088| 1.21k| _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve); 34089| 1.21k| __m256i gy_odd = _mm256_sub_epi16( 34090| 1.21k| _mm256_packs_epi32(tmp1_gy_odd_lo, tmp1_gy_odd_hi), cr_odd); 34091| | 34092| 1.21k| __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0); 34093| 1.21k| __m256i yy_eve = _mm256_and_si256(yy_all, u00FF); 34094| 1.21k| __m256i yy_odd = _mm256_srli_epi16(yy_all, 8); 34095| | 34096| 1.21k| __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve); 34097| 1.21k| __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd); 34098| 1.21k| __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve); 34099| 1.21k| __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd); 34100| | 34101| 1.21k| __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve); 34102| 1.21k| __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd); 34103| 1.21k| __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve); 34104| 1.21k| __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd); 34105| | 34106| 1.21k| __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve); 34107| 1.21k| __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd); 34108| 1.21k| __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve); 34109| 1.21k| __m256i packed_r_odd = _mm256_packus_epi16(loose_r_odd, loose_r_odd); 34110| | 34111| | // § Note the swapped B and R channels. 34112| 1.21k| __m256i mix00 = _mm256_unpacklo_epi8(packed_r_eve, packed_g_eve); 34113| 1.21k| __m256i mix01 = _mm256_unpacklo_epi8(packed_r_odd, packed_g_odd); 34114| 1.21k| __m256i mix02 = _mm256_unpacklo_epi8(packed_b_eve, uFFFF); 34115| 1.21k| __m256i mix03 = _mm256_unpacklo_epi8(packed_b_odd, uFFFF); 34116| | 34117| 1.21k| __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02); 34118| 1.21k| __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03); 34119| 1.21k| __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02); 34120| 1.21k| __m256i mix13 = _mm256_unpackhi_epi16(mix01, mix03); 34121| | 34122| 1.21k| __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11); 34123| 1.21k| __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11); 34124| 1.21k| __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13); 34125| 1.21k| __m256i mix23 = _mm256_unpackhi_epi32(mix12, mix13); 34126| | 34127| 1.21k| __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20); 34128| 1.21k| __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20); 34129| 1.21k| __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31); 34130| 1.21k| __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31); 34131| | 34132| 1.21k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30); 34133| 1.21k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31); 34134| 1.21k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32); 34135| 1.21k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x60), mix33); 34136| | 34137| 1.21k| uint32_t n = 32u - (31u & (x - x_end)); 34138| 1.21k| dst_iter += 4u * n; 34139| 1.21k| up0 += n; 34140| 1.21k| up1 += n; 34141| 1.21k| up2 += n; 34142| 1.21k| x += n; 34143| 1.21k| } 34144| 654|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2: 34158| 2.84k| bool last_column) { 34159| 2.84k| uint8_t* dp = dst_ptr; 34160| 2.84k| const uint8_t* sp_major = src_ptr_major; 34161| 2.84k| const uint8_t* sp_minor = src_ptr_minor; 34162| | 34163| 2.84k| if (first_column) { ------------------ | Branch (34163:7): [True: 2.84k, False: 0] ------------------ 34164| 2.84k| src_len--; 34165| 2.84k| if ((src_len <= 0u) && last_column) { ------------------ | Branch (34165:9): [True: 374, False: 2.46k] | Branch (34165:28): [True: 374, False: 0] ------------------ 34166| 374| uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + // 34167| 374| (4u * ((uint32_t)(*sp_minor++))); 34168| 374| *dp++ = (uint8_t)((sv + 8u) >> 4u); 34169| 374| *dp++ = (uint8_t)((sv + 7u) >> 4u); 34170| 374| return dst_ptr; 34171| 374| } 34172| | 34173| 2.46k| uint32_t sv_major_m1 = sp_major[-0]; // Clamp offset to zero. 34174| 2.46k| uint32_t sv_minor_m1 = sp_minor[-0]; // Clamp offset to zero. 34175| 2.46k| uint32_t sv_major_p1 = sp_major[+1]; 34176| 2.46k| uint32_t sv_minor_p1 = sp_minor[+1]; 34177| | 34178| 2.46k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 34179| 2.46k| (3u * ((uint32_t)(*sp_minor++))); 34180| 2.46k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 34181| 2.46k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u); 34182| 2.46k| if (src_len <= 0u) { ------------------ | Branch (34182:9): [True: 0, False: 2.46k] ------------------ 34183| 0| return dst_ptr; 34184| 0| } 34185| 2.46k| } 34186| | 34187| 2.46k| if (last_column) { ------------------ | Branch (34187:7): [True: 2.46k, False: 0] ------------------ 34188| 2.46k| src_len--; 34189| 2.46k| } 34190| | 34191| 2.46k| if (src_len < 32) { ------------------ | Branch (34191:7): [True: 2.46k, False: 0] ------------------ 34192| | // This fallback is the same as the non-SIMD-capable code path. 34193| 30.3k| for (; src_len > 0u; src_len--) { ------------------ | Branch (34193:12): [True: 27.9k, False: 2.46k] ------------------ 34194| 27.9k| uint32_t sv_major_m1 = sp_major[-1]; 34195| 27.9k| uint32_t sv_minor_m1 = sp_minor[-1]; 34196| 27.9k| uint32_t sv_major_p1 = sp_major[+1]; 34197| 27.9k| uint32_t sv_minor_p1 = sp_minor[+1]; 34198| | 34199| 27.9k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 34200| 27.9k| (3u * ((uint32_t)(*sp_minor++))); 34201| 27.9k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 34202| 27.9k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u); 34203| 27.9k| } 34204| | 34205| 2.46k| } else { 34206| 0| while (src_len > 0u) { ------------------ | Branch (34206:12): [True: 0, False: 0] ------------------ 34207| | // Load 1+32+1 samples (six u8x32 vectors) from the major (jxx) and minor 34208| | // (nxx) rows. 34209| | // 34210| | // major_p0 = [j00 j01 j02 j03 .. j28 j29 j30 j31] // p0 = "plus 0" 34211| | // minor_p0 = [n00 n01 n02 n03 .. n28 n29 n30 n31] // p0 = "plus 0" 34212| | // major_m1 = [jm1 j00 j01 j02 .. j27 j28 j29 j30] // m1 = "minus 1" 34213| | // minor_m1 = [nm1 n00 n01 n02 .. n27 n28 n29 n30] // m1 = "minus 1" 34214| | // major_p1 = [j01 j02 j03 j04 .. j29 j30 j31 j32] // p1 = "plus 1" 34215| | // minor_p1 = [n01 n02 n03 n04 .. n29 n30 n31 n32] // p1 = "plus 1" 34216| 0| __m256i major_p0 = 34217| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major + 0)); 34218| 0| __m256i minor_p0 = 34219| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor + 0)); 34220| 0| __m256i major_m1 = 34221| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major - 1)); 34222| 0| __m256i minor_m1 = 34223| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor - 1)); 34224| 0| __m256i major_p1 = 34225| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major + 1)); 34226| 0| __m256i minor_p1 = 34227| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor + 1)); 34228| | 34229| | // Unpack, staying with u8x32 vectors. 34230| | // 34231| | // step1_p0_lo = [j00 n00 j01 n01 .. j07 n07 j16 n16 j17 n17 .. j23 n23] 34232| | // step1_p0_hi = [j08 n08 j09 n09 .. j15 n15 j24 n24 j25 n25 .. j31 n31] 34233| | // step1_m1_lo = [jm1 nm1 j00 n00 .. j06 n06 j15 n15 j16 n16 .. j22 n22] 34234| | // step1_m1_hi = [j07 n07 j08 n08 .. j14 n14 j23 n23 j24 n24 .. j30 n30] 34235| | // step1_p1_lo = [j01 n01 j02 n02 .. j08 n08 j17 n17 j18 n18 .. j24 n24] 34236| | // step1_p1_hi = [j09 n09 j10 n10 .. j16 n16 j25 n25 j26 n26 .. j32 n32] 34237| 0| __m256i step1_p0_lo = _mm256_unpacklo_epi8(major_p0, minor_p0); 34238| 0| __m256i step1_p0_hi = _mm256_unpackhi_epi8(major_p0, minor_p0); 34239| 0| __m256i step1_m1_lo = _mm256_unpacklo_epi8(major_m1, minor_m1); 34240| 0| __m256i step1_m1_hi = _mm256_unpackhi_epi8(major_m1, minor_m1); 34241| 0| __m256i step1_p1_lo = _mm256_unpacklo_epi8(major_p1, minor_p1); 34242| 0| __m256i step1_p1_hi = _mm256_unpackhi_epi8(major_p1, minor_p1); 34243| | 34244| | // Multiply-add to get u16x16 vectors. 34245| | // 34246| | // step2_p0_lo = [9*j00+3*n00 9*j01+3*n01 .. 9*j23+3*n23] 34247| | // step2_p0_hi = [9*j08+3*n08 9*j09+3*n09 .. 9*j31+3*n31] 34248| | // step2_m1_lo = [3*jm1+1*nm1 3*j00+1*n00 .. 3*j22+1*n22] 34249| | // step2_m1_hi = [3*j07+1*n07 3*j08+1*n08 .. 3*j30+1*n30] 34250| | // step2_p1_lo = [3*j01+1*n01 3*j02+1*n02 .. 3*j24+1*n24] 34251| | // step2_p1_hi = [3*j09+1*n09 3*j10+1*n10 .. 3*j32+1*n32] 34252| 0| const __m256i k0309 = _mm256_set1_epi16(0x0309); 34253| 0| const __m256i k0103 = _mm256_set1_epi16(0x0103); 34254| 0| __m256i step2_p0_lo = _mm256_maddubs_epi16(step1_p0_lo, k0309); 34255| 0| __m256i step2_p0_hi = _mm256_maddubs_epi16(step1_p0_hi, k0309); 34256| 0| __m256i step2_m1_lo = _mm256_maddubs_epi16(step1_m1_lo, k0103); 34257| 0| __m256i step2_m1_hi = _mm256_maddubs_epi16(step1_m1_hi, k0103); 34258| 0| __m256i step2_p1_lo = _mm256_maddubs_epi16(step1_p1_lo, k0103); 34259| 0| __m256i step2_p1_hi = _mm256_maddubs_epi16(step1_p1_hi, k0103); 34260| | 34261| | // Compute the weighted sums of (p0, m1) and (p0, p1). For example: 34262| | // 34263| | // step3_m1_lo[00] = ((9*j00) + (3*n00) + (3*jm1) + (1*nm1)) as u16 34264| | // step3_p1_hi[15] = ((9*j31) + (3*n31) + (3*j32) + (1*n32)) as u16 34265| 0| __m256i step3_m1_lo = _mm256_add_epi16(step2_p0_lo, step2_m1_lo); 34266| 0| __m256i step3_m1_hi = _mm256_add_epi16(step2_p0_hi, step2_m1_hi); 34267| 0| __m256i step3_p1_lo = _mm256_add_epi16(step2_p0_lo, step2_p1_lo); 34268| 0| __m256i step3_p1_hi = _mm256_add_epi16(step2_p0_hi, step2_p1_hi); 34269| | 34270| | // Bias by 8 (on the left) or 7 (on the right) and then divide by 16 34271| | // (which is 9+3+3+1) to get a weighted average. On the left (m1), shift 34272| | // the u16 right value by 4. On the right (p1), shift right by 4 and then 34273| | // shift left by 8 so that, when still in the u16x16 little-endian 34274| | // interpretation, we have: 34275| | // - m1_element = (etcetera + 8) >> 4 34276| | // - p1_element = ((etcetera + 7) >> 4) << 8 34277| | // 34278| | // step4_m1_lo = [0x00?? 0x00?? ... 0x00?? 0x00??] 34279| | // step4_p1_lo = [0x??00 0x??00 ... 0x??00 0x??00] 34280| | // step4_m1_hi = [0x00?? 0x00?? ... 0x00?? 0x00??] 34281| | // step4_p1_hi = [0x??00 0x??00 ... 0x??00 0x??00] 34282| 0| __m256i step4_m1_lo = _mm256_srli_epi16( 34283| 0| _mm256_add_epi16(step3_m1_lo, _mm256_set1_epi16(8)), 4); 34284| 0| __m256i step4_p1_lo = _mm256_slli_epi16( 34285| 0| _mm256_srli_epi16(_mm256_add_epi16(step3_p1_lo, _mm256_set1_epi16(7)), 34286| 0| 4), 34287| 0| 8); 34288| 0| __m256i step4_m1_hi = _mm256_srli_epi16( 34289| 0| _mm256_add_epi16(step3_m1_hi, _mm256_set1_epi16(8)), 4); 34290| 0| __m256i step4_p1_hi = _mm256_slli_epi16( 34291| 0| _mm256_srli_epi16(_mm256_add_epi16(step3_p1_hi, _mm256_set1_epi16(7)), 34292| 0| 4), 34293| 0| 8); 34294| | 34295| | // Bitwise-or two "0x00"-rich u16x16 vectors to get a u8x32 vector. Do 34296| | // that twice. Once for the low columns and once for the high columns. 34297| | // 34298| | // In terms of jxx (major row) or nxx (minor row) source samples: 34299| | // - low columns means ( 0 .. 8; 16 .. 24). 34300| | // - high columns means ( 8 .. 16; 24 .. 32). 34301| | // 34302| | // In terms of dxx destination samples (there are twice as many): 34303| | // - low columns means ( 0 .. 16; 32 .. 48). 34304| | // - high columns means (16 .. 32; 48 .. 64). 34305| | // 34306| | // step5_lo = [d00 d01 .. d14 d15 d32 d33 .. d46 d47] 34307| | // step5_hi = [d16 d17 .. d30 d31 d48 d49 .. d62 d63] 34308| | // 34309| | // The d00, d02 ... d62 even elements come from (p0, m1) weighted sums. 34310| | // The d01, d03 ... d63 odd elements come from (p0, p1) weighted sums. 34311| 0| __m256i step5_lo = _mm256_or_si256(step4_m1_lo, step4_p1_lo); 34312| 0| __m256i step5_hi = _mm256_or_si256(step4_m1_hi, step4_p1_hi); 34313| | 34314| | // Permute and store. 34315| | // 34316| | // step6_00_31 = [d00 d01 .. d14 d15 d16 d17 .. d30 d31] 34317| | // step6_32_63 = [d32 d33 .. d46 d47 d48 d49 .. d62 d63] 34318| 0| __m256i step6_00_31 = _mm256_permute2x128_si256(step5_lo, step5_hi, 0x20); 34319| 0| __m256i step6_32_63 = _mm256_permute2x128_si256(step5_lo, step5_hi, 0x31); 34320| 0| _mm256_storeu_si256((__m256i*)(void*)(dp + 0x00), step6_00_31); 34321| 0| _mm256_storeu_si256((__m256i*)(void*)(dp + 0x20), step6_32_63); 34322| | 34323| | // Advance by up to 32 source samples (64 destination samples). The first 34324| | // iteration might be smaller than 32 so that all of the remaining steps 34325| | // are exactly 32. 34326| 0| size_t n = 32u - (31u & (0u - src_len)); 34327| 0| dp += 2u * n; 34328| 0| sp_major += n; 34329| 0| sp_minor += n; 34330| 0| src_len -= n; 34331| 0| } 34332| 0| } 34333| | 34334| 2.46k| if (last_column) { ------------------ | Branch (34334:7): [True: 2.46k, False: 0] ------------------ 34335| 2.46k| uint32_t sv_major_m1 = sp_major[-1]; 34336| 2.46k| uint32_t sv_minor_m1 = sp_minor[-1]; 34337| 2.46k| uint32_t sv_major_p1 = sp_major[+0]; // Clamp offset to zero. 34338| 2.46k| uint32_t sv_minor_p1 = sp_minor[+0]; // Clamp offset to zero. 34339| | 34340| 2.46k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 34341| 2.46k| (3u * ((uint32_t)(*sp_minor++))); 34342| 2.46k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 34343| 2.46k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u); 34344| 2.46k| } 34345| | 34346| 2.46k| return dst_ptr; 34347| 2.84k|} pixel_swizzler_fuzzer.c:wuffs_base__ptr_u8__reader: 3444| 3.66k|wuffs_base__ptr_u8__reader(uint8_t* ptr, size_t len, bool closed) { 3445| 3.66k| wuffs_base__io_buffer ret; 3446| 3.66k| ret.data.ptr = ptr; 3447| 3.66k| ret.data.len = len; 3448| 3.66k| ret.meta.wi = len; 3449| 3.66k| ret.meta.ri = 0; 3450| 3.66k| ret.meta.pos = 0; 3451| 3.66k| ret.meta.closed = closed; 3452| 3.66k| return ret; 3453| 3.66k|} pixel_swizzler_fuzzer.c:wuffs_base__make_pixel_format: 4812| 11.0k|wuffs_base__make_pixel_format(uint32_t repr) { 4813| 11.0k| wuffs_base__pixel_format f; 4814| 11.0k| f.repr = repr; 4815| 11.0k| return f; 4816| 11.0k|} pixel_swizzler_fuzzer.c:wuffs_base__status__message: 674| 2.15k|wuffs_base__status__message(const wuffs_base__status* z) { 675| 2.15k| if (z->repr) { ------------------ | Branch (675:7): [True: 2.15k, False: 0] ------------------ 676| 2.15k| if ((*z->repr == '$') || (*z->repr == '#') || (*z->repr == '@')) { ------------------ | Branch (676:9): [True: 0, False: 2.15k] | Branch (676:30): [True: 2.15k, False: 0] | Branch (676:51): [True: 0, False: 0] ------------------ 677| 2.15k| return z->repr + 1; 678| 2.15k| } 679| 2.15k| } 680| 0| return z->repr; 681| 2.15k|} pixel_swizzler_fuzzer.c:wuffs_base__u32__max: 1060| 44.0k|wuffs_base__u32__max(uint32_t x, uint32_t y) { 1061| 44.0k| return x > y ? x : y; ------------------ | Branch (1061:10): [True: 17.5k, False: 26.4k] ------------------ 1062| 44.0k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__set: 5125| 3.66k| uint32_t height) { 5126| 3.66k| if (!c) { ------------------ | Branch (5126:7): [True: 0, False: 3.66k] ------------------ 5127| 0| return; 5128| 0| } 5129| 3.66k| if (pixfmt_repr) { ------------------ | Branch (5129:7): [True: 3.66k, False: 0] ------------------ 5130| 3.66k| do { 5131| |#if SIZE_MAX < 0xFFFFFFFFFFFFFFFFull 5132| | uint64_t wh = ((uint64_t)width) * ((uint64_t)height); 5133| | // TODO: handle things other than 1 byte per pixel. 5134| | if (wh > ((uint64_t)SIZE_MAX)) { 5135| | break; 5136| | } 5137| |#endif 5138| 3.66k| c->private_impl.pixfmt.repr = pixfmt_repr; 5139| 3.66k| c->private_impl.pixsub.repr = pixsub_repr; 5140| 3.66k| c->private_impl.width = width; 5141| 3.66k| c->private_impl.height = height; 5142| 3.66k| return; 5143| 3.66k| } while (0); ------------------ | Branch (5143:14): [Folded, False: 0] ------------------ 5144| 3.66k| } 5145| | 5146| 0| c->private_impl.pixfmt.repr = 0; 5147| 0| c->private_impl.pixsub.repr = 0; 5148| 0| c->private_impl.width = 0; 5149| 0| c->private_impl.height = 0; 5150| 0|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__pixbuf_len: 5210| 3.66k|wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { 5211| 3.66k| if (!c) { ------------------ | Branch (5211:7): [True: 0, False: 3.66k] ------------------ 5212| 0| return 0; 5213| 0| } 5214| 3.66k| if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) { ------------------ | Branch (5214:7): [True: 0, False: 3.66k] ------------------ 5215| | // TODO: support planar pixel formats, concious of pixel subsampling. 5216| 0| return 0; 5217| 0| } 5218| 3.66k| uint32_t bits_per_pixel = 5219| 3.66k| wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt); 5220| 3.66k| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { ------------------ | Branch (5220:7): [True: 0, False: 3.66k] | Branch (5220:32): [True: 0, False: 3.66k] ------------------ 5221| | // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? 5222| 0| return 0; 5223| 0| } 5224| 3.66k| uint64_t bytes_per_pixel = bits_per_pixel / 8; 5225| | 5226| 3.66k| uint64_t n = 5227| 3.66k| ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); 5228| 3.66k| if (n > (UINT64_MAX / bytes_per_pixel)) { ------------------ | Branch (5228:7): [True: 0, False: 3.66k] ------------------ 5229| 0| return 0; 5230| 0| } 5231| 3.66k| n *= bytes_per_pixel; 5232| | 5233| 3.66k| if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) { ------------------ | Branch (5233:7): [True: 132, False: 3.53k] ------------------ 5234| 132| if (n > ------------------ | Branch (5234:9): [True: 0, False: 132] ------------------ 5235| 132| (UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) { ------------------ | | 4784| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5236| 0| return 0; 5237| 0| } 5238| 132| n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4784| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5239| 132| } 5240| | 5241| 3.66k| return n; 5242| 3.66k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__set_from_slice: 5779| 3.66k| wuffs_base__slice_u8 pixbuf_memory) { 5780| 3.66k| if (!pb) { ------------------ | Branch (5780:7): [True: 0, False: 3.66k] ------------------ 5781| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 5782| 0| } 5783| 3.66k| memset(pb, 0, sizeof(*pb)); 5784| 3.66k| if (!pixcfg) { ------------------ | Branch (5784:7): [True: 0, False: 3.66k] ------------------ 5785| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 5786| 0| } 5787| 3.66k| if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { ------------------ | Branch (5787:7): [True: 0, False: 3.66k] ------------------ 5788| | // TODO: support planar pixel formats, concious of pixel subsampling. 5789| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 5790| 0| } 5791| 3.66k| uint32_t bits_per_pixel = 5792| 3.66k| wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); 5793| 3.66k| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { ------------------ | Branch (5793:7): [True: 0, False: 3.66k] | Branch (5793:32): [True: 0, False: 3.66k] ------------------ 5794| | // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? 5795| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 5796| 0| } 5797| 3.66k| uint64_t bytes_per_pixel = bits_per_pixel / 8; 5798| | 5799| 3.66k| uint8_t* ptr = pixbuf_memory.ptr; 5800| 3.66k| uint64_t len = pixbuf_memory.len; 5801| 3.66k| if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) { ------------------ | Branch (5801:7): [True: 132, False: 3.53k] ------------------ 5802| | // Split a WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH byte 5803| | // chunk (1024 bytes = 256 palette entries × 4 bytes per entry) from the 5804| | // start of pixbuf_memory. We split from the start, not the end, so that 5805| | // the both chunks' pointers have the same alignment as the original 5806| | // pointer, up to an alignment of 1024. 5807| 132| if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4784| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ | Branch (5807:9): [True: 0, False: 132] ------------------ 5808| 0| return wuffs_base__make_status( 5809| 0| wuffs_base__error__bad_argument_length_too_short); 5810| 0| } 5811| 132| wuffs_base__table_u8* tab = 5812| 132| &pb->private_impl 5813| 132| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; ------------------ | | 4781| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3 ------------------ 5814| 132| tab->ptr = ptr; 5815| 132| tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4784| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5816| 132| tab->height = 1; 5817| 132| tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4784| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5818| 132| ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4784| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5819| 132| len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4784| 132|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5820| 132| } 5821| | 5822| 3.66k| uint64_t wh = ((uint64_t)pixcfg->private_impl.width) * 5823| 3.66k| ((uint64_t)pixcfg->private_impl.height); 5824| 3.66k| size_t width = (size_t)(pixcfg->private_impl.width); 5825| 3.66k| if ((wh > (UINT64_MAX / bytes_per_pixel)) || ------------------ | Branch (5825:7): [True: 0, False: 3.66k] ------------------ 5826| 3.66k| (width > (SIZE_MAX / bytes_per_pixel))) { ------------------ | Branch (5826:7): [True: 0, False: 3.66k] ------------------ 5827| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 5828| 0| } 5829| 3.66k| wh *= bytes_per_pixel; 5830| 3.66k| width = ((size_t)(width * bytes_per_pixel)); 5831| 3.66k| if (wh > len) { ------------------ | Branch (5831:7): [True: 0, False: 3.66k] ------------------ 5832| 0| return wuffs_base__make_status( 5833| 0| wuffs_base__error__bad_argument_length_too_short); 5834| 0| } 5835| | 5836| 3.66k| pb->pixcfg = *pixcfg; 5837| 3.66k| wuffs_base__table_u8* tab = &pb->private_impl.planes[0]; 5838| 3.66k| tab->ptr = ptr; 5839| 3.66k| tab->width = width; 5840| 3.66k| tab->height = pixcfg->private_impl.height; 5841| 3.66k| tab->stride = width; 5842| | return wuffs_base__make_status(NULL); 5843| 3.66k|} pixel_swizzler_fuzzer.c:wuffs_base__empty_slice_u8: 1783| 3.66k|wuffs_base__empty_slice_u8(void) { 1784| 3.66k| wuffs_base__slice_u8 ret; 1785| | ret.ptr = NULL; 1786| 3.66k| ret.len = 0; 1787| 3.66k| return ret; 1788| 3.66k|}