LLVMFuzzerTestOneInput: 118| 3.38k|LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 119| 3.38k| llvmFuzzerTestOneInput(data, size); 120| 3.38k| return 0; 121| 3.38k|} pixel_swizzler_fuzzer.c:llvmFuzzerTestOneInput: 84| 3.38k|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.38k| size_t s2 = size / 2; 87| 3.38k| uint32_t hash0 = jenkins_hash_u32(data, s2); 88| 3.38k| uint32_t hash1 = jenkins_hash_u32(data + s2, size - s2); 89| 3.38k| uint64_t hash = (((uint64_t)hash0) << 32) | ((uint64_t)hash1); 90| | 91| | // The ! means that closed will be true for (size == 0). 92| 3.38k| const bool closed = !(1 & popcount32(hash0)); 93| | 94| 3.38k| wuffs_base__io_buffer src = 95| 3.38k| wuffs_base__ptr_u8__reader((uint8_t*)data, size, closed); 96| | 97| 3.38k| const char* msg = fuzz(&src, hash); 98| 3.38k| if (msg) { ------------------ | Branch (98:7): [True: 1.97k, False: 1.41k] ------------------ 99| 1.97k| if (strnlen(msg, 2047) >= 2047) { ------------------ | Branch (99:9): [True: 0, False: 1.97k] ------------------ 100| 0| msg = "fuzzlib: internal error: error message is too long"; 101| 0| } 102| 1.97k| if (closed && strstr(msg, "base: short read")) { ------------------ | Branch (102:9): [True: 1.02k, False: 950] | Branch (102:19): [True: 0, False: 1.02k] ------------------ 103| 0| fprintf(stderr, "short read on a closed io_reader\n"); 104| 0| intentional_segfault(); 105| 1.97k| } else if (strstr(msg, "internal error:")) { ------------------ | Branch (105:16): [True: 0, False: 1.97k] ------------------ 106| | fprintf(stderr, "internal errors shouldn't occur: \"%s\"\n", msg); 107| 0| intentional_segfault(); 108| 0| } 109| 1.97k| } 110| 3.38k| return msg; 111| 3.38k|} pixel_swizzler_fuzzer.c:jenkins_hash_u32: 53| 6.77k|jenkins_hash_u32(const uint8_t* data, size_t size) { 54| 6.77k| uint32_t hash = 0; 55| 6.77k| size_t i = 0; 56| 25.0M| while (i != size) { ------------------ | Branch (56:10): [True: 25.0M, False: 6.77k] ------------------ 57| 25.0M| hash += data[i++]; 58| 25.0M| hash += hash << 10; 59| 25.0M| hash ^= hash >> 6; 60| 25.0M| } 61| 6.77k| hash += hash << 3; 62| 6.77k| hash ^= hash >> 11; 63| 6.77k| hash += hash << 15; 64| 6.77k| return hash; 65| 6.77k|} pixel_swizzler_fuzzer.c:popcount32: 27| 3.38k|popcount32(uint32_t x) { 28| 3.38k| static const uint8_t table[256] = { 29| 3.38k| 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, // 30| 3.38k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 31| 3.38k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 32| 3.38k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 33| 3.38k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 34| 3.38k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 35| 3.38k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 36| 3.38k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 37| 3.38k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 38| 3.38k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 39| 3.38k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 40| 3.38k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 41| 3.38k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 42| 3.38k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 43| 3.38k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 44| 3.38k| 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, // 45| 3.38k| }; 46| 3.38k| return table[0xFF & (x >> 0)] + table[0xFF & (x >> 8)] + 47| 3.38k| table[0xFF & (x >> 16)] + table[0xFF & (x >> 24)]; 48| 3.38k|} 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.38k|fuzz_swizzle_interleaved_from_slice(wuffs_base__io_buffer* src, uint64_t hash) { 127| 3.38k| uint8_t dst_palette_array[1024]; 128| 3.38k| uint8_t src_palette_array[1024]; 129| 3.38k| if ((src->meta.wi - src->meta.ri) >= 2048) { ------------------ | Branch (129:7): [True: 226, False: 3.16k] ------------------ 130| 226| memcpy(dst_palette_array, src->data.ptr + src->meta.ri, 1024); 131| 226| src->meta.ri += 1024; 132| 226| memcpy(src_palette_array, src->data.ptr + src->meta.ri, 1024); 133| 226| src->meta.ri += 1024; 134| 3.16k| } else { 135| 3.23M| for (uint32_t i = 0; i < 1024; i++) { ------------------ | Branch (135:26): [True: 3.23M, False: 3.16k] ------------------ 136| 3.23M| dst_palette_array[i] = (uint8_t)i; 137| 3.23M| src_palette_array[i] = (uint8_t)i; 138| 3.23M| } 139| 3.16k| } 140| 3.38k| wuffs_base__slice_u8 dst_palette = 141| 3.38k| wuffs_base__make_slice_u8(&dst_palette_array[0], 1024); 142| 3.38k| wuffs_base__slice_u8 src_palette = 143| 3.38k| wuffs_base__make_slice_u8(&src_palette_array[0], 1024); 144| | 145| 3.38k| size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]); 146| 3.38k| wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( 147| 3.38k| pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); 148| 3.38k| wuffs_base__pixel_format src_pixfmt = wuffs_base__make_pixel_format( 149| 3.38k| pixfmts[(0xFF & (hash >> 8)) % num_pixfmts]); 150| | 151| 3.38k| size_t num_blends = sizeof(blends) / sizeof(blends[0]); 152| 3.38k| wuffs_base__pixel_blend blend = blends[(0xFF & (hash >> 16)) % num_blends]; 153| | 154| 3.38k| size_t dst_len = 0xFF & (hash >> 24); 155| 3.38k| size_t src_len = 0xFF & (hash >> 32); 156| | 157| 3.38k| wuffs_base__pixel_swizzler swizzler; 158| 3.38k| wuffs_base__status status = wuffs_base__pixel_swizzler__prepare( 159| 3.38k| &swizzler, dst_pixfmt, dst_palette, src_pixfmt, src_palette, blend); 160| 3.38k| if (status.repr) { ------------------ | Branch (160:7): [True: 290, False: 3.09k] ------------------ 161| 290| return wuffs_base__status__message(&status); 162| 290| } 163| | 164| 3.09k| static size_t alloc_size = 0; 165| 3.09k| if (alloc_size == 0) { ------------------ | Branch (165:7): [True: 1, False: 3.09k] ------------------ 166| 1| alloc_size = round_up_to_pagesize(0x100); 167| 1| } 168| | 169| 3.09k| static uint8_t* dst_alloc = NULL; 170| 3.09k| if (!dst_alloc) { ------------------ | Branch (170:7): [True: 1, False: 3.09k] ------------------ 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.09k| static uint8_t* src_alloc = NULL; 178| 3.09k| if (!src_alloc) { ------------------ | Branch (178:7): [True: 1, False: 3.09k] ------------------ 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.09k| wuffs_base__slice_u8 dst_slice = 188| 3.09k| wuffs_base__make_slice_u8(dst_alloc + alloc_size - dst_len, dst_len); 189| 3.09k| wuffs_base__slice_u8 src_slice = 190| 3.09k| wuffs_base__make_slice_u8(src_alloc + alloc_size - src_len, src_len); 191| | 192| | // Fill in dst_slice and src_slice. 193| 3.09k| if ((src->meta.wi - src->meta.ri) >= (dst_len + src_len)) { ------------------ | Branch (193:7): [True: 578, False: 2.51k] ------------------ 194| 578| memcpy(dst_slice.ptr, src->data.ptr + src->meta.ri, dst_len); 195| 578| src->meta.ri += dst_len; 196| 578| memcpy(src_slice.ptr, src->data.ptr + src->meta.ri, src_len); 197| 578| src->meta.ri += src_len; 198| 2.51k| } else { 199| 315k| for (size_t i = 0; i < dst_len; i++) { ------------------ | Branch (199:24): [True: 313k, False: 2.51k] ------------------ 200| 313k| dst_slice.ptr[i] = (uint8_t)i; 201| 313k| } 202| 224k| for (size_t i = 0; i < src_len; i++) { ------------------ | Branch (202:24): [True: 222k, False: 2.51k] ------------------ 203| 222k| src_slice.ptr[i] = (uint8_t)i; 204| 222k| } 205| 2.51k| } 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.09k| wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice( 216| 3.09k| &swizzler, dst_slice, dst_palette, src_slice); 217| | 218| | return NULL; 219| 3.09k|} fuzz_swizzle_ycck: 222| 3.38k|fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) { 223| 3.38k| uint8_t dst_palette_array[1024] = {0}; 224| 3.38k| wuffs_base__slice_u8 dst_palette = 225| 3.38k| wuffs_base__make_slice_u8(&dst_palette_array[0], 1024); 226| | 227| 3.38k| size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]); 228| 3.38k| wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( 229| 3.38k| pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); 230| | 231| 3.38k| uint32_t x_min_incl = (63 & (hash >> 8)) + 1; 232| 3.38k| uint32_t x_max_excl = (63 & (hash >> 14)) + 1; 233| 3.38k| uint32_t y_min_incl = (63 & (hash >> 20)) + 1; 234| 3.38k| uint32_t y_max_excl = (63 & (hash >> 26)) + 1; 235| | 236| 3.38k| uint32_t width_in_mcus = (3 & (hash >> 32)) + 1; 237| 3.38k| uint32_t height_in_mcus = (3 & (hash >> 34)) + 1; 238| | 239| 3.38k| uint32_t allow_hv3 = 1 & (hash >> 36); 240| 3.38k| uint8_t ycc_model = (1 & (hash >> 37)) ? 0x80 : 0x00; ------------------ | Branch (240:23): [True: 1.10k, False: 2.28k] ------------------ 241| 3.38k| uint8_t ycc_upsampling = 1 & (hash >> 38); 242| 3.38k| bool use_4th_component = 1 & (hash >> 39); 243| | 244| 3.38k| if (ycc_upsampling) { ------------------ | Branch (244:7): [True: 1.28k, False: 2.09k] ------------------ 245| 1.28k| x_min_incl = 0; 246| 1.28k| y_min_incl = 0; 247| 2.09k| } else { 248| 2.09k| if (x_min_incl > x_max_excl) { ------------------ | Branch (248:9): [True: 1.05k, False: 1.04k] ------------------ 249| 1.05k| uint32_t a = x_min_incl; 250| 1.05k| x_min_incl = x_max_excl; 251| 1.05k| x_max_excl = a; 252| 1.05k| } 253| 2.09k| if (y_min_incl > y_max_excl) { ------------------ | Branch (253:9): [True: 1.22k, False: 873] ------------------ 254| 1.22k| uint32_t a = y_min_incl; 255| 1.22k| y_min_incl = y_max_excl; 256| 1.22k| y_max_excl = a; 257| 1.22k| } 258| 2.09k| } 259| | 260| 3.38k| uint32_t possible_hv_values[2][4] = { 261| 3.38k| {1, 1, 2, 4}, 262| 3.38k| {1, 1, 3, 3}, 263| 3.38k| }; 264| 3.38k| uint32_t h0 = possible_hv_values[allow_hv3][3 & (hash >> 28)]; 265| 3.38k| uint32_t h1 = possible_hv_values[allow_hv3][3 & (hash >> 30)]; 266| 3.38k| uint32_t h2 = possible_hv_values[allow_hv3][3 & (hash >> 32)]; 267| 3.38k| uint32_t h3 = 268| 3.38k| use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 34)] : 0; ------------------ | Branch (268:7): [True: 780, False: 2.60k] ------------------ 269| 3.38k| uint32_t v0 = possible_hv_values[allow_hv3][3 & (hash >> 36)]; 270| 3.38k| uint32_t v1 = possible_hv_values[allow_hv3][3 & (hash >> 38)]; 271| 3.38k| uint32_t v2 = possible_hv_values[allow_hv3][3 & (hash >> 40)]; 272| 3.38k| uint32_t v3 = 273| 3.38k| use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 42)] : 0; ------------------ | Branch (273:7): [True: 780, False: 2.60k] ------------------ 274| | 275| 3.38k| uint32_t width0 = 8 * width_in_mcus * h0; 276| 3.38k| uint32_t width1 = 8 * width_in_mcus * h1; 277| 3.38k| uint32_t width2 = 8 * width_in_mcus * h2; 278| 3.38k| uint32_t width3 = 8 * width_in_mcus * h3; 279| 3.38k| uint32_t height0 = 8 * height_in_mcus * v0; 280| 3.38k| uint32_t height1 = 8 * height_in_mcus * v1; 281| 3.38k| uint32_t height2 = 8 * height_in_mcus * v2; 282| 3.38k| uint32_t height3 = 8 * height_in_mcus * v3; 283| | 284| 3.38k| uint32_t hmax = wuffs_base__u32__max( 285| 3.38k| h0, wuffs_base__u32__max(h1, wuffs_base__u32__max(h2, h3))); 286| 3.38k| uint32_t vmax = wuffs_base__u32__max( 287| 3.38k| v0, wuffs_base__u32__max(v1, wuffs_base__u32__max(v2, v3))); 288| 3.38k| x_max_excl = x_min_incl + wuffs_base__u32__min(x_max_excl - x_min_incl, 289| 3.38k| 8 * width_in_mcus * hmax); 290| 3.38k| y_max_excl = y_min_incl + wuffs_base__u32__min(y_max_excl - y_min_incl, 291| 3.38k| 8 * height_in_mcus * vmax); 292| | 293| 3.38k| static size_t dst_alloc_size = 0; 294| 3.38k| if (dst_alloc_size == 0) { ------------------ | Branch (294:7): [True: 1, False: 3.38k] ------------------ 295| 1| dst_alloc_size = round_up_to_pagesize(8 * 64 * 64); 296| 1| } 297| | 298| 3.38k| static uint8_t* dst_alloc = NULL; 299| 3.38k| if (!dst_alloc) { ------------------ | Branch (299:7): [True: 1, False: 3.38k] ------------------ 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.38k| wuffs_base__pixel_buffer dst_pixbuf; 307| 3.38k| wuffs_base__pixel_config dst_pixcfg; 308| 3.38k| wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, x_max_excl, 309| 3.38k| y_max_excl); 310| 3.38k| uint64_t dst_pixbuf_len = wuffs_base__pixel_config__pixbuf_len(&dst_pixcfg); 311| 3.38k| if (dst_pixbuf_len > dst_alloc_size) { ------------------ | Branch (311:7): [True: 0, False: 3.38k] ------------------ 312| 0| return "fuzz: internal error: dst_alloc_size is too small"; 313| 3.38k| } else { 314| 3.38k| wuffs_base__status status = wuffs_base__pixel_buffer__set_from_slice( 315| 3.38k| &dst_pixbuf, &dst_pixcfg, 316| 3.38k| wuffs_base__make_slice_u8(dst_alloc + dst_alloc_size - dst_pixbuf_len, 317| 3.38k| dst_pixbuf_len)); 318| 3.38k| if (status.repr) { ------------------ | Branch (318:9): [True: 0, False: 3.38k] ------------------ 319| 0| return "fuzz: internal error: wuffs_base__pixel_buffer__set_from_slice " 320| 0| "failed"; 321| 0| } 322| 3.38k| } 323| | 324| 3.38k| static size_t src_alloc_size = 0; 325| 3.38k| if (src_alloc_size == 0) { ------------------ | Branch (325:7): [True: 1, False: 3.38k] ------------------ 326| 1| src_alloc_size = round_up_to_pagesize(8 * 4 * 4 * 8 * 4 * 4); 327| 1| } 328| | 329| 3.38k| static uint8_t* src_alloc0 = NULL; 330| 3.38k| static uint8_t* src_alloc1 = NULL; 331| 3.38k| static uint8_t* src_alloc2 = NULL; 332| 3.38k| static uint8_t* src_alloc3 = NULL; 333| 3.38k| if (!src_alloc0) { ------------------ | Branch (333:7): [True: 1, False: 3.38k] ------------------ 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.38k| if (!src_alloc1) { ------------------ | Branch (339:7): [True: 1, False: 3.38k] ------------------ 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.38k| if (!src_alloc2) { ------------------ | Branch (345:7): [True: 1, False: 3.38k] ------------------ 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.38k| if (!src_alloc3) { ------------------ | Branch (351:7): [True: 1, False: 3.38k] ------------------ 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.38k| uint32_t src_len0 = width0 * height0; 359| 3.38k| uint32_t src_len1 = width1 * height1; 360| 3.38k| uint32_t src_len2 = width2 * height2; 361| 3.38k| uint32_t src_len3 = width3 * height3; 362| 3.38k| if ((src_len0 > src_alloc_size) || // ------------------ | Branch (362:7): [True: 0, False: 3.38k] ------------------ 363| 3.38k| (src_len1 > src_alloc_size) || // ------------------ | Branch (363:7): [True: 0, False: 3.38k] ------------------ 364| 3.38k| (src_len2 > src_alloc_size) || // ------------------ | Branch (364:7): [True: 0, False: 3.38k] ------------------ 365| 3.38k| (src_len3 > src_alloc_size)) { ------------------ | Branch (365:7): [True: 0, False: 3.38k] ------------------ 366| 0| return "fuzz: internal error: src_alloc_size is too small"; 367| 0| } 368| | 369| 3.38k| uint8_t s0 = 0x90; 370| 3.38k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (370:7): [True: 3.07k, False: 310] ------------------ 371| 3.07k| s0 = src->data.ptr[src->meta.ri++]; 372| 3.07k| } 373| 3.38k| uint8_t s1 = 0x91; 374| 3.38k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (374:7): [True: 2.79k, False: 596] ------------------ 375| 2.79k| s1 = src->data.ptr[src->meta.ri++]; 376| 2.79k| } 377| 3.38k| uint8_t s2 = 0x92; 378| 3.38k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (378:7): [True: 1.70k, False: 1.68k] ------------------ 379| 1.70k| s2 = src->data.ptr[src->meta.ri++]; 380| 1.70k| } 381| 3.38k| uint8_t s3 = 0x93; 382| 3.38k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (382:7): [True: 374, False: 3.01k] ------------------ 383| 374| s3 = src->data.ptr[src->meta.ri++]; 384| 374| } 385| | 386| 3.38k| wuffs_base__slice_u8 src0 = wuffs_base__make_slice_u8( 387| 3.38k| src_alloc0 + src_alloc_size - src_len0, src_len0); 388| 3.38k| memset(src0.ptr, s0, src0.len); 389| 3.38k| wuffs_base__slice_u8 src1 = wuffs_base__make_slice_u8( 390| 3.38k| src_alloc1 + src_alloc_size - src_len1, src_len1); 391| 3.38k| memset(src1.ptr, s1, src1.len); 392| 3.38k| wuffs_base__slice_u8 src2 = wuffs_base__make_slice_u8( 393| 3.38k| src_alloc2 + src_alloc_size - src_len2, src_len2); 394| 3.38k| memset(src2.ptr, s2, src2.len); 395| 3.38k| wuffs_base__slice_u8 src3 = wuffs_base__empty_slice_u8(); 396| 3.38k| if (use_4th_component) { ------------------ | Branch (396:7): [True: 780, False: 2.60k] ------------------ 397| 780| wuffs_base__slice_u8 src3 = wuffs_base__make_slice_u8( 398| 780| src_alloc3 + src_alloc_size - src_len3, src_len3); 399| 780| memset(src3.ptr, s3, src3.len); 400| 780| } 401| | 402| 3.38k| wuffs_base__pixel_swizzler swizzler = {0}; 403| 3.38k| uint8_t scratch_buffer[2048]; 404| 3.38k| wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck( 405| 3.38k| &swizzler, &dst_pixbuf, dst_palette, // 406| 3.38k| x_min_incl, x_max_excl, // 407| 3.38k| y_min_incl, y_max_excl, // 408| 3.38k| src0, src1, src2, src3, // 409| 3.38k| width0, width1, width2, width3, // 410| 3.38k| height0, height1, height2, height3, // 411| 3.38k| width0, width1, width2, width3, // 412| 3.38k| h0, h1, h2, h3, // 413| 3.38k| v0, v1, v2, v3, // 414| 3.38k| ycc_model, // 415| 3.38k| ycc_upsampling, // 416| 3.38k| wuffs_base__make_slice_u8(scratch_buffer, sizeof(scratch_buffer))); 417| 3.38k| if (status.repr) { ------------------ | Branch (417:7): [True: 1.74k, False: 1.64k] ------------------ 418| 1.74k| return wuffs_base__status__message(&status); 419| 1.74k| } 420| 1.64k| return NULL; 421| 3.38k|} fuzz: 424| 3.38k|fuzz(wuffs_base__io_buffer* src, uint64_t hash) { 425| 3.38k| const char* s0 = fuzz_swizzle_interleaved_from_slice(src, hash); 426| 3.38k| const char* s1 = fuzz_swizzle_ycck(src, hash); 427| 3.38k| if (s0 && strstr(s0, "internal error:")) { ------------------ | Branch (427:7): [True: 290, False: 3.09k] | Branch (427:13): [True: 0, False: 290] ------------------ 428| 0| return s0; 429| 0| } 430| 3.38k| if (s1 && strstr(s1, "internal error:")) { ------------------ | Branch (430:7): [True: 1.74k, False: 1.64k] | Branch (430:13): [True: 0, False: 1.74k] ------------------ 431| 0| return s1; 432| 0| } 433| 3.38k| return s0 ? s0 : s1; ------------------ | Branch (433:10): [True: 290, False: 3.09k] ------------------ 434| 3.38k|} wuffs_base__pixel_buffer__set_color_u32_argb_premul_at: 24596| 487k| wuffs_base__color_u32_argb_premul color) { 24597| 487k| if (!pb) { ------------------ | Branch (24597:7): [True: 0, False: 487k] ------------------ 24598| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 24599| 0| } 24600| 487k| if ((x >= pb->pixcfg.private_impl.width) || ------------------ | Branch (24600:7): [True: 0, False: 487k] ------------------ 24601| 487k| (y >= pb->pixcfg.private_impl.height)) { ------------------ | Branch (24601:7): [True: 0, False: 487k] ------------------ 24602| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 24603| 0| } 24604| | 24605| 487k| if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (24605:7): [True: 0, False: 487k] ------------------ 24606| | // TODO: support planar formats. 24607| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 24608| 0| } 24609| | 24610| 487k| size_t stride = pb->private_impl.planes[0].stride; 24611| 487k| uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)); 24612| | 24613| 487k| switch (pb->pixcfg.private_impl.pixfmt.repr) { 24614| 13.8k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 13.8k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (24614:5): [True: 13.8k, False: 473k] ------------------ 24615| 30.1k| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 30.1k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (24615:5): [True: 16.3k, False: 471k] ------------------ 24616| 30.1k| wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color); 24617| 30.1k| break; 24618| | 24619| | // Common formats above. Rarer formats below. 24620| | 24621| 70.3k| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 70.3k|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (24621:5): [True: 70.3k, False: 416k] ------------------ 24622| 70.3k| wuffs_base__poke_u8__no_bounds_check( 24623| 70.3k| row + ((size_t)x), 24624| 70.3k| wuffs_base__color_u32_argb_premul__as__color_u8_gray(color)); 24625| 70.3k| break; 24626| 19.5k| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 19.5k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (24626:5): [True: 19.5k, False: 467k] ------------------ 24627| 19.5k| wuffs_base__poke_u16le__no_bounds_check( 24628| 19.5k| row + (2 * ((size_t)x)), 24629| 19.5k| wuffs_base__color_u32_argb_premul__as__color_u16_gray(color)); 24630| 19.5k| break; 24631| 12.3k| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 12.3k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (24631:5): [True: 12.3k, False: 474k] ------------------ 24632| 12.3k| wuffs_base__poke_u16be__no_bounds_check( 24633| 12.3k| row + (2 * ((size_t)x)), 24634| 12.3k| wuffs_base__color_u32_argb_premul__as__color_u16_gray(color)); 24635| 12.3k| break; 24636| 22.5k| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4946| 22.5k|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (24636:5): [True: 22.5k, False: 464k] ------------------ 24637| 22.5k| wuffs_base__poke_u16le__no_bounds_check( 24638| 22.5k| row + (2 * ((size_t)x)), 24639| 22.5k| wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul( 24640| 22.5k| color)); 24641| 22.5k| break; 24642| | 24643| 32.3k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 32.3k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (24643:5): [True: 32.3k, False: 454k] ------------------ 24644| 32.3k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4959| 32.3k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (24644:5): [True: 0, False: 487k] ------------------ 24645| 45.0k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4960| 45.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (24645:5): [True: 12.6k, False: 474k] ------------------ 24646| 45.0k| wuffs_base__poke_u8__no_bounds_check( 24647| 45.0k| row + ((size_t)x), wuffs_base__pixel_palette__closest_element( 24648| 45.0k| wuffs_base__pixel_buffer__palette(pb), 24649| 45.0k| pb->pixcfg.private_impl.pixfmt, color)); 24650| 45.0k| break; 24651| | 24652| 58.9k| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 58.9k|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (24652:5): [True: 58.9k, False: 428k] ------------------ 24653| 58.9k| wuffs_base__poke_u16le__no_bounds_check( 24654| 58.9k| row + (2 * ((size_t)x)), 24655| 58.9k| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color)); 24656| 58.9k| break; 24657| 53.4k| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 53.4k|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (24657:5): [True: 53.4k, False: 433k] ------------------ 24658| 53.4k| wuffs_base__poke_u24le__no_bounds_check(row + (3 * ((size_t)x)), color); 24659| 53.4k| break; 24660| 21.6k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 21.6k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (24660:5): [True: 21.6k, False: 465k] ------------------ 24661| 21.6k| wuffs_base__poke_u32le__no_bounds_check( 24662| 21.6k| row + (4 * ((size_t)x)), 24663| 21.6k| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 24664| 21.6k| color)); 24665| 21.6k| break; 24666| 90.9k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 90.9k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (24666:5): [True: 90.9k, False: 396k] ------------------ 24667| 90.9k| wuffs_base__poke_u64le__no_bounds_check( 24668| 90.9k| row + (8 * ((size_t)x)), 24669| 90.9k| wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul( 24670| 90.9k| color)); 24671| 90.9k| break; 24672| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (24672:5): [True: 0, False: 487k] ------------------ 24673| 0| wuffs_base__poke_u64le__no_bounds_check( 24674| 0| row + (8 * ((size_t)x)), wuffs_base__color_u32__as__color_u64(color)); 24675| 0| break; 24676| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (24676:5): [True: 0, False: 487k] ------------------ 24677| 0| wuffs_base__poke_u32le__no_bounds_check( 24678| 0| row + (4 * ((size_t)x)), (color >> 31) ? (color | 0xFF000000) : 0); ------------------ | Branch (24678:36): [True: 0, False: 0] ------------------ 24679| 0| break; 24680| | 24681| 35.1k| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 35.1k|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (24681:5): [True: 35.1k, False: 452k] ------------------ 24682| 35.1k| wuffs_base__poke_u24le__no_bounds_check( 24683| 35.1k| row + (3 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color)); 24684| 35.1k| break; 24685| 10.5k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 10.5k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (24685:5): [True: 10.5k, False: 476k] ------------------ 24686| 10.5k| wuffs_base__poke_u32le__no_bounds_check( 24687| 10.5k| row + (4 * ((size_t)x)), 24688| 10.5k| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 24689| 10.5k| wuffs_base__color_swap_u32_argb_abgr(color))); 24690| 10.5k| break; 24691| 16.7k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 16.7k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (24691:5): [True: 16.7k, False: 470k] ------------------ 24692| 16.7k| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 16.7k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (24692:5): [True: 0, False: 487k] ------------------ 24693| 16.7k| wuffs_base__poke_u32le__no_bounds_check( 24694| 16.7k| row + (4 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color)); 24695| 16.7k| break; 24696| | 24697| 0| default: ------------------ | Branch (24697:5): [True: 0, False: 487k] ------------------ 24698| | // TODO: support more formats. 24699| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 24700| 487k| } 24701| | 24702| 487k| return wuffs_base__make_status(NULL); 24703| 487k|} wuffs_base__pixel_palette__closest_element: 25365| 45.0k| wuffs_base__color_u32_argb_premul c) { 25366| 45.0k| size_t n = palette_slice.len / 4; 25367| 45.0k| if (n > (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 45.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ | Branch (25367:7): [True: 0, False: 45.0k] ------------------ 25368| 0| n = (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4); ------------------ | | 4900| 0|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 25369| 0| } 25370| 45.0k| size_t best_index = 0; 25371| 45.0k| uint64_t best_score = 0xFFFFFFFFFFFFFFFF; 25372| | 25373| | // Work in 16-bit color. 25374| 45.0k| uint32_t ca = 0x101 * (0xFF & (c >> 24)); 25375| 45.0k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 25376| 45.0k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 25377| 45.0k| uint32_t cb = 0x101 * (0xFF & (c >> 0)); 25378| | 25379| 45.0k| switch (palette_format.repr) { ------------------ | Branch (25379:11): [True: 45.0k, False: 0] ------------------ 25380| 32.3k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 32.3k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (25380:5): [True: 32.3k, False: 12.6k] ------------------ 25381| 32.3k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4959| 32.3k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (25381:5): [True: 0, False: 45.0k] ------------------ 25382| 45.0k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: { ------------------ | | 4960| 45.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (25382:5): [True: 12.6k, False: 32.3k] ------------------ 25383| 45.0k| bool nonpremul = palette_format.repr == 25384| 45.0k| WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL; ------------------ | | 4958| 45.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ 25385| | 25386| 45.0k| size_t i; 25387| 11.5M| for (i = 0; i < n; i++) { ------------------ | Branch (25387:19): [True: 11.5M, False: 45.0k] ------------------ 25388| | // Work in 16-bit color. 25389| 11.5M| uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0])); 25390| 11.5M| uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1])); 25391| 11.5M| uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2])); 25392| 11.5M| uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3])); 25393| | 25394| | // Convert to premultiplied alpha. 25395| 11.5M| if (nonpremul && (pa != 0xFFFF)) { ------------------ | Branch (25395:13): [True: 8.29M, False: 3.24M] | Branch (25395:26): [True: 4.85M, False: 3.43M] ------------------ 25396| 4.85M| pb = (pb * pa) / 0xFFFF; 25397| 4.85M| pg = (pg * pa) / 0xFFFF; 25398| 4.85M| pr = (pr * pa) / 0xFFFF; 25399| 4.85M| } 25400| | 25401| | // These deltas are conceptually int32_t (signed) but after squaring, 25402| | // it's equivalent to work in uint32_t (unsigned). 25403| 11.5M| pb -= cb; 25404| 11.5M| pg -= cg; 25405| 11.5M| pr -= cr; 25406| 11.5M| pa -= ca; 25407| 11.5M| uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) + 25408| 11.5M| ((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa)); 25409| 11.5M| if (best_score > score) { ------------------ | Branch (25409:13): [True: 93.3k, False: 11.4M] ------------------ 25410| 93.3k| best_score = score; 25411| 93.3k| best_index = i; 25412| 93.3k| } 25413| 11.5M| } 25414| 45.0k| break; 25415| 32.3k| } 25416| 45.0k| } 25417| | 25418| 45.0k| return (uint8_t)best_index; 25419| 45.0k|} wuffs_base__pixel_swizzler__prepare: 32599| 3.38k| wuffs_base__pixel_blend blend) { 32600| 3.38k| if (!p) { ------------------ | Branch (32600:7): [True: 0, False: 3.38k] ------------------ 32601| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 32602| 0| } 32603| 3.38k| p->private_impl.func = NULL; 32604| 3.38k| p->private_impl.transparent_black_func = NULL; 32605| 3.38k| p->private_impl.dst_pixfmt_bytes_per_pixel = 0; 32606| 3.38k| p->private_impl.src_pixfmt_bytes_per_pixel = 0; 32607| | 32608| | // ---- 32609| | 32610| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 32611| | switch (dst_pixfmt.repr) { 32612| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y) 32613| | case WUFFS_BASE__PIXEL_FORMAT__Y: 32614| | break; 32615| |#endif 32616| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_YA_NONPREMUL) 32617| | case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: 32618| | break; 32619| |#endif 32620| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565) 32621| | case WUFFS_BASE__PIXEL_FORMAT__BGR_565: 32622| | break; 32623| |#endif 32624| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR) 32625| | case WUFFS_BASE__PIXEL_FORMAT__BGR: 32626| | break; 32627| |#endif 32628| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL) 32629| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: 32630| | break; 32631| |#endif 32632| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL_4X16LE) 32633| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: 32634| | break; 32635| |#endif 32636| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_PREMUL) 32637| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: 32638| | break; 32639| |#endif 32640| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGB) 32641| | case WUFFS_BASE__PIXEL_FORMAT__RGB: 32642| | break; 32643| |#endif 32644| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_NONPREMUL) 32645| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: 32646| | break; 32647| |#endif 32648| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_PREMUL) 32649| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: 32650| | break; 32651| |#endif 32652| | default: 32653| | return wuffs_base__make_status( 32654| | wuffs_base__error__disabled_by_wuffs_config_dst_pixel_format_enable_allowlist); 32655| | } 32656| |#endif // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 32657| | 32658| | // ---- 32659| | 32660| 3.38k| wuffs_base__pixel_swizzler__func func = NULL; 32661| 3.38k| wuffs_base__pixel_swizzler__transparent_black_func transparent_black_func = 32662| 3.38k| NULL; 32663| | 32664| 3.38k| uint32_t dst_pixfmt_bits_per_pixel = 32665| 3.38k| wuffs_base__pixel_format__bits_per_pixel(&dst_pixfmt); 32666| 3.38k| if ((dst_pixfmt_bits_per_pixel == 0) || ------------------ | Branch (32666:7): [True: 0, False: 3.38k] ------------------ 32667| 3.38k| ((dst_pixfmt_bits_per_pixel & 7) != 0)) { ------------------ | Branch (32667:7): [True: 0, False: 3.38k] ------------------ 32668| 0| return wuffs_base__make_status( 32669| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 32670| 0| } 32671| | 32672| 3.38k| uint32_t src_pixfmt_bits_per_pixel = 32673| 3.38k| wuffs_base__pixel_format__bits_per_pixel(&src_pixfmt); 32674| 3.38k| if ((src_pixfmt_bits_per_pixel == 0) || ------------------ | Branch (32674:7): [True: 0, False: 3.38k] ------------------ 32675| 3.38k| ((src_pixfmt_bits_per_pixel & 7) != 0)) { ------------------ | Branch (32675:7): [True: 0, False: 3.38k] ------------------ 32676| 0| return wuffs_base__make_status( 32677| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 32678| 0| } 32679| | 32680| | // TODO: support many more formats. 32681| | 32682| 3.38k| switch (blend) { ------------------ | Branch (32682:11): [True: 3.38k, False: 0] ------------------ 32683| 1.49k| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1.49k|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32683:5): [True: 1.49k, False: 1.89k] ------------------ 32684| 1.49k| transparent_black_func = 32685| 1.49k| wuffs_private_impl__swizzle_transparent_black_src; 32686| 1.49k| break; 32687| | 32688| 1.89k| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 1.89k|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32688:5): [True: 1.89k, False: 1.49k] ------------------ 32689| 1.89k| transparent_black_func = 32690| 1.89k| wuffs_private_impl__swizzle_transparent_black_src_over; 32691| 1.89k| break; 32692| 3.38k| } 32693| | 32694| 3.38k| switch (src_pixfmt.repr) { ------------------ | Branch (32694:11): [True: 3.38k, False: 0] ------------------ 32695| 141| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 141|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32695:5): [True: 141, False: 3.24k] ------------------ 32696| 141| func = wuffs_private_impl__pixel_swizzler__prepare__y( 32697| 141| p, dst_pixfmt, dst_palette, src_palette, blend); 32698| 141| break; 32699| | 32700| 123| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 123|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (32700:5): [True: 123, False: 3.26k] ------------------ 32701| 123| func = wuffs_private_impl__pixel_swizzler__prepare__y_16be( 32702| 123| p, dst_pixfmt, dst_palette, src_palette, blend); 32703| 123| break; 32704| | 32705| 144| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 144|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (32705:5): [True: 144, False: 3.24k] ------------------ 32706| 144| func = wuffs_private_impl__pixel_swizzler__prepare__y_16le( 32707| 144| p, dst_pixfmt, dst_palette, src_palette, blend); 32708| 144| break; 32709| | 32710| 284| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4946| 284|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (32710:5): [True: 284, False: 3.10k] ------------------ 32711| 284| func = wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul( 32712| 284| p, dst_pixfmt, dst_palette, src_palette, blend); 32713| 284| break; 32714| | 32715| 228| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 228|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (32715:5): [True: 228, False: 3.15k] ------------------ 32716| 228| func = 32717| 228| wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul( 32718| 228| p, dst_pixfmt, dst_palette, src_palette, blend); 32719| 228| break; 32720| | 32721| 345| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4960| 345|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (32721:5): [True: 345, False: 3.04k] ------------------ 32722| 345| func = wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary( 32723| 345| p, dst_pixfmt, dst_palette, src_palette, blend); 32724| 345| break; 32725| | 32726| 113| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 113|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32726:5): [True: 113, False: 3.27k] ------------------ 32727| 113| func = wuffs_private_impl__pixel_swizzler__prepare__bgr_565( 32728| 113| p, dst_pixfmt, dst_palette, src_palette, blend); 32729| 113| break; 32730| | 32731| 125| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 125|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32731:5): [True: 125, False: 3.26k] ------------------ 32732| 125| func = wuffs_private_impl__pixel_swizzler__prepare__bgr( 32733| 125| p, dst_pixfmt, dst_palette, src_palette, blend); 32734| 125| break; 32735| | 32736| 216| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 216|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32736:5): [True: 216, False: 3.17k] ------------------ 32737| 216| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul( 32738| 216| p, dst_pixfmt, dst_palette, src_palette, blend); 32739| 216| break; 32740| | 32741| 289| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 289|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32741:5): [True: 289, False: 3.09k] ------------------ 32742| 289| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le( 32743| 289| p, dst_pixfmt, dst_palette, src_palette, blend); 32744| 289| break; 32745| | 32746| 262| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 262|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32746:5): [True: 262, False: 3.12k] ------------------ 32747| 262| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul( 32748| 262| p, dst_pixfmt, dst_palette, src_palette, blend); 32749| 262| break; 32750| | 32751| 420| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 420|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (32751:5): [True: 420, False: 2.96k] ------------------ 32752| 420| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le( 32753| 420| p, dst_pixfmt, dst_palette, src_palette, blend); 32754| 420| break; 32755| | 32756| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32756:5): [True: 0, False: 3.38k] ------------------ 32757| 0| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( 32758| 0| p, dst_pixfmt, dst_palette, src_palette, blend); 32759| 0| break; 32760| | 32761| 133| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 133|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32761:5): [True: 133, False: 3.25k] ------------------ 32762| 133| func = wuffs_private_impl__pixel_swizzler__prepare__bgrx( 32763| 133| p, dst_pixfmt, dst_palette, src_palette, blend); 32764| 133| break; 32765| | 32766| 101| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 101|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32766:5): [True: 101, False: 3.28k] ------------------ 32767| 101| func = wuffs_private_impl__pixel_swizzler__prepare__rgb( 32768| 101| p, dst_pixfmt, dst_palette, src_palette, blend); 32769| 101| break; 32770| | 32771| 217| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 217|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32771:5): [True: 217, False: 3.16k] ------------------ 32772| 217| func = wuffs_private_impl__pixel_swizzler__prepare__rgba_nonpremul( 32773| 217| p, dst_pixfmt, dst_palette, src_palette, blend); 32774| 217| break; 32775| | 32776| 245| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 245|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32776:5): [True: 245, False: 3.14k] ------------------ 32777| 245| func = wuffs_private_impl__pixel_swizzler__prepare__rgba_premul( 32778| 245| p, dst_pixfmt, dst_palette, src_palette, blend); 32779| 245| break; 32780| 3.38k| } 32781| | 32782| 3.38k| p->private_impl.func = func; 32783| 3.38k| p->private_impl.transparent_black_func = transparent_black_func; 32784| 3.38k| p->private_impl.dst_pixfmt_bytes_per_pixel = dst_pixfmt_bits_per_pixel / 8; 32785| 3.38k| p->private_impl.src_pixfmt_bytes_per_pixel = src_pixfmt_bits_per_pixel / 8; 32786| 3.38k| return wuffs_base__make_status( 32787| 3.38k| func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_option); ------------------ | Branch (32787:7): [True: 3.09k, False: 290] ------------------ 32788| 3.38k|} wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice: 32837| 3.09k| wuffs_base__slice_u8 src) { 32838| 3.09k| if (p && p->private_impl.func) { ------------------ | Branch (32838:7): [True: 3.09k, False: 0] | Branch (32838:12): [True: 3.09k, False: 0] ------------------ 32839| 3.09k| return (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr, 32840| 3.09k| dst_palette.len, src.ptr, src.len); 32841| 3.09k| } 32842| 0| return 0; 32843| 3.09k|} wuffs_base__pixel_swizzler__swizzle_ycck: 34295| 3.38k| wuffs_base__slice_u8 scratch_buffer_2k) { 34296| 3.38k| if (!p) { ------------------ | Branch (34296:7): [True: 0, False: 3.38k] ------------------ 34297| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 34298| 3.38k| } else if (!dst || // ------------------ | Branch (34298:14): [True: 0, False: 3.38k] ------------------ 34299| 3.38k| (x_min_incl > x_max_excl) || // ------------------ | Branch (34299:14): [True: 0, False: 3.38k] ------------------ 34300| 3.38k| (x_max_excl > 0xFFFFu) || // ------------------ | Branch (34300:14): [True: 0, False: 3.38k] ------------------ 34301| 3.38k| (y_min_incl > y_max_excl) || // ------------------ | Branch (34301:14): [True: 0, False: 3.38k] ------------------ 34302| 3.38k| (y_max_excl > 0xFFFFu) || // ------------------ | Branch (34302:14): [True: 0, False: 3.38k] ------------------ 34303| 3.38k| (4u <= ((unsigned int)h0 - 1u)) || // ------------------ | Branch (34303:14): [True: 0, False: 3.38k] ------------------ 34304| 3.38k| (4u <= ((unsigned int)h1 - 1u)) || // ------------------ | Branch (34304:14): [True: 0, False: 3.38k] ------------------ 34305| 3.38k| (4u <= ((unsigned int)h2 - 1u)) || // ------------------ | Branch (34305:14): [True: 0, False: 3.38k] ------------------ 34306| 3.38k| (4u <= ((unsigned int)v0 - 1u)) || // ------------------ | Branch (34306:14): [True: 0, False: 3.38k] ------------------ 34307| 3.38k| (4u <= ((unsigned int)v1 - 1u)) || // ------------------ | Branch (34307:14): [True: 0, False: 3.38k] ------------------ 34308| 3.38k| (4u <= ((unsigned int)v2 - 1u)) || // ------------------ | Branch (34308:14): [True: 0, False: 3.38k] ------------------ 34309| 3.38k| ((ycc_upsampling != 0) && ((x_min_incl | y_min_incl) > 0u)) || ------------------ | Branch (34309:15): [True: 1.28k, False: 2.09k] | Branch (34309:40): [True: 0, False: 1.28k] ------------------ 34310| 3.38k| (scratch_buffer_2k.len < 2048u)) { ------------------ | Branch (34310:14): [True: 0, False: 3.38k] ------------------ 34311| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34312| 0| } 34313| 3.38k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (34313:7): [True: 780, False: 2.60k] | Branch (34313:21): [True: 0, False: 2.60k] ------------------ 34314| 780| if ((4u <= ((unsigned int)h3 - 1u)) || // ------------------ | Branch (34314:9): [True: 0, False: 780] ------------------ 34315| 780| (4u <= ((unsigned int)v3 - 1u))) { ------------------ | Branch (34315:9): [True: 0, False: 780] ------------------ 34316| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34317| 0| } 34318| 780| } 34319| | 34320| 3.38k| uint32_t max_incl_h = wuffs_private_impl__u32__max_of_4(h0, h1, h2, h3); 34321| 3.38k| uint32_t max_incl_v = wuffs_private_impl__u32__max_of_4(v0, v1, v2, v3); 34322| | 34323| | // Calculate the inverse h and v ratios. 34324| | // 34325| | // It also canonicalizes (h=2 and max_incl_h=4) as equivalent to (h=1 and 34326| | // max_incl_h=2). In both cases, the inv_h value is 2. 34327| 3.38k| uint32_t inv_h0 = max_incl_h / h0; 34328| 3.38k| uint32_t inv_h1 = max_incl_h / h1; 34329| 3.38k| uint32_t inv_h2 = max_incl_h / h2; 34330| 3.38k| uint32_t inv_h3 = h3 ? (max_incl_h / h3) : 0u; ------------------ | Branch (34330:21): [True: 780, False: 2.60k] ------------------ 34331| 3.38k| uint32_t inv_v0 = max_incl_v / v0; 34332| 3.38k| uint32_t inv_v1 = max_incl_v / v1; 34333| 3.38k| uint32_t inv_v2 = max_incl_v / v2; 34334| 3.38k| uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; ------------------ | Branch (34334:21): [True: 780, False: 2.60k] ------------------ 34335| | 34336| 3.38k| if (x_min_incl != 0) { ------------------ | Branch (34336:7): [True: 2.09k, False: 1.28k] ------------------ 34337| 2.09k| if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) || ------------------ | Branch (34337:9): [True: 404, False: 1.69k] | Branch (34337:34): [True: 249, False: 1.44k] ------------------ 34338| 1.44k| (x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) { ------------------ | Branch (34338:9): [True: 125, False: 1.32k] | Branch (34338:35): [True: 160, False: 1.16k] | Branch (34338:45): [True: 9, False: 151] ------------------ 34339| 787| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34340| 787| } 34341| 2.09k| } 34342| 2.59k| if (y_min_incl != 0) { ------------------ | Branch (34342:7): [True: 1.31k, False: 1.28k] ------------------ 34343| 1.31k| if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) || ------------------ | Branch (34343:9): [True: 260, False: 1.05k] | Branch (34343:34): [True: 110, False: 941] ------------------ 34344| 941| (y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) { ------------------ | Branch (34344:9): [True: 26, False: 915] | Branch (34344:35): [True: 65, False: 850] | Branch (34344:45): [True: 13, False: 52] ------------------ 34345| 409| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34346| 409| } 34347| 1.31k| } 34348| | 34349| 2.19k| uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u; 34350| 2.19k| if (inv_h0 == 2) { ------------------ | Branch (34350:7): [True: 320, False: 1.87k] ------------------ 34351| 320| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0); 34352| 320| } 34353| 2.19k| if (inv_h1 == 2) { ------------------ | Branch (34353:7): [True: 315, False: 1.87k] ------------------ 34354| 315| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1); 34355| 315| } 34356| 2.19k| if (inv_h2 == 2) { ------------------ | Branch (34356:7): [True: 310, False: 1.88k] ------------------ 34357| 310| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2); 34358| 310| } 34359| 2.19k| if (inv_h3 == 2) { ------------------ | Branch (34359:7): [True: 50, False: 2.14k] ------------------ 34360| 50| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3); 34361| 50| } 34362| | 34363| 2.19k| uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u; 34364| 2.19k| if (inv_v0 == 2) { ------------------ | Branch (34364:7): [True: 357, False: 1.83k] ------------------ 34365| 357| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0); 34366| 357| } 34367| 2.19k| if (inv_v1 == 2) { ------------------ | Branch (34367:7): [True: 342, False: 1.84k] ------------------ 34368| 342| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1); 34369| 342| } 34370| 2.19k| if (inv_v2 == 2) { ------------------ | Branch (34370:7): [True: 185, False: 2.00k] ------------------ 34371| 185| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2); 34372| 185| } 34373| 2.19k| if (inv_v3 == 2) { ------------------ | Branch (34373:7): [True: 62, False: 2.12k] ------------------ 34374| 62| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3); 34375| 62| } 34376| | 34377| 2.19k| x_max_excl = wuffs_base__u32__min( // 34378| 2.19k| wuffs_base__pixel_config__width(&dst->pixcfg), // 34379| 2.19k| x_min_incl + wuffs_private_impl__u32__min_of_5( // 34380| 2.19k| x_max_excl - x_min_incl, // 34381| 2.19k| width0 * inv_h0, // 34382| 2.19k| width1 * inv_h1, // 34383| 2.19k| width2 * inv_h2, // 34384| 2.19k| inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF)); ------------------ | Branch (34384:24): [True: 527, False: 1.66k] ------------------ 34385| 2.19k| y_max_excl = wuffs_base__u32__min( // 34386| 2.19k| wuffs_base__pixel_config__height(&dst->pixcfg), // 34387| 2.19k| y_min_incl + wuffs_private_impl__u32__min_of_5( // 34388| 2.19k| y_max_excl - y_min_incl, // 34389| 2.19k| height0 * inv_v0, // 34390| 2.19k| height1 * inv_v1, // 34391| 2.19k| height2 * inv_v2, // 34392| 2.19k| inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF)); ------------------ | Branch (34392:24): [True: 527, False: 1.66k] ------------------ 34393| | 34394| 2.19k| if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) { ------------------ | Branch (34394:7): [True: 14, False: 2.17k] | Branch (34394:37): [True: 13, False: 2.16k] ------------------ 34395| 27| return wuffs_base__make_status(NULL); 34396| 27| } 34397| 2.16k| uint32_t width = x_max_excl - x_min_incl; 34398| 2.16k| uint32_t height = y_max_excl - y_min_incl; 34399| | 34400| 2.16k| if (((h0 * inv_h0) != max_incl_h) || // ------------------ | Branch (34400:7): [True: 0, False: 2.16k] ------------------ 34401| 2.16k| ((h1 * inv_h1) != max_incl_h) || // ------------------ | Branch (34401:7): [True: 0, False: 2.16k] ------------------ 34402| 2.16k| ((h2 * inv_h2) != max_incl_h) || // ------------------ | Branch (34402:7): [True: 0, False: 2.16k] ------------------ 34403| 2.16k| ((v0 * inv_v0) != max_incl_v) || // ------------------ | Branch (34403:7): [True: 0, False: 2.16k] ------------------ 34404| 2.16k| ((v1 * inv_v1) != max_incl_v) || // ------------------ | Branch (34404:7): [True: 0, False: 2.16k] ------------------ 34405| 2.16k| ((v2 * inv_v2) != max_incl_v) || // ------------------ | Branch (34405:7): [True: 0, False: 2.16k] ------------------ 34406| 2.16k| (src0.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34406:7): [True: 0, False: 2.16k] ------------------ 34407| 2.16k| width, height, stride0, inv_h0, inv_v0)) || 34408| 2.16k| (src1.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34408:7): [True: 0, False: 2.16k] ------------------ 34409| 2.16k| width, height, stride1, inv_h1, inv_v1)) || 34410| 2.16k| (src2.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34410:7): [True: 0, False: 2.16k] ------------------ 34411| 2.16k| width, height, stride2, inv_h2, inv_v2))) { 34412| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34413| 0| } 34414| 2.16k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (34414:7): [True: 527, False: 1.63k] | Branch (34414:21): [True: 0, False: 1.63k] ------------------ 34415| 527| if (((h3 * inv_h3) != max_incl_h) || // ------------------ | Branch (34415:9): [True: 0, False: 527] ------------------ 34416| 527| ((v3 * inv_v3) != max_incl_v) || // ------------------ | Branch (34416:9): [True: 0, False: 527] ------------------ 34417| 527| (src3.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34417:9): [True: 527, False: 0] ------------------ 34418| 527| width, height, stride3, inv_h3, inv_v3))) { 34419| 527| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34420| 527| } 34421| 527| } 34422| | 34423| 1.63k| if (wuffs_base__pixel_format__is_planar(&dst->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (34423:7): [True: 0, False: 1.63k] ------------------ 34424| | // TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's TODO. 34425| 0| return wuffs_base__make_status( 34426| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 34427| 0| } 34428| | 34429| | // ---- 34430| | 34431| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 34432| | switch (dst->pixcfg.private_impl.pixfmt.repr) { 34433| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y) 34434| | case WUFFS_BASE__PIXEL_FORMAT__Y: 34435| | break; 34436| |#endif 34437| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_YA_NONPREMUL) 34438| | case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: 34439| | break; 34440| |#endif 34441| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565) 34442| | case WUFFS_BASE__PIXEL_FORMAT__BGR_565: 34443| | break; 34444| |#endif 34445| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR) 34446| | case WUFFS_BASE__PIXEL_FORMAT__BGR: 34447| | break; 34448| |#endif 34449| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL) 34450| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: 34451| | break; 34452| |#endif 34453| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL_4X16LE) 34454| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: 34455| | break; 34456| |#endif 34457| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_PREMUL) 34458| | case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: 34459| | break; 34460| |#endif 34461| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGB) 34462| | case WUFFS_BASE__PIXEL_FORMAT__RGB: 34463| | break; 34464| |#endif 34465| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_NONPREMUL) 34466| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: 34467| | break; 34468| |#endif 34469| |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_PREMUL) 34470| | case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: 34471| | break; 34472| |#endif 34473| | default: 34474| | return wuffs_base__make_status( 34475| | wuffs_base__error__disabled_by_wuffs_config_dst_pixel_format_enable_allowlist); 34476| | } 34477| |#else // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 34478| 1.63k| switch (dst->pixcfg.private_impl.pixfmt.repr) { 34479| 143| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 143|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (34479:5): [True: 143, False: 1.49k] ------------------ 34480| 182| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 182|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (34480:5): [True: 39, False: 1.59k] ------------------ 34481| 212| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 212|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (34481:5): [True: 30, False: 1.60k] ------------------ 34482| 266| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4946| 266|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (34482:5): [True: 54, False: 1.58k] ------------------ 34483| 335| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 335|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (34483:5): [True: 69, False: 1.56k] ------------------ 34484| 335| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4959| 335|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (34484:5): [True: 0, False: 1.63k] ------------------ 34485| 365| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4960| 365|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (34485:5): [True: 30, False: 1.60k] ------------------ 34486| 503| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 503|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (34486:5): [True: 138, False: 1.49k] ------------------ 34487| 609| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 609|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (34487:5): [True: 106, False: 1.53k] ------------------ 34488| 779| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 779|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (34488:5): [True: 170, False: 1.46k] ------------------ 34489| 986| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 986|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (34489:5): [True: 207, False: 1.42k] ------------------ 34490| 1.10k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 1.10k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (34490:5): [True: 114, False: 1.52k] ------------------ 34491| 1.19k| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 1.19k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (34491:5): [True: 95, False: 1.54k] ------------------ 34492| 1.28k| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 1.28k|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (34492:5): [True: 89, False: 1.54k] ------------------ 34493| 1.47k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 1.47k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (34493:5): [True: 195, False: 1.44k] ------------------ 34494| 1.61k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 1.61k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (34494:5): [True: 137, False: 1.49k] ------------------ 34495| 1.61k| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 1.61k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (34495:5): [True: 0, False: 1.63k] ------------------ 34496| 1.61k| break; 34497| | 34498| 20| default: ------------------ | Branch (34498:5): [True: 20, False: 1.61k] ------------------ 34499| | // TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's 34500| | // TODO. 34501| 20| return wuffs_base__make_status( 34502| 20| wuffs_base__error__unsupported_pixel_swizzler_option); 34503| 1.63k| } 34504| 1.61k|#endif // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 34505| | 34506| | // ---- 34507| | 34508| 1.61k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; 34509| | 34510| 1.61k| if (ycc_model >= WUFFS_BASE__YCC_MODEL__RGB) { ------------------ | | 5257| 1.61k|#define WUFFS_BASE__YCC_MODEL__RGB 0x40 ------------------ | Branch (34510:7): [True: 359, False: 1.25k] ------------------ 34511| 359| conv3func = &wuffs_private_impl__swizzle_rgb__convert_3_general; 34512| | 34513| 1.25k| } else if (ycc_model >= WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) { ------------------ | | 5254| 1.25k|#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE 0x04 ------------------ | Branch (34513:14): [True: 0, False: 1.25k] ------------------ 34514| 0| switch (dst->pixcfg.private_impl.pixfmt.repr) { 34515| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (34515:7): [True: 0, False: 0] ------------------ 34516| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (34516:7): [True: 0, False: 0] ------------------ 34517| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (34517:7): [True: 0, False: 0] ------------------ 34518| 0| conv3func = &wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_bgrx; 34519| 0| break; 34520| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (34520:7): [True: 0, False: 0] ------------------ 34521| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (34521:7): [True: 0, False: 0] ------------------ 34522| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (34522:7): [True: 0, False: 0] ------------------ 34523| 0| conv3func = &wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_rgbx; 34524| 0| break; 34525| 0| default: ------------------ | Branch (34525:7): [True: 0, False: 0] ------------------ 34526| 0| conv3func = &wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_general; 34527| 0| break; 34528| 0| } 34529| | 34530| 1.25k| } else { 34531| 1.25k| switch (dst->pixcfg.private_impl.pixfmt.repr) { 34532| 138| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 138|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (34532:7): [True: 138, False: 1.11k] ------------------ 34533| 233| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 233|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (34533:7): [True: 95, False: 1.16k] ------------------ 34534| 311| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 311|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (34534:7): [True: 78, False: 1.17k] ------------------ 34535| 311|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 34536| 311| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (34536:13): [True: 311, False: 0] ------------------ 34537| 311| conv3func = 34538| 311| &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx_x86_avx2; 34539| 311| break; 34540| 311| } 34541| 0|#endif 34542| 0| conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx; 34543| 0| break; 34544| 168| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 168|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (34544:7): [True: 168, False: 1.08k] ------------------ 34545| 279| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 279|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (34545:7): [True: 111, False: 1.14k] ------------------ 34546| 279| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 279|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (34546:7): [True: 0, False: 1.25k] ------------------ 34547| 279|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 34548| 279| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (34548:13): [True: 279, False: 0] ------------------ 34549| 279| conv3func = 34550| 279| &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx_x86_avx2; 34551| 279| break; 34552| 279| } 34553| 0|#endif 34554| 0| conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx; 34555| 0| break; 34556| 667| default: ------------------ | Branch (34556:7): [True: 667, False: 590] ------------------ 34557| 667| conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general; 34558| 667| break; 34559| 1.25k| } 34560| 1.25k| } 34561| | 34562| 1.61k| void (*func3)(wuffs_base__pixel_buffer * dst, // 34563| 1.61k| uint32_t x_min_incl, // 34564| 1.61k| uint32_t x_max_excl, // 34565| 1.61k| uint32_t y_min_incl, // 34566| 1.61k| uint32_t y_max_excl, // 34567| 1.61k| const uint8_t* src_ptr0, // 34568| 1.61k| const uint8_t* src_ptr1, // 34569| 1.61k| const uint8_t* src_ptr2, // 34570| 1.61k| uint32_t stride0, // 34571| 1.61k| uint32_t stride1, // 34572| 1.61k| uint32_t stride2, // 34573| 1.61k| uint32_t inv_h0, // 34574| 1.61k| uint32_t inv_h1, // 34575| 1.61k| uint32_t inv_h2, // 34576| 1.61k| uint32_t inv_v0, // 34577| 1.61k| uint32_t inv_v1, // 34578| 1.61k| uint32_t inv_v2, // 34579| 1.61k| uint32_t half_width_for_2to1, // 34580| 1.61k| uint32_t half_height_for_2to1, // 34581| 1.61k| uint8_t* scratch_buffer_2k_ptr, // 34582| 1.61k| wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], 34583| 1.61k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) = 34584| 1.61k| &wuffs_private_impl__swizzle_ycc__general__box_filter; 34585| | 34586| 1.61k| void (*func4)(wuffs_base__pixel_buffer * dst, // 34587| 1.61k| uint32_t x_min_incl, // 34588| 1.61k| uint32_t x_max_excl, // 34589| 1.61k| uint32_t y_min_incl, // 34590| 1.61k| uint32_t y_max_excl, // 34591| 1.61k| const uint8_t* src_ptr0, // 34592| 1.61k| const uint8_t* src_ptr1, // 34593| 1.61k| const uint8_t* src_ptr2, // 34594| 1.61k| const uint8_t* src_ptr3, // 34595| 1.61k| uint32_t stride0, // 34596| 1.61k| uint32_t stride1, // 34597| 1.61k| uint32_t stride2, // 34598| 1.61k| uint32_t stride3, // 34599| 1.61k| uint32_t inv_h0, // 34600| 1.61k| uint32_t inv_h1, // 34601| 1.61k| uint32_t inv_h2, // 34602| 1.61k| uint32_t inv_h3, // 34603| 1.61k| uint32_t inv_v0, // 34604| 1.61k| uint32_t inv_v1, // 34605| 1.61k| uint32_t inv_v2, // 34606| 1.61k| uint32_t inv_v3, // 34607| 1.61k| uint32_t half_width_for_2to1, // 34608| 1.61k| uint32_t half_height_for_2to1, // 34609| 1.61k| uint8_t* scratch_buffer_2k_ptr, // 34610| 1.61k| wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], 34611| 1.61k| wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) = 34612| 1.61k| &wuffs_private_impl__swizzle_ycck__general__box_filter; 34613| | 34614| 1.61k| wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4]; 34615| 1.61k| memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs, 34616| 1.61k| sizeof upfuncs); 34617| | 34618| 1.61k| if ((ycc_upsampling != 0) && ------------------ | Branch (34618:7): [True: 808, False: 808] ------------------ 34619| 808| (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) || ------------------ | Branch (34619:8): [True: 207, False: 601] ------------------ 34620| 601| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) || ------------------ | Branch (34620:8): [True: 99, False: 502] ------------------ 34621| 502| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) || ------------------ | Branch (34621:8): [True: 67, False: 435] ------------------ 34622| 435| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h3, inv_v3))) { ------------------ | Branch (34622:8): [True: 0, False: 435] ------------------ 34623| 373| func3 = &wuffs_private_impl__swizzle_ycc__general__triangle_filter; 34624| 373| func4 = &wuffs_private_impl__swizzle_ycck__general__triangle_filter; 34625| | 34626| 373| upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle; 34627| 373| upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle; 34628| 373| upfuncs[1][1] = 34629| 373| (ycc_upsampling == 1) ------------------ | Branch (34629:9): [True: 373, False: 0] ------------------ 34630| 373| ? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg 34631| 373| : wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp; 34632| | 34633| 373|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 34634| |#if defined(__GNUC__) && !defined(__clang__) 34635| | // Don't use our AVX2 implementation for GCC (but do use it for clang). For 34636| | // some unknown reason, GCC performs noticably better on the non-SIMD 34637| | // version. Possibly because GCC's auto-vectorizer is smarter (just with 34638| | // SSE2, not AVX2) than our hand-written code, but that's just a guess. 34639| | // 34640| | // See commits 51bc60ef9298cb2efc1b29a9681191f66d49820d and 34641| | // cd769a0cdf1b5affee13f6089b995f3d39569cb4 for benchmark numbers. 34642| | // 34643| | // See also https://godbolt.org/z/MbhbPGEz4 for Debian Bullseye's clang 11 34644| | // versus gcc 10, where only gcc auto-vectorizes, although later clang 34645| | // versions will also auto-vectorize. 34646| |#else 34647| 373| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (34647:9): [True: 373, False: 0] ------------------ 34648| 373| upfuncs[1][1] = 34649| 373| (ycc_upsampling == 1) ------------------ | Branch (34649:11): [True: 373, False: 0] ------------------ 34650| 373| ? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2 34651| 373| : wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp_x86_avx2; 34652| 373| } 34653| 373|#endif 34654| 373|#endif 34655| 373| } 34656| | 34657| 1.61k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (34657:7): [True: 0, False: 1.61k] | Branch (34657:21): [True: 0, False: 1.61k] ------------------ 34658| 0| wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = NULL; 34659| 0| switch (ycc_model) { 34660| 0| case WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE: ------------------ | | 5253| 0|#define WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE 0x00 ------------------ | Branch (34660:7): [True: 0, False: 0] ------------------ 34661| 0| conv4func = &wuffs_private_impl__swizzle_ycck__convert_4_general; 34662| 0| break; 34663| 0| case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC: ------------------ | | 5255| 0|#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC 0x06 ------------------ | Branch (34663:7): [True: 0, False: 0] ------------------ 34664| 0| if (dst->pixcfg.private_impl.pixfmt.repr == ------------------ | Branch (34664:13): [True: 0, False: 0] ------------------ 34665| 0| WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) { ------------------ | | 4966| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ 34666| 0| conv4func = 34667| 0| &wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_bgra_premul; 34668| 0| } else { 34669| 0| conv4func = 34670| 0| &wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_general; 34671| 0| } 34672| 0| break; 34673| 0| case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER: ------------------ | | 5256| 0|#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER 0x07 ------------------ | Branch (34673:7): [True: 0, False: 0] ------------------ 34674| 0| if (dst->pixcfg.private_impl.pixfmt.repr == ------------------ | Branch (34674:13): [True: 0, False: 0] ------------------ 34675| 0| WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) { ------------------ | | 4966| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ 34676| 0| conv4func = 34677| 0| &wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_bgra_premul; 34678| 0| } else { 34679| 0| conv4func = 34680| 0| &wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_general; 34681| 0| } 34682| 0| break; 34683| 0| case WUFFS_BASE__YCC_MODEL__CMY: ------------------ | | 5258| 0|#define WUFFS_BASE__YCC_MODEL__CMY 0x80 ------------------ | Branch (34683:7): [True: 0, False: 0] ------------------ 34684| 0| conv4func = &wuffs_private_impl__swizzle_cmyk__convert_4_general; 34685| 0| break; 34686| 0| default: ------------------ | Branch (34686:7): [True: 0, False: 0] ------------------ 34687| 0| return wuffs_base__make_status( 34688| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 34689| 0| } 34690| | 34691| 0| (*func4)( // 34692| 0| dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // 34693| 0| src0.ptr, src1.ptr, src2.ptr, src3.ptr, // 34694| 0| stride0, stride1, stride2, stride3, // 34695| 0| inv_h0, inv_h1, inv_h2, inv_h3, // 34696| 0| inv_v0, inv_v1, inv_v2, inv_v3, // 34697| 0| half_width_for_2to1, half_height_for_2to1, // 34698| 0| scratch_buffer_2k.ptr, &upfuncs, conv4func); 34699| | 34700| 1.61k| } else { 34701| 1.61k| (*func3)( // 34702| 1.61k| dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // 34703| 1.61k| src0.ptr, src1.ptr, src2.ptr, // 34704| 1.61k| stride0, stride1, stride2, // 34705| 1.61k| inv_h0, inv_h1, inv_h2, // 34706| 1.61k| inv_v0, inv_v1, inv_v2, // 34707| 1.61k| half_width_for_2to1, half_height_for_2to1, // 34708| 1.61k| scratch_buffer_2k.ptr, &upfuncs, conv3func); 34709| 1.61k| } 34710| | 34711| 1.61k| return wuffs_base__make_status(NULL); 34712| 1.61k|} pixel_swizzler_fuzzer.c:wuffs_base__make_status: 624| 497k|wuffs_base__make_status(const char* repr) { 625| 497k| wuffs_base__status z; 626| 497k| z.repr = repr; 627| 497k| return z; 628| 497k|} pixel_swizzler_fuzzer.c:wuffs_base__u32__min: 1057| 30.6k|wuffs_base__u32__min(uint32_t x, uint32_t y) { 1058| 30.6k| return x < y ? x : y; ------------------ | Branch (1058:10): [True: 16.2k, False: 14.3k] ------------------ 1059| 30.6k|} pixel_swizzler_fuzzer.c:wuffs_base__make_slice_u8: 1721| 79.1k|wuffs_base__make_slice_u8(uint8_t* ptr, size_t len) { 1722| 79.1k| wuffs_base__slice_u8 ret; 1723| 79.1k| ret.ptr = ptr; 1724| 79.1k| ret.len = len; 1725| 79.1k| return ret; 1726| 79.1k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u32le__no_bounds_check: 1441| 60.2k|wuffs_base__peek_u32le__no_bounds_check(const uint8_t* p) { 1442| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1443| | uint32_t x; 1444| | memcpy(&x, p, 4); 1445| | return x; 1446| |#else 1447| 60.2k| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | 1448| 60.2k| ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); 1449| 60.2k|#endif 1450| 60.2k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u24le__no_bounds_check: 1423| 1.06k|wuffs_base__peek_u24le__no_bounds_check(const uint8_t* p) { 1424| 1.06k| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | 1425| 1.06k| ((uint32_t)(p[2]) << 16); 1426| 1.06k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u16le__no_bounds_check: 1406| 10.0k|wuffs_base__peek_u16le__no_bounds_check(const uint8_t* p) { 1407| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1408| | uint16_t x; 1409| | memcpy(&x, p, 2); 1410| | return x; 1411| |#else 1412| 10.0k| return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); 1413| 10.0k|#endif 1414| 10.0k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u24be__no_bounds_check: 1417| 701|wuffs_base__peek_u24be__no_bounds_check(const uint8_t* p) { 1418| 701| return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) | 1419| 701| ((uint32_t)(p[2]) << 0); 1420| 701|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u16be__no_bounds_check: 1395| 77|wuffs_base__peek_u16be__no_bounds_check(const uint8_t* p) { 1396| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1397| | uint16_t x; 1398| | memcpy(&x, p, 2); 1399| | return _byteswap_ushort(x); 1400| |#else 1401| 77| return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); 1402| 77|#endif 1403| 77|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_planar: 5031| 495k|wuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) { 5032| 495k| return ((f->repr >> 16) & 0x03) != 0; 5033| 495k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul: 4485| 14.3k| uint32_t argb_nonpremul) { 4486| | // Multiplying by 0x101 (twice, once for alpha and once for color) converts 4487| | // from 8-bit to 16-bit color. Shifting right by 8 undoes that. 4488| | // 4489| | // Working in the higher bit depth can produce slightly different (and 4490| | // arguably slightly more accurate) results. For example, given 8-bit blue 4491| | // and alpha of 0x80 and 0x81: 4492| | // 4493| | // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40 4494| | // - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41 4495| 14.3k| uint32_t a = 0xFF & (argb_nonpremul >> 24); 4496| 14.3k| uint32_t a16 = a * (0x101 * 0x101); 4497| | 4498| 14.3k| uint32_t r = 0xFF & (argb_nonpremul >> 16); 4499| 14.3k| r = ((r * a16) / 0xFFFF) >> 8; 4500| 14.3k| uint32_t g = 0xFF & (argb_nonpremul >> 8); 4501| 14.3k| g = ((g * a16) / 0xFFFF) >> 8; 4502| 14.3k| uint32_t b = 0xFF & (argb_nonpremul >> 0); 4503| 14.3k| b = ((b * a16) / 0xFFFF) >> 8; 4504| | 4505| 14.3k| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4506| 14.3k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul: 4417| 2.56k|wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(uint16_t rgb_565) { 4418| 2.56k| uint32_t b5 = 0x1F & (rgb_565 >> 0); 4419| 2.56k| uint32_t b = (b5 << 3) | (b5 >> 2); 4420| 2.56k| uint32_t g6 = 0x3F & (rgb_565 >> 5); 4421| 2.56k| uint32_t g = (g6 << 2) | (g6 >> 4); 4422| 2.56k| uint32_t r5 = 0x1F & (rgb_565 >> 11); 4423| 2.56k| uint32_t r = (r5 << 3) | (r5 >> 2); 4424| 2.56k| return 0xFF000000 | (r << 16) | (g << 8) | (b << 0); 4425| 2.56k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul: 4535| 556| uint64_t argb_nonpremul) { 4536| 556| uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); 4537| | 4538| 556| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); 4539| 556| r16 = (r16 * a16) / 0xFFFF; 4540| 556| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); 4541| 556| g16 = (g16 * a16) / 0xFFFF; 4542| 556| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); 4543| 556| b16 = (b16 * a16) / 0xFFFF; 4544| | 4545| 556| return ((a16 >> 8) << 24) | ((r16 >> 8) << 16) | ((g16 >> 8) << 8) | 4546| 556| ((b16 >> 8) << 0); 4547| 556|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u64le__no_bounds_check: 1511| 5.99k|wuffs_base__peek_u64le__no_bounds_check(const uint8_t* p) { 1512| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) 1513| | uint64_t x; 1514| | memcpy(&x, p, 8); 1515| | return x; 1516| |#else 1517| 5.99k| return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | 1518| 5.99k| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | 1519| 5.99k| ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | 1520| 5.99k| ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56); 1521| 5.99k|#endif 1522| 5.99k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64__as__color_u32: 4660| 2.43k|wuffs_base__color_u64__as__color_u32(uint64_t c) { 4661| 2.43k| uint32_t a = ((uint32_t)(0xFF & (c >> 56))); 4662| 2.43k| uint32_t r = ((uint32_t)(0xFF & (c >> 40))); 4663| 2.43k| uint32_t g = ((uint32_t)(0xFF & (c >> 24))); 4664| 2.43k| uint32_t b = ((uint32_t)(0xFF & (c >> 8))); 4665| 2.43k| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4666| 2.43k|} pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u32_argb_abgr: 4829| 70.6k|wuffs_base__color_swap_u32_argb_abgr(uint32_t u) { 4830| 70.6k| uint32_t o = u & 0xFF00FF00ul; 4831| 70.6k| uint32_t r = u & 0x00FF0000ul; 4832| 70.6k| uint32_t b = u & 0x000000FFul; 4833| 70.6k| return o | (r >> 16) | (b << 16); 4834| 70.6k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u32le__no_bounds_check: 1578| 244k|wuffs_base__poke_u32le__no_bounds_check(uint8_t* p, uint32_t x) { 1579| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \ 1580| | (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)) 1581| | // This seems to perform better on gcc 10 (but not clang 9). Clang also 1582| | // defines "__GNUC__". 1583| | memcpy(p, &x, 4); 1584| |#else 1585| 244k| p[0] = (uint8_t)(x >> 0); 1586| 244k| p[1] = (uint8_t)(x >> 8); 1587| 244k| p[2] = (uint8_t)(x >> 16); 1588| 244k| p[3] = (uint8_t)(x >> 24); 1589| 244k|#endif 1590| 244k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u8__no_bounds_check: 1532| 115k|wuffs_base__poke_u8__no_bounds_check(uint8_t* p, uint8_t x) { 1533| 115k| p[0] = x; 1534| 115k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u8_gray: 4429| 91.4k| wuffs_base__color_u32_argb_premul c) { 4430| | // Work in 16-bit color. 4431| 91.4k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 4432| 91.4k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 4433| 91.4k| uint32_t cb = 0x101 * (0xFF & (c >> 0)); 4434| | 4435| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4436| | // as those given by the JFIF specification. 4437| | // 4438| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We 4439| | // shift by 24, not just by 16, because the return value is 8-bit color, not 4440| | // 16-bit color. 4441| 91.4k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4442| 91.4k| return (uint8_t)(weighted_average >> 24); 4443| 91.4k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u16le__no_bounds_check: 1543| 111k|wuffs_base__poke_u16le__no_bounds_check(uint8_t* p, uint16_t x) { 1544| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \ 1545| | (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)) 1546| | // This seems to perform better on gcc 10 (but not clang 9). Clang also 1547| | // defines "__GNUC__". 1548| | memcpy(p, &x, 2); 1549| |#else 1550| 111k| p[0] = (uint8_t)(x >> 0); 1551| 111k| p[1] = (uint8_t)(x >> 8); 1552| 111k|#endif 1553| 111k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_gray: 4467| 31.8k| wuffs_base__color_u32_argb_premul c) { 4468| | // Work in 16-bit color. 4469| 31.8k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 4470| 31.8k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 4471| 31.8k| uint32_t cb = 0x101 * (0xFF & (c >> 0)); 4472| | 4473| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4474| | // as those given by the JFIF specification. 4475| | // 4476| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). 4477| 31.8k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4478| 31.8k| return (uint16_t)(weighted_average >> 16); 4479| 31.8k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u16be__no_bounds_check: 1537| 12.3k|wuffs_base__poke_u16be__no_bounds_check(uint8_t* p, uint16_t x) { 1538| 12.3k| p[0] = (uint8_t)(x >> 8); 1539| 12.3k| p[1] = (uint8_t)(x >> 0); 1540| 12.3k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul: 4447| 22.5k| wuffs_base__color_u32_argb_premul c) { 4448| 22.5k| uint32_t a = 0xFF & (c >> 24); 4449| 22.5k| if (a == 0) { ------------------ | Branch (4449:7): [True: 0, False: 22.5k] ------------------ 4450| 0| return 0; 4451| 0| } 4452| 22.5k| uint32_t a16 = a * 0x101; 4453| | 4454| 22.5k| uint32_t cr = 0xFF & (c >> 16); 4455| 22.5k| cr = (cr * (0x101 * 0xFFFF)) / a16; 4456| 22.5k| uint32_t cg = 0xFF & (c >> 8); 4457| 22.5k| cg = (cg * (0x101 * 0xFFFF)) / a16; 4458| 22.5k| uint32_t cb = 0xFF & (c >> 0); 4459| 22.5k| cb = (cb * (0x101 * 0xFFFF)) / a16; 4460| | 4461| 22.5k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4462| 22.5k| return (uint16_t)((a16 & 0xFF00) | (weighted_average >> 24)); 4463| 22.5k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__palette: 6048| 45.0k|wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) { 6049| 45.0k| if (pb && ------------------ | Branch (6049:7): [True: 45.0k, False: 0] ------------------ 6050| 45.0k| wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (6050:7): [True: 45.0k, False: 0] ------------------ 6051| 45.0k| wuffs_base__table_u8* tab = 6052| 45.0k| &pb->private_impl 6053| 45.0k| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; ------------------ | | 4897| 45.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3 ------------------ 6054| 45.0k| if ((tab->width == ------------------ | Branch (6054:9): [True: 45.0k, False: 0] ------------------ 6055| 45.0k| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) && ------------------ | | 4900| 45.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6056| 45.0k| (tab->height == 1)) { ------------------ | Branch (6056:9): [True: 45.0k, False: 0] ------------------ 6057| 45.0k| return wuffs_base__make_slice_u8( 6058| 45.0k| tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH); ------------------ | | 4900| 45.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6059| 45.0k| } 6060| 45.0k| } 6061| 0| return wuffs_base__empty_slice_u8(); 6062| 45.0k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_indexed: 5021| 51.8k|wuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) { 5022| 51.8k| return ((f->repr >> 18) & 0x01) != 0; 5023| 51.8k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565: 4409| 61.6k| wuffs_base__color_u32_argb_premul c) { 4410| 61.6k| uint32_t r5 = 0xF800 & (c >> 8); 4411| 61.6k| uint32_t g6 = 0x07E0 & (c >> 5); 4412| 61.6k| uint32_t b5 = 0x001F & (c >> 3); 4413| 61.6k| return (uint16_t)(r5 | g6 | b5); 4414| 61.6k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u24le__no_bounds_check: 1563| 94.1k|wuffs_base__poke_u24le__no_bounds_check(uint8_t* p, uint32_t x) { 1564| 94.1k| p[0] = (uint8_t)(x >> 0); 1565| 94.1k| p[1] = (uint8_t)(x >> 8); 1566| 94.1k| p[2] = (uint8_t)(x >> 16); 1567| 94.1k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul: 4512| 33.3k| wuffs_base__color_u32_argb_premul c) { 4513| 33.3k| uint32_t a = 0xFF & (c >> 24); 4514| 33.3k| if (a == 0xFF) { ------------------ | Branch (4514:7): [True: 32.4k, False: 931] ------------------ 4515| 32.4k| return c; 4516| 32.4k| } else if (a == 0) { ------------------ | Branch (4516:14): [True: 227, False: 704] ------------------ 4517| 227| return 0; 4518| 227| } 4519| 704| uint32_t a16 = a * 0x101; 4520| | 4521| 704| uint32_t r = 0xFF & (c >> 16); 4522| 704| r = ((r * (0x101 * 0xFFFF)) / a16) >> 8; 4523| 704| uint32_t g = 0xFF & (c >> 8); 4524| 704| g = ((g * (0x101 * 0xFFFF)) / a16) >> 8; 4525| 704| uint32_t b = 0xFF & (c >> 0); 4526| 704| b = ((b * (0x101 * 0xFFFF)) / a16) >> 8; 4527| | 4528| 704| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4529| 33.3k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u64le__no_bounds_check: 1665| 94.3k|wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) { 1666| |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \ 1667| | (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)) 1668| | // This seems to perform better on gcc 10 (but not clang 9). Clang also 1669| | // defines "__GNUC__". 1670| | memcpy(p, &x, 8); 1671| |#else 1672| 94.3k| p[0] = (uint8_t)(x >> 0); 1673| 94.3k| p[1] = (uint8_t)(x >> 8); 1674| 94.3k| p[2] = (uint8_t)(x >> 16); 1675| 94.3k| p[3] = (uint8_t)(x >> 24); 1676| 94.3k| p[4] = (uint8_t)(x >> 32); 1677| 94.3k| p[5] = (uint8_t)(x >> 40); 1678| 94.3k| p[6] = (uint8_t)(x >> 48); 1679| 94.3k| p[7] = (uint8_t)(x >> 56); 1680| 94.3k|#endif 1681| 94.3k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul: 4553| 90.9k| wuffs_base__color_u32_argb_premul c) { 4554| 90.9k| uint32_t a = 0xFF & (c >> 24); 4555| 90.9k| if (a == 0xFF) { ------------------ | Branch (4555:7): [True: 90.9k, False: 0] ------------------ 4556| 90.9k| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); 4557| 90.9k| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); 4558| 90.9k| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); 4559| 90.9k| return 0xFFFF000000000000u | (r16 << 32) | (g16 << 16) | (b16 << 0); 4560| 90.9k| } else if (a == 0) { ------------------ | Branch (4560:14): [True: 0, False: 0] ------------------ 4561| 0| return 0; 4562| 0| } 4563| 0| uint64_t a16 = a * 0x101; 4564| | 4565| 0| uint64_t r = 0xFF & (c >> 16); 4566| 0| uint64_t r16 = (r * (0x101 * 0xFFFF)) / a16; 4567| 0| uint64_t g = 0xFF & (c >> 8); 4568| 0| uint64_t g16 = (g * (0x101 * 0xFFFF)) / a16; 4569| 0| uint64_t b = 0xFF & (c >> 0); 4570| 0| uint64_t b16 = (b * (0x101 * 0xFFFF)) / a16; 4571| | 4572| 0| return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); 4573| 90.9k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32__as__color_u64: 4651| 3.28k|wuffs_base__color_u32__as__color_u64(uint32_t c) { 4652| 3.28k| uint64_t a16 = 0x101 * (0xFF & (c >> 24)); 4653| 3.28k| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); 4654| 3.28k| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); 4655| 3.28k| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); 4656| 3.28k| return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); 4657| 3.28k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__bits_per_pixel: 4994| 13.5k|wuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) { 4995| 13.5k| if (((f->repr >> 16) & 0x03) != 0) { ------------------ | Branch (4995:7): [True: 0, False: 13.5k] ------------------ 4996| 0| return 0; 4997| 0| } 4998| 13.5k| return wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 4999| 13.5k| (f->repr >> 0)] + 5000| 13.5k| wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 5001| 13.5k| (f->repr >> 4)] + 5002| 13.5k| wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 5003| 13.5k| (f->repr >> 8)] + 5004| 13.5k| wuffs_private_impl__pixel_format__bits_per_channel[0x0F & 5005| 13.5k| (f->repr >> 12)]; 5006| 13.5k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y: 31166| 141| wuffs_base__pixel_blend blend) { 31167| 141| switch (dst_pixfmt.repr) { ------------------ | Branch (31167:11): [True: 126, False: 15] ------------------ 31168| 20| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31168:5): [True: 20, False: 121] ------------------ 31169| 20| return wuffs_private_impl__swizzle_copy_1_1; 31170| | 31171| 15| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31171:5): [True: 15, False: 126] ------------------ 31172| 15| return wuffs_private_impl__swizzle_bgr_565__y; 31173| | 31174| 13| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31174:5): [True: 13, False: 128] ------------------ 31175| 19| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 19|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31175:5): [True: 6, False: 135] ------------------ 31176| 19| return wuffs_private_impl__swizzle_xxx__y; 31177| | 31178| 7| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31178:5): [True: 7, False: 134] ------------------ 31179| 11| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31179:5): [True: 4, False: 137] ------------------ 31180| 11| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31180:5): [True: 0, False: 141] ------------------ 31181| 25| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31181:5): [True: 14, False: 127] ------------------ 31182| 36| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 36|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31182:5): [True: 11, False: 130] ------------------ 31183| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31183:5): [True: 13, False: 128] ------------------ 31184| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31184:5): [True: 0, False: 141] ------------------ 31185| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31185:5): [True: 0, False: 141] ------------------ 31186| 49|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31187| 49| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31187:11): [True: 49, False: 0] ------------------ 31188| 49| return wuffs_private_impl__swizzle_xxxx__y__x86_sse42; 31189| 49| } 31190| 0|#endif 31191| 0| return wuffs_private_impl__swizzle_xxxx__y; 31192| | 31193| 20| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31193:5): [True: 20, False: 121] ------------------ 31194| 23| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 23|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31194:5): [True: 3, False: 138] ------------------ 31195| 23| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31195:5): [True: 0, False: 141] ------------------ 31196| 23| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4975| 23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (31196:5): [True: 0, False: 141] ------------------ 31197| 23| return wuffs_private_impl__swizzle_xxxxxxxx__y; 31198| 141| } 31199| 15| return NULL; 31200| 141|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_1_1: 25929| 36| size_t src_len) { 25930| 36| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (25930:16): [True: 16, False: 20] ------------------ 25931| 36| if (len > 0) { ------------------ | Branch (25931:7): [True: 12, False: 24] ------------------ 25932| 12| memmove(dst_ptr, src_ptr, len); 25933| 12| } 25934| 36| return len; 25935| 36|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y: 26627| 15| size_t src_len) { 26628| 15| size_t dst_len2 = dst_len / 2; 26629| 15| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26629:16): [True: 7, False: 8] ------------------ 26630| 15| uint8_t* d = dst_ptr; 26631| 15| const uint8_t* s = src_ptr; 26632| 15| size_t n = len; 26633| | 26634| | // TODO: unroll. 26635| | 26636| 463| while (n >= 1) { ------------------ | Branch (26636:10): [True: 448, False: 15] ------------------ 26637| 448| uint32_t y5 = (uint32_t)(s[0] >> 3); 26638| 448| uint32_t y6 = (uint32_t)(s[0] >> 2); 26639| 448| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 26640| 448| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26641| | 26642| 448| s += 1 * 1; 26643| 448| d += 1 * 2; 26644| 448| n -= 1; 26645| 448| } 26646| | 26647| 15| return len; 26648| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y: 29807| 19| size_t src_len) { 29808| 19| size_t dst_len3 = dst_len / 3; 29809| 19| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29809:16): [True: 12, False: 7] ------------------ 29810| 19| uint8_t* d = dst_ptr; 29811| 19| const uint8_t* s = src_ptr; 29812| 19| size_t n = len; 29813| | 29814| | // TODO: unroll. 29815| | 29816| 278| while (n >= 1) { ------------------ | Branch (29816:10): [True: 259, False: 19] ------------------ 29817| 259| uint8_t s0 = s[0]; 29818| 259| d[0] = s0; 29819| 259| d[1] = s0; 29820| 259| d[2] = s0; 29821| | 29822| 259| s += 1 * 1; 29823| 259| d += 1 * 3; 29824| 259| n -= 1; 29825| 259| } 29826| | 29827| 19| return len; 29828| 19|} pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_sse42: 375| 151|wuffs_base__cpu_arch__have_x86_sse42(void) { 376| |#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) 377| | return true; 378| |#else 379| 151|#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| 151| const unsigned int sse42_ecx1 = 0x00900002; 385| | 386| | // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). 387| 151|#if defined(__GNUC__) 388| 151| unsigned int eax1 = 0; 389| 151| unsigned int ebx1 = 0; 390| 151| unsigned int ecx1 = 0; 391| 151| unsigned int edx1 = 0; 392| 151| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && ------------------ | Branch (392:7): [True: 151, False: 0] ------------------ 393| 151| ((ecx1 & sse42_ecx1) == sse42_ecx1)) { ------------------ | Branch (393:7): [True: 151, False: 0] ------------------ 394| 151| return true; 395| 151| } 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| 151|#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) 408| 151|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y__x86_sse42: 30077| 49| size_t src_len) { 30078| 49| size_t dst_len4 = dst_len / 4; 30079| 49| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (30079:16): [True: 33, False: 16] ------------------ 30080| 49| uint8_t* d = dst_ptr; 30081| 49| const uint8_t* s = src_ptr; 30082| 49| size_t n = len; 30083| | 30084| 49| __m128i shuffle = _mm_set_epi8(+0x03, +0x03, +0x03, +0x03, // 30085| 49| +0x02, +0x02, +0x02, +0x02, // 30086| 49| +0x01, +0x01, +0x01, +0x01, // 30087| 49| +0x00, +0x00, +0x00, +0x00); 30088| 49| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 30089| 49| -0x01, +0x00, +0x00, +0x00, // 30090| 49| -0x01, +0x00, +0x00, +0x00, // 30091| 49| -0x01, +0x00, +0x00, +0x00); 30092| | 30093| 207| while (n >= 4) { ------------------ | Branch (30093:10): [True: 158, False: 49] ------------------ 30094| 158| __m128i x; 30095| 158| x = _mm_cvtsi32_si128((int)(wuffs_base__peek_u32le__no_bounds_check(s))); 30096| 158| x = _mm_shuffle_epi8(x, shuffle); 30097| 158| x = _mm_or_si128(x, or_ff); 30098| 158| _mm_storeu_si128((__m128i*)(void*)d, x); 30099| | 30100| 158| s += 4 * 1; 30101| 158| d += 4 * 4; 30102| 158| n -= 4; 30103| 158| } 30104| | 30105| 87| while (n >= 1) { ------------------ | Branch (30105:10): [True: 38, False: 49] ------------------ 30106| 38| wuffs_base__poke_u32le__no_bounds_check( 30107| 38| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); 30108| | 30109| 38| s += 1 * 1; 30110| 38| d += 1 * 4; 30111| 38| n -= 1; 30112| 38| } 30113| | 30114| 49| return len; 30115| 49|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y: 30269| 23| size_t src_len) { 30270| 23| size_t dst_len8 = dst_len / 8; 30271| 23| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (30271:16): [True: 15, False: 8] ------------------ 30272| 23| uint8_t* d = dst_ptr; 30273| 23| const uint8_t* s = src_ptr; 30274| 23| size_t n = len; 30275| | 30276| 256| while (n >= 1) { ------------------ | Branch (30276:10): [True: 233, False: 23] ------------------ 30277| 233| wuffs_base__poke_u64le__no_bounds_check( 30278| 233| d + (0 * 8), 0xFFFF000000000000 | (0x010101010101 * (uint64_t)s[0])); 30279| | 30280| 233| s += 1 * 1; 30281| 233| d += 1 * 8; 30282| 233| n -= 1; 30283| 233| } 30284| | 30285| 23| return len; 30286| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16be: 31208| 123| wuffs_base__pixel_blend blend) { 31209| 123| switch (dst_pixfmt.repr) { ------------------ | Branch (31209:11): [True: 111, False: 12] ------------------ 31210| 21| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 21|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31210:5): [True: 21, False: 102] ------------------ 31211| 21| return wuffs_private_impl__swizzle_y__y_16be; 31212| | 31213| 4| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 4|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (31213:5): [True: 4, False: 119] ------------------ 31214| 4| return wuffs_private_impl__swizzle_y_16le__y_16be; 31215| | 31216| 4| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 4|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (31216:5): [True: 4, False: 119] ------------------ 31217| 4| return wuffs_private_impl__swizzle_copy_2_2; 31218| | 31219| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31219:5): [True: 19, False: 104] ------------------ 31220| 19| return wuffs_private_impl__swizzle_bgr_565__y_16be; 31221| | 31222| 2| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 2|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31222:5): [True: 2, False: 121] ------------------ 31223| 11| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31223:5): [True: 9, False: 114] ------------------ 31224| 11| return wuffs_private_impl__swizzle_xxx__y_16be; 31225| | 31226| 10| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31226:5): [True: 10, False: 113] ------------------ 31227| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31227:5): [True: 8, False: 115] ------------------ 31228| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31228:5): [True: 0, False: 123] ------------------ 31229| 30| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 30|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31229:5): [True: 12, False: 111] ------------------ 31230| 39| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 39|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31230:5): [True: 9, False: 114] ------------------ 31231| 43| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31231:5): [True: 4, False: 119] ------------------ 31232| 43| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31232:5): [True: 0, False: 123] ------------------ 31233| 43| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 43|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31233:5): [True: 0, False: 123] ------------------ 31234| 43| return wuffs_private_impl__swizzle_xxxx__y_16be; 31235| | 31236| 5| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31236:5): [True: 5, False: 118] ------------------ 31237| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31237:5): [True: 4, False: 119] ------------------ 31238| 9| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 9|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31238:5): [True: 0, False: 123] ------------------ 31239| 9| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4975| 9|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (31239:5): [True: 0, False: 123] ------------------ 31240| 9| return wuffs_private_impl__swizzle_xxxxxxxx__y_16be; 31241| 123| } 31242| 12| return NULL; 31243| 123|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__y_16be: 30863| 21| size_t src_len) { 30864| 21| size_t src_len2 = src_len / 2; 30865| 21| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30865:16): [True: 3, False: 18] ------------------ 30866| 21| uint8_t* d = dst_ptr; 30867| 21| const uint8_t* s = src_ptr; 30868| 21| size_t n = len; 30869| | 30870| | // TODO: unroll. 30871| | 30872| 1.04k| while (n >= 1) { ------------------ | Branch (30872:10): [True: 1.02k, False: 21] ------------------ 30873| 1.02k| d[0] = s[0]; 30874| | 30875| 1.02k| s += 1 * 2; 30876| 1.02k| d += 1 * 1; 30877| 1.02k| n -= 1; 30878| 1.02k| } 30879| | 30880| 21| return len; 30881| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y_16le__y_16be: 31071| 22| size_t src_len) { 31072| 22| size_t dst_len2 = dst_len / 2; 31073| 22| size_t src_len2 = src_len / 2; 31074| 22| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (31074:16): [True: 3, False: 19] ------------------ 31075| 22| uint8_t* d = dst_ptr; 31076| 22| const uint8_t* s = src_ptr; 31077| 22| size_t n = len; 31078| | 31079| 795| while (n >= 1) { ------------------ | Branch (31079:10): [True: 773, False: 22] ------------------ 31080| 773| uint8_t s0 = s[0]; 31081| 773| uint8_t s1 = s[1]; 31082| 773| d[0] = s1; 31083| 773| d[1] = s0; 31084| | 31085| 773| s += 1 * 2; 31086| 773| d += 1 * 2; 31087| 773| n -= 1; 31088| 773| } 31089| | 31090| 22| return len; 31091| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_2_2: 25943| 18| size_t src_len) { 25944| 18| size_t dst_len2 = dst_len / 2; 25945| 18| size_t src_len2 = src_len / 2; 25946| 18| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (25946:16): [True: 2, False: 16] ------------------ 25947| 18| if (len > 0) { ------------------ | Branch (25947:7): [True: 13, False: 5] ------------------ 25948| 13| memmove(dst_ptr, src_ptr, len * 2); 25949| 13| } 25950| 18| return len; 25951| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16be: 26656| 19| size_t src_len) { 26657| 19| size_t dst_len2 = dst_len / 2; 26658| 19| size_t src_len2 = src_len / 2; 26659| 19| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26659:16): [True: 5, False: 14] ------------------ 26660| 19| uint8_t* d = dst_ptr; 26661| 19| const uint8_t* s = src_ptr; 26662| 19| size_t n = len; 26663| | 26664| | // TODO: unroll. 26665| | 26666| 752| while (n >= 1) { ------------------ | Branch (26666:10): [True: 733, False: 19] ------------------ 26667| 733| uint32_t y5 = (uint32_t)(s[0] >> 3); 26668| 733| uint32_t y6 = (uint32_t)(s[0] >> 2); 26669| 733| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 26670| 733| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26671| | 26672| 733| s += 1 * 2; 26673| 733| d += 1 * 2; 26674| 733| n -= 1; 26675| 733| } 26676| | 26677| 19| return len; 26678| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16be: 29836| 11| size_t src_len) { 29837| 11| size_t dst_len3 = dst_len / 3; 29838| 11| size_t src_len2 = src_len / 2; 29839| 11| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29839:16): [True: 4, False: 7] ------------------ 29840| 11| uint8_t* d = dst_ptr; 29841| 11| const uint8_t* s = src_ptr; 29842| 11| size_t n = len; 29843| | 29844| | // TODO: unroll. 29845| | 29846| 177| while (n >= 1) { ------------------ | Branch (29846:10): [True: 166, False: 11] ------------------ 29847| 166| uint8_t s0 = s[0]; 29848| 166| d[0] = s0; 29849| 166| d[1] = s0; 29850| 166| d[2] = s0; 29851| | 29852| 166| s += 1 * 2; 29853| 166| d += 1 * 3; 29854| 166| n -= 1; 29855| 166| } 29856| | 29857| 11| return len; 29858| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y_16be: 30150| 43| size_t src_len) { 30151| 43| size_t dst_len4 = dst_len / 4; 30152| 43| size_t src_len2 = src_len / 2; 30153| 43| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (30153:16): [True: 18, False: 25] ------------------ 30154| 43| uint8_t* d = dst_ptr; 30155| 43| const uint8_t* s = src_ptr; 30156| 43| size_t n = len; 30157| | 30158| 856| while (n >= 1) { ------------------ | Branch (30158:10): [True: 813, False: 43] ------------------ 30159| 813| wuffs_base__poke_u32le__no_bounds_check( 30160| 813| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); 30161| | 30162| 813| s += 1 * 2; 30163| 813| d += 1 * 4; 30164| 813| n -= 1; 30165| 813| } 30166| | 30167| 43| return len; 30168| 43|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16be: 30294| 9| size_t src_len) { 30295| 9| size_t dst_len8 = dst_len / 8; 30296| 9| size_t src_len2 = src_len / 2; 30297| 9| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (30297:16): [True: 6, False: 3] ------------------ 30298| 9| uint8_t* d = dst_ptr; 30299| 9| const uint8_t* s = src_ptr; 30300| 9| size_t n = len; 30301| | 30302| 86| while (n >= 1) { ------------------ | Branch (30302:10): [True: 77, False: 9] ------------------ 30303| 77| uint64_t s0 = 30304| 77| ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(s + (0 * 2)))); 30305| 77| wuffs_base__poke_u64le__no_bounds_check( 30306| 77| d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0)); 30307| | 30308| 77| s += 1 * 2; 30309| 77| d += 1 * 8; 30310| 77| n -= 1; 30311| 77| } 30312| | 30313| 9| return len; 30314| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16le: 31251| 144| wuffs_base__pixel_blend blend) { 31252| 144| switch (dst_pixfmt.repr) { ------------------ | Branch (31252:11): [True: 133, False: 11] ------------------ 31253| 17| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 17|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31253:5): [True: 17, False: 127] ------------------ 31254| 17| return wuffs_private_impl__swizzle_y__y_16le; 31255| | 31256| 7| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 7|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (31256:5): [True: 7, False: 137] ------------------ 31257| 7| return wuffs_private_impl__swizzle_copy_2_2; 31258| | 31259| 18| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 18|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (31259:5): [True: 18, False: 126] ------------------ 31260| 18| return wuffs_private_impl__swizzle_y_16le__y_16be; 31261| | 31262| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31262:5): [True: 19, False: 125] ------------------ 31263| 19| return wuffs_private_impl__swizzle_bgr_565__y_16le; 31264| | 31265| 5| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31265:5): [True: 5, False: 139] ------------------ 31266| 15| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 15|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31266:5): [True: 10, False: 134] ------------------ 31267| 15| return wuffs_private_impl__swizzle_xxx__y_16le; 31268| | 31269| 8| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31269:5): [True: 8, False: 136] ------------------ 31270| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31270:5): [True: 5, False: 139] ------------------ 31271| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31271:5): [True: 0, False: 144] ------------------ 31272| 16| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31272:5): [True: 3, False: 141] ------------------ 31273| 28| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 28|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31273:5): [True: 12, False: 132] ------------------ 31274| 41| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 41|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31274:5): [True: 13, False: 131] ------------------ 31275| 41| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 41|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31275:5): [True: 0, False: 144] ------------------ 31276| 41| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 41|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31276:5): [True: 0, False: 144] ------------------ 31277| 41| return wuffs_private_impl__swizzle_xxxx__y_16le; 31278| | 31279| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31279:5): [True: 12, False: 132] ------------------ 31280| 16| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31280:5): [True: 4, False: 140] ------------------ 31281| 16| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31281:5): [True: 0, False: 144] ------------------ 31282| 16| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4975| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (31282:5): [True: 0, False: 144] ------------------ 31283| 16| return wuffs_private_impl__swizzle_xxxxxxxx__y_16le; 31284| 144| } 31285| 11| return NULL; 31286| 144|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__y_16le: 30889| 17| size_t src_len) { 30890| 17| size_t src_len2 = src_len / 2; 30891| 17| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30891:16): [True: 5, False: 12] ------------------ 30892| 17| uint8_t* d = dst_ptr; 30893| 17| const uint8_t* s = src_ptr; 30894| 17| size_t n = len; 30895| | 30896| | // TODO: unroll. 30897| | 30898| 378| while (n >= 1) { ------------------ | Branch (30898:10): [True: 361, False: 17] ------------------ 30899| 361| d[0] = s[1]; 30900| | 30901| 361| s += 1 * 2; 30902| 361| d += 1 * 1; 30903| 361| n -= 1; 30904| 361| } 30905| | 30906| 17| return len; 30907| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16le: 26686| 19| size_t src_len) { 26687| 19| size_t dst_len2 = dst_len / 2; 26688| 19| size_t src_len2 = src_len / 2; 26689| 19| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26689:16): [True: 7, False: 12] ------------------ 26690| 19| uint8_t* d = dst_ptr; 26691| 19| const uint8_t* s = src_ptr; 26692| 19| size_t n = len; 26693| | 26694| | // TODO: unroll. 26695| | 26696| 785| while (n >= 1) { ------------------ | Branch (26696:10): [True: 766, False: 19] ------------------ 26697| 766| uint32_t y5 = (uint32_t)(s[1] >> 3); 26698| 766| uint32_t y6 = (uint32_t)(s[1] >> 2); 26699| 766| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 26700| 766| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26701| | 26702| 766| s += 1 * 2; 26703| 766| d += 1 * 2; 26704| 766| n -= 1; 26705| 766| } 26706| | 26707| 19| return len; 26708| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16le: 29866| 15| size_t src_len) { 29867| 15| size_t dst_len3 = dst_len / 3; 29868| 15| size_t src_len2 = src_len / 2; 29869| 15| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29869:16): [True: 8, False: 7] ------------------ 29870| 15| uint8_t* d = dst_ptr; 29871| 15| const uint8_t* s = src_ptr; 29872| 15| size_t n = len; 29873| | 29874| | // TODO: unroll. 29875| | 29876| 385| while (n >= 1) { ------------------ | Branch (29876:10): [True: 370, False: 15] ------------------ 29877| 370| uint8_t s0 = s[1]; 29878| 370| d[0] = s0; 29879| 370| d[1] = s0; 29880| 370| d[2] = s0; 29881| | 29882| 370| s += 1 * 2; 29883| 370| d += 1 * 3; 29884| 370| n -= 1; 29885| 370| } 29886| | 29887| 15| return len; 29888| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y_16le: 30176| 41| size_t src_len) { 30177| 41| size_t dst_len4 = dst_len / 4; 30178| 41| size_t src_len2 = src_len / 2; 30179| 41| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (30179:16): [True: 18, False: 23] ------------------ 30180| 41| uint8_t* d = dst_ptr; 30181| 41| const uint8_t* s = src_ptr; 30182| 41| size_t n = len; 30183| | 30184| 816| while (n >= 1) { ------------------ | Branch (30184:10): [True: 775, False: 41] ------------------ 30185| 775| wuffs_base__poke_u32le__no_bounds_check( 30186| 775| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[1])); 30187| | 30188| 775| s += 1 * 2; 30189| 775| d += 1 * 4; 30190| 775| n -= 1; 30191| 775| } 30192| | 30193| 41| return len; 30194| 41|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16le: 30322| 16| size_t src_len) { 30323| 16| size_t dst_len8 = dst_len / 8; 30324| 16| size_t src_len2 = src_len / 2; 30325| 16| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (30325:16): [True: 7, False: 9] ------------------ 30326| 16| uint8_t* d = dst_ptr; 30327| 16| const uint8_t* s = src_ptr; 30328| 16| size_t n = len; 30329| | 30330| 171| while (n >= 1) { ------------------ | Branch (30330:10): [True: 155, False: 16] ------------------ 30331| 155| uint64_t s0 = 30332| 155| ((uint64_t)(wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))); 30333| 155| wuffs_base__poke_u64le__no_bounds_check( 30334| 155| d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0)); 30335| | 30336| 155| s += 1 * 2; 30337| 155| d += 1 * 8; 30338| 155| n -= 1; 30339| 155| } 30340| | 30341| 16| return len; 30342| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul: 31294| 284| wuffs_base__pixel_blend blend) { 31295| 284| switch (dst_pixfmt.repr) { ------------------ | Branch (31295:11): [True: 259, False: 25] ------------------ 31296| 37| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 37|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31296:5): [True: 37, False: 247] ------------------ 31297| 37| switch (blend) { ------------------ | Branch (31297:15): [True: 37, False: 0] ------------------ 31298| 19| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31298:9): [True: 19, False: 18] ------------------ 31299| 19| return wuffs_private_impl__swizzle_y__ya_nonpremul__src; 31300| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31300:9): [True: 18, False: 19] ------------------ 31301| 18| return wuffs_private_impl__swizzle_y__ya_nonpremul__src_over; 31302| 37| } 31303| 0| return NULL; 31304| | 31305| 35| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4946| 35|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (31305:5): [True: 35, False: 249] ------------------ 31306| 35| switch (blend) { ------------------ | Branch (31306:15): [True: 35, False: 0] ------------------ 31307| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31307:9): [True: 3, False: 32] ------------------ 31308| 3| return wuffs_private_impl__swizzle_copy_2_2; 31309| 32| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31309:9): [True: 32, False: 3] ------------------ 31310| 32| return wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over; 31311| 35| } 31312| 0| return NULL; 31313| | 31314| 38| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 38|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31314:5): [True: 38, False: 246] ------------------ 31315| 38| switch (blend) { ------------------ | Branch (31315:15): [True: 38, False: 0] ------------------ 31316| 20| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31316:9): [True: 20, False: 18] ------------------ 31317| 20| return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src; 31318| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31318:9): [True: 18, False: 20] ------------------ 31319| 18| return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over; 31320| 38| } 31321| 0| return NULL; 31322| | 31323| 15| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31323:5): [True: 15, False: 269] ------------------ 31324| 27| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 27|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31324:5): [True: 12, False: 272] ------------------ 31325| 27| switch (blend) { ------------------ | Branch (31325:15): [True: 27, False: 0] ------------------ 31326| 12| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31326:9): [True: 12, False: 15] ------------------ 31327| 12| return wuffs_private_impl__swizzle_xxx__ya_nonpremul__src; 31328| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31328:9): [True: 15, False: 12] ------------------ 31329| 15| return wuffs_private_impl__swizzle_xxx__ya_nonpremul__src_over; 31330| 27| } 31331| 0| return NULL; 31332| | 31333| 22| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31333:5): [True: 22, False: 262] ------------------ 31334| 41| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 41|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31334:5): [True: 19, False: 265] ------------------ 31335| 41| switch (blend) { ------------------ | Branch (31335:15): [True: 41, False: 0] ------------------ 31336| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31336:9): [True: 16, False: 25] ------------------ 31337| 16| return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src; 31338| 25| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 25|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31338:9): [True: 25, False: 16] ------------------ 31339| 25| return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over; 31340| 41| } 31341| 0| return NULL; 31342| | 31343| 19| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31343:5): [True: 19, False: 265] ------------------ 31344| 37| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 37|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31344:5): [True: 18, False: 266] ------------------ 31345| 37| switch (blend) { ------------------ | Branch (31345:15): [True: 37, False: 0] ------------------ 31346| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31346:9): [True: 18, False: 19] ------------------ 31347| 18| return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src; 31348| 19| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31348:9): [True: 19, False: 18] ------------------ 31349| 19| return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over; 31350| 37| } 31351| 0| return NULL; 31352| | 31353| 44| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 44|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31353:5): [True: 44, False: 240] ------------------ 31354| 44| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 44|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31354:5): [True: 0, False: 284] ------------------ 31355| 44| switch (blend) { ------------------ | Branch (31355:15): [True: 44, False: 0] ------------------ 31356| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31356:9): [True: 10, False: 34] ------------------ 31357| 10| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src; 31358| 34| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 34|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31358:9): [True: 34, False: 10] ------------------ 31359| 34| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over; 31360| 44| } 31361| 0| return NULL; 31362| 284| } 31363| 25| return NULL; 31364| 284|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src: 30915| 19| size_t src_len) { 30916| 19| size_t src_len2 = src_len / 2; 30917| 19| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30917:16): [True: 4, False: 15] ------------------ 30918| 19| uint8_t* d = dst_ptr; 30919| 19| const uint8_t* s = src_ptr; 30920| 19| size_t n = len; 30921| | 30922| | // TODO: unroll. 30923| | 30924| 383| while (n >= 1) { ------------------ | Branch (30924:10): [True: 364, False: 19] ------------------ 30925| 364| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 30926| 364| d[0] = (uint8_t) 30927| 364| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0); 30928| | 30929| 364| s += 1 * 2; 30930| 364| d += 1 * 1; 30931| 364| n -= 1; 30932| 364| } 30933| | 30934| 19| return len; 30935| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src_over: 30943| 18| size_t src_len) { 30944| 18| size_t src_len2 = src_len / 2; 30945| 18| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30945:16): [True: 3, False: 15] ------------------ 30946| 18| uint8_t* d = dst_ptr; 30947| 18| const uint8_t* s = src_ptr; 30948| 18| size_t n = len; 30949| | 30950| | // TODO: unroll. 30951| | 30952| 708| while (n >= 1) { ------------------ | Branch (30952:10): [True: 690, False: 18] ------------------ 30953| 690| uint32_t d0 = 0xFF000000 | ((uint32_t)(d[0]) * 0x010101); 30954| 690| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 30955| 690| d[0] = (uint8_t)wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, 30956| 690| s0); 30957| | 30958| 690| s += 1 * 2; 30959| 690| d += 1 * 1; 30960| 690| n -= 1; 30961| 690| } 30962| | 30963| 18| return len; 30964| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u32_axxx: 25610| 6.04k| uint32_t src_nonpremul) { 25611| | // Extract 16-bit color components. 25612| 6.04k| uint32_t da = 0x101 * (0xFF & (dst_premul >> 24)); 25613| 6.04k| uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16)); 25614| 6.04k| uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8)); 25615| 6.04k| uint32_t db = 0x101 * (0xFF & (dst_premul >> 0)); 25616| 6.04k| uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24)); 25617| 6.04k| uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16)); 25618| 6.04k| uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8)); 25619| 6.04k| uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0)); 25620| | 25621| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25622| 6.04k| uint32_t ia = 0xFFFF - sa; 25623| | 25624| | // Composite src (nonpremul) over dst (premul). 25625| 6.04k| da = sa + ((da * ia) / 0xFFFF); 25626| 6.04k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25627| 6.04k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25628| 6.04k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25629| | 25630| | // Convert from 16-bit color to 8-bit color. 25631| 6.04k| da >>= 8; 25632| 6.04k| dr >>= 8; 25633| 6.04k| dg >>= 8; 25634| 6.04k| db >>= 8; 25635| | 25636| | // Combine components. 25637| 6.04k| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25638| 6.04k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over: 31102| 32| size_t src_len) { 31103| 32| size_t dst_len2 = dst_len / 2; 31104| 32| size_t src_len2 = src_len / 2; 31105| 32| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (31105:16): [True: 8, False: 24] ------------------ 31106| 32| uint8_t* d = dst_ptr; 31107| 32| const uint8_t* s = src_ptr; 31108| 32| size_t n = len; 31109| | 31110| 1.30k| while (n >= 1) { ------------------ | Branch (31110:10): [True: 1.26k, False: 32] ------------------ 31111| 1.26k| uint32_t d0 = ((uint32_t)(d[1]) << 24) | ((uint32_t)(d[0]) * 0x010101); 31112| 1.26k| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 31113| 1.26k| uint32_t c0 = 31114| 1.26k| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0); 31115| 1.26k| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)(c0 >> 16)); 31116| | 31117| 1.26k| s += 1 * 2; 31118| 1.26k| d += 1 * 2; 31119| 1.26k| n -= 1; 31120| 1.26k| } 31121| | 31122| 32| return len; 31123| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx: 25426| 2.87k| uint32_t src_nonpremul) { 25427| | // Extract 16-bit color components. 25428| | // 25429| | // If the destination is transparent then SRC_OVER is equivalent to SRC: just 25430| | // return src_nonpremul. This isn't just an optimization (skipping the rest 25431| | // of the function's computation). It also preserves the nonpremul 25432| | // distinction between e.g. transparent red and transparent blue that would 25433| | // otherwise be lost by converting from nonpremul to premul and back. 25434| 2.87k| uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24)); 25435| 2.87k| if (da == 0) { ------------------ | Branch (25435:7): [True: 628, False: 2.24k] ------------------ 25436| 628| return src_nonpremul; 25437| 628| } 25438| 2.24k| uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16)); 25439| 2.24k| uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8)); 25440| 2.24k| uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0)); 25441| 2.24k| uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24)); 25442| 2.24k| uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16)); 25443| 2.24k| uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8)); 25444| 2.24k| uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0)); 25445| | 25446| | // Convert dst from nonpremul to premul. 25447| 2.24k| dr = (dr * da) / 0xFFFF; 25448| 2.24k| dg = (dg * da) / 0xFFFF; 25449| 2.24k| db = (db * da) / 0xFFFF; 25450| | 25451| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25452| 2.24k| uint32_t ia = 0xFFFF - sa; 25453| | 25454| | // Composite src (nonpremul) over dst (premul). 25455| 2.24k| da = sa + ((da * ia) / 0xFFFF); 25456| 2.24k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25457| 2.24k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25458| 2.24k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25459| | 25460| | // Convert dst from premul to nonpremul. 25461| 2.24k| if (da != 0) { ------------------ | Branch (25461:7): [True: 2.24k, False: 0] ------------------ 25462| 2.24k| dr = (dr * 0xFFFF) / da; 25463| 2.24k| dg = (dg * 0xFFFF) / da; 25464| 2.24k| db = (db * 0xFFFF) / da; 25465| 2.24k| } 25466| | 25467| | // Convert from 16-bit color to 8-bit color. 25468| 2.24k| da >>= 8; 25469| 2.24k| dr >>= 8; 25470| 2.24k| dg >>= 8; 25471| 2.24k| db >>= 8; 25472| | 25473| | // Combine components. 25474| 2.24k| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25475| 2.87k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src: 26716| 20| size_t src_len) { 26717| 20| size_t dst_len2 = dst_len / 2; 26718| 20| size_t src_len2 = src_len / 2; 26719| 20| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26719:16): [True: 3, False: 17] ------------------ 26720| 20| uint8_t* d = dst_ptr; 26721| 20| const uint8_t* s = src_ptr; 26722| 20| size_t n = len; 26723| | 26724| | // TODO: unroll. 26725| | 26726| 878| while (n >= 1) { ------------------ | Branch (26726:10): [True: 858, False: 20] ------------------ 26727| 858| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 26728| | 26729| 858| wuffs_base__poke_u16le__no_bounds_check( 26730| 858| d + (0 * 2), 26731| 858| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26732| 858| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26733| 858| s0))); 26734| | 26735| 858| s += 1 * 2; 26736| 858| d += 1 * 2; 26737| 858| n -= 1; 26738| 858| } 26739| | 26740| 20| return len; 26741| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over: 26750| 18| size_t src_len) { 26751| 18| size_t dst_len2 = dst_len / 2; 26752| 18| size_t src_len2 = src_len / 2; 26753| 18| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26753:16): [True: 6, False: 12] ------------------ 26754| 18| uint8_t* d = dst_ptr; 26755| 18| const uint8_t* s = src_ptr; 26756| 18| size_t n = len; 26757| | 26758| | // TODO: unroll. 26759| | 26760| 685| while (n >= 1) { ------------------ | Branch (26760:10): [True: 667, False: 18] ------------------ 26761| | // Extract 16-bit color components. 26762| 667| uint32_t sa = 0x101 * ((uint32_t)s[1]); 26763| 667| uint32_t sy = 0x101 * ((uint32_t)s[0]); 26764| | 26765| | // Convert from 565 color to 16-bit color. 26766| 667| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26767| 667| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26768| 667| uint32_t dr = (0x8421 * old_r5) >> 4; 26769| 667| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26770| 667| uint32_t dg = (0x1041 * old_g6) >> 2; 26771| 667| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26772| 667| uint32_t db = (0x8421 * old_b5) >> 4; 26773| | 26774| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26775| 667| uint32_t ia = 0xFFFF - sa; 26776| | 26777| | // Composite src (nonpremul) over dst (premul). 26778| 667| dr = ((sy * sa) + (dr * ia)) / 0xFFFF; 26779| 667| dg = ((sy * sa) + (dg * ia)) / 0xFFFF; 26780| 667| db = ((sy * sa) + (db * ia)) / 0xFFFF; 26781| | 26782| | // Convert from 16-bit color to 565 color and combine the components. 26783| 667| uint32_t new_r5 = 0x1F & (dr >> 11); 26784| 667| uint32_t new_g6 = 0x3F & (dg >> 10); 26785| 667| uint32_t new_b5 = 0x1F & (db >> 11); 26786| 667| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26787| 667| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26788| | 26789| 667| s += 1 * 2; 26790| 667| d += 1 * 2; 26791| 667| n -= 1; 26792| 667| } 26793| | 26794| 18| return len; 26795| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__ya_nonpremul__src: 29896| 12| size_t src_len) { 29897| 12| size_t dst_len3 = dst_len / 3; 29898| 12| size_t src_len2 = src_len / 2; 29899| 12| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29899:16): [True: 5, False: 7] ------------------ 29900| 12| uint8_t* d = dst_ptr; 29901| 12| const uint8_t* s = src_ptr; 29902| 12| size_t n = len; 29903| | 29904| | // TODO: unroll. 29905| | 29906| 258| while (n >= 1) { ------------------ | Branch (29906:10): [True: 246, False: 12] ------------------ 29907| 246| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 29908| 246| wuffs_base__poke_u24le__no_bounds_check( 29909| 246| d + (0 * 3), 29910| 246| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 29911| | 29912| 246| s += 1 * 2; 29913| 246| d += 1 * 3; 29914| 246| n -= 1; 29915| 246| } 29916| | 29917| 12| return len; 29918| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__ya_nonpremul__src_over: 29927| 15| size_t src_len) { 29928| 15| size_t dst_len3 = dst_len / 3; 29929| 15| size_t src_len2 = src_len / 2; 29930| 15| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29930:16): [True: 8, False: 7] ------------------ 29931| 15| uint8_t* d = dst_ptr; 29932| 15| const uint8_t* s = src_ptr; 29933| 15| size_t n = len; 29934| | 29935| | // TODO: unroll. 29936| | 29937| 260| while (n >= 1) { ------------------ | Branch (29937:10): [True: 245, False: 15] ------------------ 29938| 245| uint32_t d0 = 29939| 245| wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000; 29940| 245| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 29941| 245| wuffs_base__poke_u24le__no_bounds_check( 29942| 245| d + (0 * 3), 29943| 245| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 29944| | 29945| 245| s += 1 * 2; 29946| 245| d += 1 * 3; 29947| 245| n -= 1; 29948| 245| } 29949| | 29950| 15| return len; 29951| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src: 27952| 16| size_t src_len) { 27953| 16| size_t dst_len4 = dst_len / 4; 27954| 16| size_t src_len2 = src_len / 2; 27955| 16| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (27955:16): [True: 7, False: 9] ------------------ 27956| 16| uint8_t* d = dst_ptr; 27957| 16| const uint8_t* s = src_ptr; 27958| 16| size_t n = len; 27959| | 27960| | // TODO: unroll. 27961| | 27962| 299| while (n >= 1) { ------------------ | Branch (27962:10): [True: 283, False: 16] ------------------ 27963| 283| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 27964| 283| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 27965| | 27966| 283| s += 1 * 2; 27967| 283| d += 1 * 4; 27968| 283| n -= 1; 27969| 283| } 27970| | 27971| 16| return len; 27972| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over: 27981| 25| size_t src_len) { 27982| 25| size_t dst_len4 = dst_len / 4; 27983| 25| size_t src_len2 = src_len / 2; 27984| 25| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (27984:16): [True: 9, False: 16] ------------------ 27985| 25| uint8_t* d = dst_ptr; 27986| 25| const uint8_t* s = src_ptr; 27987| 25| size_t n = len; 27988| | 27989| | // TODO: unroll. 27990| | 27991| 384| while (n >= 1) { ------------------ | Branch (27991:10): [True: 359, False: 25] ------------------ 27992| 359| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27993| 359| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 27994| 359| wuffs_base__poke_u32le__no_bounds_check( 27995| 359| d + (0 * 4), 27996| 359| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27997| | 27998| 359| s += 1 * 2; 27999| 359| d += 1 * 4; 28000| 359| n -= 1; 28001| 359| } 28002| | 28003| 25| return len; 28004| 25|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src: 28936| 18| size_t src_len) { 28937| 18| size_t dst_len4 = dst_len / 4; 28938| 18| size_t src_len2 = src_len / 2; 28939| 18| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28939:16): [True: 7, False: 11] ------------------ 28940| 18| uint8_t* d = dst_ptr; 28941| 18| const uint8_t* s = src_ptr; 28942| 18| size_t n = len; 28943| | 28944| | // TODO: unroll. 28945| | 28946| 415| while (n >= 1) { ------------------ | Branch (28946:10): [True: 397, False: 18] ------------------ 28947| 397| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 28948| 397| wuffs_base__poke_u32le__no_bounds_check( 28949| 397| d + (0 * 4), 28950| 397| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28951| | 28952| 397| s += 1 * 2; 28953| 397| d += 1 * 4; 28954| 397| n -= 1; 28955| 397| } 28956| | 28957| 18| return len; 28958| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over: 28967| 19| size_t src_len) { 28968| 19| size_t dst_len4 = dst_len / 4; 28969| 19| size_t src_len2 = src_len / 2; 28970| 19| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28970:16): [True: 9, False: 10] ------------------ 28971| 19| uint8_t* d = dst_ptr; 28972| 19| const uint8_t* s = src_ptr; 28973| 19| size_t n = len; 28974| | 28975| | // TODO: unroll. 28976| | 28977| 345| while (n >= 1) { ------------------ | Branch (28977:10): [True: 326, False: 19] ------------------ 28978| 326| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28979| 326| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 28980| 326| wuffs_base__poke_u32le__no_bounds_check( 28981| 326| d + (0 * 4), 28982| 326| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28983| | 28984| 326| s += 1 * 2; 28985| 326| d += 1 * 4; 28986| 326| n -= 1; 28987| 326| } 28988| | 28989| 19| return len; 28990| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src: 28387| 10| size_t src_len) { 28388| 10| size_t dst_len8 = dst_len / 8; 28389| 10| size_t src_len2 = src_len / 2; 28390| 10| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (28390:16): [True: 5, False: 5] ------------------ 28391| 10| uint8_t* d = dst_ptr; 28392| 10| const uint8_t* s = src_ptr; 28393| | 28394| 10| size_t n = len; 28395| 96| while (n >= 1) { ------------------ | Branch (28395:10): [True: 86, False: 10] ------------------ 28396| 86| uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) | 28397| 86| ((uint64_t)(s[0]) * 0x0000010101010101); 28398| 86| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 28399| | 28400| 86| s += 1 * 2; 28401| 86| d += 1 * 8; 28402| 86| n -= 1; 28403| 86| } 28404| 10| return len; 28405| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over: 28414| 34| size_t src_len) { 28415| 34| size_t dst_len8 = dst_len / 8; 28416| 34| size_t src_len2 = src_len / 2; 28417| 34| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (28417:16): [True: 15, False: 19] ------------------ 28418| 34| uint8_t* d = dst_ptr; 28419| 34| const uint8_t* s = src_ptr; 28420| | 28421| 34| size_t n = len; 28422| 245| while (n >= 1) { ------------------ | Branch (28422:10): [True: 211, False: 34] ------------------ 28423| 211| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28424| 211| uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) | 28425| 211| ((uint64_t)(s[0]) * 0x0000010101010101); 28426| 211| wuffs_base__poke_u64le__no_bounds_check( 28427| 211| d + (0 * 8), 28428| 211| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28429| | 28430| 211| s += 1 * 2; 28431| 211| d += 1 * 8; 28432| 211| n -= 1; 28433| 211| } 28434| 34| return len; 28435| 34|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx: 25480| 1.48k| uint64_t src_nonpremul) { 25481| | // Extract components. 25482| | // 25483| | // If the destination is transparent then SRC_OVER is equivalent to SRC: just 25484| | // return src_nonpremul. This isn't just an optimization (skipping the rest 25485| | // of the function's computation). It also preserves the nonpremul 25486| | // distinction between e.g. transparent red and transparent blue that would 25487| | // otherwise be lost by converting from nonpremul to premul and back. 25488| 1.48k| uint64_t da = 0xFFFF & (dst_nonpremul >> 48); 25489| 1.48k| if (da == 0) { ------------------ | Branch (25489:7): [True: 282, False: 1.20k] ------------------ 25490| 282| return src_nonpremul; 25491| 282| } 25492| 1.20k| uint64_t dr = 0xFFFF & (dst_nonpremul >> 32); 25493| 1.20k| uint64_t dg = 0xFFFF & (dst_nonpremul >> 16); 25494| 1.20k| uint64_t db = 0xFFFF & (dst_nonpremul >> 0); 25495| 1.20k| uint64_t sa = 0xFFFF & (src_nonpremul >> 48); 25496| 1.20k| uint64_t sr = 0xFFFF & (src_nonpremul >> 32); 25497| 1.20k| uint64_t sg = 0xFFFF & (src_nonpremul >> 16); 25498| 1.20k| uint64_t sb = 0xFFFF & (src_nonpremul >> 0); 25499| | 25500| | // Convert dst from nonpremul to premul. 25501| 1.20k| dr = (dr * da) / 0xFFFF; 25502| 1.20k| dg = (dg * da) / 0xFFFF; 25503| 1.20k| db = (db * da) / 0xFFFF; 25504| | 25505| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25506| 1.20k| uint64_t ia = 0xFFFF - sa; 25507| | 25508| | // Composite src (nonpremul) over dst (premul). 25509| 1.20k| da = sa + ((da * ia) / 0xFFFF); 25510| 1.20k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25511| 1.20k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25512| 1.20k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25513| | 25514| | // Convert dst from premul to nonpremul. 25515| 1.20k| if (da != 0) { ------------------ | Branch (25515:7): [True: 1.20k, False: 0] ------------------ 25516| 1.20k| dr = (dr * 0xFFFF) / da; 25517| 1.20k| dg = (dg * 0xFFFF) / da; 25518| 1.20k| db = (db * 0xFFFF) / da; 25519| 1.20k| } 25520| | 25521| | // Combine components. 25522| 1.20k| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25523| 1.48k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul: 31372| 228| wuffs_base__pixel_blend blend) { 31373| 228| switch (dst_pixfmt.repr) { ------------------ | Branch (31373:11): [True: 206, False: 22] ------------------ 31374| 43| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 43|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31374:5): [True: 43, False: 185] ------------------ 31375| 43| switch (blend) { ------------------ | Branch (31375:15): [True: 43, False: 0] ------------------ 31376| 19| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31376:9): [True: 19, False: 24] ------------------ 31377| 19| if (wuffs_private_impl__swizzle_squash_align4_y_8888( ------------------ | Branch (31377:15): [True: 0, False: 19] ------------------ 31378| 19| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31379| 19| src_palette.len, true) != 31380| 19| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 19|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31381| 0| return NULL; 31382| 0| } 31383| 19| return wuffs_private_impl__swizzle_y__index__src; 31384| 24| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 24|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31384:9): [True: 24, False: 19] ------------------ 31385| 24| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31385:15): [True: 0, False: 24] ------------------ 31386| 24| src_palette) != 31387| 24| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 24|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31388| 0| return NULL; 31389| 0| } 31390| 24| return wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over; 31391| 43| } 31392| 0| return NULL; 31393| | 31394| 11| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (31394:5): [True: 11, False: 217] ------------------ 31395| 11| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31395:11): [True: 0, False: 11] ------------------ 31396| 11| src_palette) != 31397| 11| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31398| 0| return NULL; 31399| 0| } 31400| 11| switch (blend) { ------------------ | Branch (31400:15): [True: 10, False: 1] ------------------ 31401| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31401:9): [True: 10, False: 1] ------------------ 31402| 10| return wuffs_private_impl__swizzle_copy_1_1; 31403| 11| } 31404| 1| return NULL; 31405| | 31406| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31406:5): [True: 19, False: 209] ------------------ 31407| 19| switch (blend) { ------------------ | Branch (31407:15): [True: 19, False: 0] ------------------ 31408| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31408:9): [True: 3, False: 16] ------------------ 31409| 3| if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888( ------------------ | Branch (31409:15): [True: 0, False: 3] ------------------ 31410| 3| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31411| 3| src_palette.len, true) != 31412| 3| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 3|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31413| 0| return NULL; 31414| 0| } 31415| 3| return wuffs_private_impl__swizzle_bgr_565__index__src; 31416| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31416:9): [True: 16, False: 3] ------------------ 31417| 16| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31417:15): [True: 0, False: 16] ------------------ 31418| 16| src_palette) != 31419| 16| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 16|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31420| 0| return NULL; 31421| 0| } 31422| 16| return wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over; 31423| 19| } 31424| 0| return NULL; 31425| | 31426| 12| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31426:5): [True: 12, False: 216] ------------------ 31427| 12| switch (blend) { ------------------ | Branch (31427:15): [True: 12, False: 0] ------------------ 31428| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31428:9): [True: 4, False: 8] ------------------ 31429| 4| if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src( ------------------ | Branch (31429:15): [True: 0, False: 4] ------------------ 31430| 4| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31431| 4| src_palette.len) != 31432| 4| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31433| 0| return NULL; 31434| 0| } 31435| 4| return wuffs_private_impl__swizzle_xxx__index__src; 31436| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31436:9): [True: 8, False: 4] ------------------ 31437| 8| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31437:15): [True: 0, False: 8] ------------------ 31438| 8| src_palette) != 31439| 8| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 8|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31440| 0| return NULL; 31441| 0| } 31442| 8| return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over; 31443| 12| } 31444| 0| return NULL; 31445| | 31446| 25| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31446:5): [True: 25, False: 203] ------------------ 31447| 25| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31447:11): [True: 0, False: 25] ------------------ 31448| 25| src_palette) != 31449| 25| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 25|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31450| 0| return NULL; 31451| 0| } 31452| 25| switch (blend) { ------------------ | Branch (31452:15): [True: 25, False: 0] ------------------ 31453| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31453:9): [True: 7, False: 18] ------------------ 31454| 7| return wuffs_private_impl__swizzle_xxxx__index__src; 31455| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31455:9): [True: 18, False: 7] ------------------ 31456| 18| return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over; 31457| 25| } 31458| 0| return NULL; 31459| | 31460| 49| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 49|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31460:5): [True: 49, False: 179] ------------------ 31461| 49| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31461:11): [True: 0, False: 49] ------------------ 31462| 49| src_palette) != 31463| 49| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 49|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31464| 0| return NULL; 31465| 0| } 31466| 49| switch (blend) { ------------------ | Branch (31466:15): [True: 49, False: 0] ------------------ 31467| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31467:9): [True: 5, False: 44] ------------------ 31468| 5| return wuffs_private_impl__swizzle_xxxxxxxx__index__src; 31469| 44| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 44|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31469:9): [True: 44, False: 5] ------------------ 31470| 44| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over; 31471| 49| } 31472| 0| return NULL; 31473| | 31474| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31474:5): [True: 13, False: 215] ------------------ 31475| 13| switch (blend) { ------------------ | Branch (31475:15): [True: 13, False: 0] ------------------ 31476| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31476:9): [True: 5, False: 8] ------------------ 31477| 5| if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src( ------------------ | Branch (31477:15): [True: 0, False: 5] ------------------ 31478| 5| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31479| 5| src_palette.len) != 31480| 5| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 5|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31481| 0| return NULL; 31482| 0| } 31483| 5| return wuffs_private_impl__swizzle_xxxx__index__src; 31484| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31484:9): [True: 8, False: 5] ------------------ 31485| 8| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31485:15): [True: 0, False: 8] ------------------ 31486| 8| src_palette) != 31487| 8| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 8|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31488| 0| return NULL; 31489| 0| } 31490| 8| return wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over; 31491| 13| } 31492| 0| return NULL; 31493| | 31494| 18| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 18|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31494:5): [True: 18, False: 210] ------------------ 31495| 18| switch (blend) { ------------------ | Branch (31495:15): [True: 18, False: 0] ------------------ 31496| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31496:9): [True: 8, False: 10] ------------------ 31497| 8| if (wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src( ------------------ | Branch (31497:15): [True: 0, False: 8] ------------------ 31498| 8| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31499| 8| src_palette.len) != 31500| 8| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 8|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31501| 0| return NULL; 31502| 0| } 31503| 8| return wuffs_private_impl__swizzle_xxx__index__src; 31504| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31504:9): [True: 10, False: 8] ------------------ 31505| 10| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31505:15): [True: 0, False: 10] ------------------ 31506| 10| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31507| 10| src_palette.len) != 31508| 10| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 10|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31509| 0| return NULL; 31510| 0| } 31511| 10| return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over; 31512| 18| } 31513| 0| return NULL; 31514| | 31515| 9| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 9|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31515:5): [True: 9, False: 219] ------------------ 31516| 9| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31516:11): [True: 0, False: 9] ------------------ 31517| 9| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31518| 9| src_palette.len) != 31519| 9| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 9|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31520| 0| return NULL; 31521| 0| } 31522| 9| switch (blend) { ------------------ | Branch (31522:15): [True: 9, False: 0] ------------------ 31523| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31523:9): [True: 2, False: 7] ------------------ 31524| 2| return wuffs_private_impl__swizzle_xxxx__index__src; 31525| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31525:9): [True: 7, False: 2] ------------------ 31526| 7| return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over; 31527| 9| } 31528| 0| return NULL; 31529| | 31530| 7| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 7|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31530:5): [True: 7, False: 221] ------------------ 31531| 7| switch (blend) { ------------------ | Branch (31531:15): [True: 7, False: 0] ------------------ 31532| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31532:9): [True: 2, False: 5] ------------------ 31533| 2| if (wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src( ------------------ | Branch (31533:15): [True: 0, False: 2] ------------------ 31534| 2| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31535| 2| src_palette.len) != 31536| 2| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 2|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31537| 0| return NULL; 31538| 0| } 31539| 2| return wuffs_private_impl__swizzle_xxxx__index__src; 31540| 5| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31540:9): [True: 5, False: 2] ------------------ 31541| 5| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31541:15): [True: 0, False: 5] ------------------ 31542| 5| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31543| 5| src_palette.len) != 31544| 5| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 5|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31545| 0| return NULL; 31546| 0| } 31547| 5| return wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over; 31548| 7| } 31549| 0| return NULL; 31550| | 31551| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31551:5): [True: 0, False: 228] ------------------ 31552| | // TODO. 31553| 0| break; 31554| 228| } 31555| 22| return NULL; 31556| 228|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_y_8888: 25763| 56| bool nonpremul) { 25764| 56| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25764:17): [True: 0, False: 56] ------------------ 25765| 56| uint8_t* d = dst_ptr; 25766| 56| const uint8_t* s = src_ptr; 25767| | 25768| 56| size_t n = len; 25769| 14.3k| while (n--) { ------------------ | Branch (25769:10): [True: 14.3k, False: 56] ------------------ 25770| 14.3k| uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s); 25771| 14.3k| if (nonpremul) { ------------------ | Branch (25771:9): [True: 4.86k, False: 9.47k] ------------------ 25772| 4.86k| argb = 25773| 4.86k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb); 25774| 4.86k| } 25775| 14.3k| uint32_t s0 = wuffs_base__color_u32_argb_premul__as__color_u8_gray(argb); 25776| 14.3k| wuffs_base__poke_u32le__no_bounds_check( 25777| 14.3k| d, (argb & 0xFF000000) | (s0 * 0x010101)); 25778| 14.3k| s += 4; 25779| 14.3k| d += 4; 25780| 14.3k| } 25781| 56| return len; 25782| 56|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index__src: 30972| 23| size_t src_len) { 30973| 23| if (dst_palette_len != ------------------ | Branch (30973:7): [True: 0, False: 23] ------------------ 30974| 23| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 23|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30975| 0| return 0; 30976| 0| } 30977| 23| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (30977:16): [True: 3, False: 20] ------------------ 30978| 23| uint8_t* d = dst_ptr; 30979| 23| const uint8_t* s = src_ptr; 30980| 23| size_t n = len; 30981| | 30982| | // TODO: unroll. 30983| | 30984| 1.69k| while (n >= 1) { ------------------ | Branch (30984:10): [True: 1.66k, False: 23] ------------------ 30985| 1.66k| d[0] = dst_palette_ptr[(size_t)s[0] * 4]; 30986| | 30987| 1.66k| s += 1 * 1; 30988| 1.66k| d += 1 * 1; 30989| 1.66k| n -= 1; 30990| 1.66k| } 30991| | 30992| 23| return len; 30993| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__slice_u8__copy_from_slice: 18632| 305| wuffs_base__slice_u8 src) { 18633| 305| size_t len = dst.len < src.len ? dst.len : src.len; ------------------ | Branch (18633:16): [True: 0, False: 305] ------------------ 18634| 305| if (len > 0) { ------------------ | Branch (18634:7): [True: 305, False: 0] ------------------ 18635| 305| memmove(dst.ptr, src.ptr, len); 18636| 305| } 18637| 305| return len; 18638| 305|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over: 31002| 24| size_t src_len) { 31003| 24| if (dst_palette_len != ------------------ | Branch (31003:7): [True: 0, False: 24] ------------------ 31004| 24| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 24|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31005| 0| return 0; 31006| 0| } 31007| 24| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (31007:16): [True: 4, False: 20] ------------------ 31008| 24| uint8_t* d = dst_ptr; 31009| 24| const uint8_t* s = src_ptr; 31010| 24| size_t n = len; 31011| | 31012| | // TODO: unroll. 31013| | 31014| 2.74k| while (n >= 1) { ------------------ | Branch (31014:10): [True: 2.71k, False: 24] ------------------ 31015| 2.71k| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 31016| 2.71k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 31017| 2.71k| ((size_t)s[0] * 4)); 31018| 2.71k| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 31019| 2.71k| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 31020| | 31021| 2.71k| s += 1 * 1; 31022| 2.71k| d += 1 * 1; 31023| 2.71k| n -= 1; 31024| 2.71k| } 31025| | 31026| 24| return len; 31027| 24|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_bgr_565_8888: 25732| 38| bool nonpremul) { 25733| 38| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25733:17): [True: 0, False: 38] ------------------ 25734| 38| uint8_t* d = dst_ptr; 25735| 38| const uint8_t* s = src_ptr; 25736| | 25737| 38| size_t n = len; 25738| 9.76k| while (n--) { ------------------ | Branch (25738:10): [True: 9.72k, False: 38] ------------------ 25739| 9.72k| uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s); 25740| 9.72k| if (nonpremul) { ------------------ | Branch (25740:9): [True: 768, False: 8.96k] ------------------ 25741| 768| argb = 25742| 768| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb); 25743| 768| } 25744| 9.72k| uint32_t b5 = 0x1F & (argb >> (8 - 5)); 25745| 9.72k| uint32_t g6 = 0x3F & (argb >> (16 - 6)); 25746| 9.72k| uint32_t r5 = 0x1F & (argb >> (24 - 5)); 25747| 9.72k| uint32_t alpha = argb & 0xFF000000; 25748| 9.72k| wuffs_base__poke_u32le__no_bounds_check( 25749| 9.72k| d, alpha | (r5 << 11) | (g6 << 5) | (b5 << 0)); 25750| 9.72k| s += 4; 25751| 9.72k| d += 4; 25752| 9.72k| } 25753| 38| return len; 25754| 38|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index__src: 26803| 15| size_t src_len) { 26804| 15| if (dst_palette_len != ------------------ | Branch (26804:7): [True: 0, False: 15] ------------------ 26805| 15| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 15|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26806| 0| return 0; 26807| 0| } 26808| 15| size_t dst_len2 = dst_len / 2; 26809| 15| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26809:16): [True: 5, False: 10] ------------------ 26810| 15| uint8_t* d = dst_ptr; 26811| 15| const uint8_t* s = src_ptr; 26812| 15| size_t n = len; 26813| | 26814| 15| const size_t loop_unroll_count = 4; 26815| | 26816| 187| while (n >= loop_unroll_count) { ------------------ | Branch (26816:10): [True: 172, False: 15] ------------------ 26817| 172| wuffs_base__poke_u16le__no_bounds_check( 26818| 172| d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check( 26819| 172| dst_palette_ptr + ((size_t)s[0] * 4))); 26820| 172| wuffs_base__poke_u16le__no_bounds_check( 26821| 172| d + (1 * 2), wuffs_base__peek_u16le__no_bounds_check( 26822| 172| dst_palette_ptr + ((size_t)s[1] * 4))); 26823| 172| wuffs_base__poke_u16le__no_bounds_check( 26824| 172| d + (2 * 2), wuffs_base__peek_u16le__no_bounds_check( 26825| 172| dst_palette_ptr + ((size_t)s[2] * 4))); 26826| 172| wuffs_base__poke_u16le__no_bounds_check( 26827| 172| d + (3 * 2), wuffs_base__peek_u16le__no_bounds_check( 26828| 172| dst_palette_ptr + ((size_t)s[3] * 4))); 26829| | 26830| 172| s += loop_unroll_count * 1; 26831| 172| d += loop_unroll_count * 2; 26832| 172| n -= loop_unroll_count; 26833| 172| } 26834| | 26835| 34| while (n >= 1) { ------------------ | Branch (26835:10): [True: 19, False: 15] ------------------ 26836| 19| wuffs_base__poke_u16le__no_bounds_check( 26837| 19| d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check( 26838| 19| dst_palette_ptr + ((size_t)s[0] * 4))); 26839| | 26840| 19| s += 1 * 1; 26841| 19| d += 1 * 2; 26842| 19| n -= 1; 26843| 19| } 26844| | 26845| 15| return len; 26846| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over: 26855| 16| size_t src_len) { 26856| 16| if (dst_palette_len != ------------------ | Branch (26856:7): [True: 0, False: 16] ------------------ 26857| 16| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 16|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26858| 0| return 0; 26859| 0| } 26860| 16| size_t dst_len2 = dst_len / 2; 26861| 16| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26861:16): [True: 5, False: 11] ------------------ 26862| 16| uint8_t* d = dst_ptr; 26863| 16| const uint8_t* s = src_ptr; 26864| 16| size_t n = len; 26865| | 26866| | // TODO: unroll. 26867| | 26868| 515| while (n >= 1) { ------------------ | Branch (26868:10): [True: 499, False: 16] ------------------ 26869| 499| uint32_t d0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 26870| 499| wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2))); 26871| 499| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 26872| 499| ((size_t)s[0] * 4)); 26873| 499| wuffs_base__poke_u16le__no_bounds_check( 26874| 499| d + (0 * 2), 26875| 499| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26876| 499| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0))); 26877| | 26878| 499| s += 1 * 1; 26879| 499| d += 1 * 2; 26880| 499| n -= 1; 26881| 499| } 26882| | 26883| 16| return len; 26884| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src: 28446| 23| size_t src_len) { 28447| 23| size_t dst_len4 = dst_len / 4; 28448| 23| size_t src_len4 = src_len / 4; 28449| 23| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28449:16): [True: 5, False: 18] ------------------ 28450| 23| uint8_t* d = dst_ptr; 28451| 23| const uint8_t* s = src_ptr; 28452| 23| size_t n = len; 28453| | 28454| | // TODO: unroll. 28455| | 28456| 2.48k| while (n >= 1) { ------------------ | Branch (28456:10): [True: 2.46k, False: 23] ------------------ 28457| 2.46k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 28458| 2.46k| wuffs_base__poke_u32le__no_bounds_check( 28459| 2.46k| d + (0 * 4), 28460| 2.46k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28461| | 28462| 2.46k| s += 1 * 4; 28463| 2.46k| d += 1 * 4; 28464| 2.46k| n -= 1; 28465| 2.46k| } 28466| | 28467| 23| return len; 28468| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index__src: 29622| 19| size_t src_len) { 29623| 19| if (dst_palette_len != ------------------ | Branch (29623:7): [True: 0, False: 19] ------------------ 29624| 19| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 19|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29625| 0| return 0; 29626| 0| } 29627| 19| size_t dst_len3 = dst_len / 3; 29628| 19| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29628:16): [True: 9, False: 10] ------------------ 29629| 19| uint8_t* d = dst_ptr; 29630| 19| const uint8_t* s = src_ptr; 29631| 19| size_t n = len; 29632| | 29633| 19| const size_t loop_unroll_count = 4; 29634| | 29635| | // The comparison in the while condition is ">", not ">=", because with 29636| | // ">=", the last 4-byte store could write past the end of the dst slice. 29637| | // 29638| | // Each 4-byte store writes one too many bytes, but a subsequent store 29639| | // will overwrite that with the correct byte. There is always another 29640| | // store, whether a 4-byte store in this loop or a 1-byte store in the 29641| | // next loop. 29642| 130| while (n > loop_unroll_count) { ------------------ | Branch (29642:10): [True: 111, False: 19] ------------------ 29643| 111| wuffs_base__poke_u32le__no_bounds_check( 29644| 111| d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check( 29645| 111| dst_palette_ptr + ((size_t)s[0] * 4))); 29646| 111| wuffs_base__poke_u32le__no_bounds_check( 29647| 111| d + (1 * 3), wuffs_base__peek_u32le__no_bounds_check( 29648| 111| dst_palette_ptr + ((size_t)s[1] * 4))); 29649| 111| wuffs_base__poke_u32le__no_bounds_check( 29650| 111| d + (2 * 3), wuffs_base__peek_u32le__no_bounds_check( 29651| 111| dst_palette_ptr + ((size_t)s[2] * 4))); 29652| 111| wuffs_base__poke_u32le__no_bounds_check( 29653| 111| d + (3 * 3), wuffs_base__peek_u32le__no_bounds_check( 29654| 111| dst_palette_ptr + ((size_t)s[3] * 4))); 29655| | 29656| 111| s += loop_unroll_count * 1; 29657| 111| d += loop_unroll_count * 3; 29658| 111| n -= loop_unroll_count; 29659| 111| } 29660| | 29661| 60| while (n >= 1) { ------------------ | Branch (29661:10): [True: 41, False: 19] ------------------ 29662| 41| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29663| 41| ((size_t)s[0] * 4)); 29664| 41| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29665| | 29666| 41| s += 1 * 1; 29667| 41| d += 1 * 3; 29668| 41| n -= 1; 29669| 41| } 29670| | 29671| 19| return len; 29672| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over: 29681| 18| size_t src_len) { 29682| 18| if (dst_palette_len != ------------------ | Branch (29682:7): [True: 0, False: 18] ------------------ 29683| 18| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 18|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29684| 0| return 0; 29685| 0| } 29686| 18| size_t dst_len3 = dst_len / 3; 29687| 18| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29687:16): [True: 9, False: 9] ------------------ 29688| 18| uint8_t* d = dst_ptr; 29689| 18| const uint8_t* s = src_ptr; 29690| 18| size_t n = len; 29691| | 29692| | // TODO: unroll. 29693| | 29694| 416| while (n >= 1) { ------------------ | Branch (29694:10): [True: 398, False: 18] ------------------ 29695| 398| uint32_t d0 = 29696| 398| wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000; 29697| 398| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29698| 398| ((size_t)s[0] * 4)); 29699| 398| wuffs_base__poke_u24le__no_bounds_check( 29700| 398| d + (0 * 3), 29701| 398| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 29702| | 29703| 398| s += 1 * 1; 29704| 398| d += 1 * 3; 29705| 398| n -= 1; 29706| 398| } 29707| | 29708| 18| return len; 29709| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index__src: 29961| 23| size_t src_len) { 29962| 23| if (dst_palette_len != ------------------ | Branch (29962:7): [True: 0, False: 23] ------------------ 29963| 23| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 23|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29964| 0| return 0; 29965| 0| } 29966| 23| size_t dst_len4 = dst_len / 4; 29967| 23| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (29967:16): [True: 12, False: 11] ------------------ 29968| 23| uint8_t* d = dst_ptr; 29969| 23| const uint8_t* s = src_ptr; 29970| 23| size_t n = len; 29971| | 29972| 23| const size_t loop_unroll_count = 4; 29973| | 29974| 155| while (n >= loop_unroll_count) { ------------------ | Branch (29974:10): [True: 132, False: 23] ------------------ 29975| 132| wuffs_base__poke_u32le__no_bounds_check( 29976| 132| d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check( 29977| 132| dst_palette_ptr + ((size_t)s[0] * 4))); 29978| 132| wuffs_base__poke_u32le__no_bounds_check( 29979| 132| d + (1 * 4), wuffs_base__peek_u32le__no_bounds_check( 29980| 132| dst_palette_ptr + ((size_t)s[1] * 4))); 29981| 132| wuffs_base__poke_u32le__no_bounds_check( 29982| 132| d + (2 * 4), wuffs_base__peek_u32le__no_bounds_check( 29983| 132| dst_palette_ptr + ((size_t)s[2] * 4))); 29984| 132| wuffs_base__poke_u32le__no_bounds_check( 29985| 132| d + (3 * 4), wuffs_base__peek_u32le__no_bounds_check( 29986| 132| dst_palette_ptr + ((size_t)s[3] * 4))); 29987| | 29988| 132| s += loop_unroll_count * 1; 29989| 132| d += loop_unroll_count * 4; 29990| 132| n -= loop_unroll_count; 29991| 132| } 29992| | 29993| 51| while (n >= 1) { ------------------ | Branch (29993:10): [True: 28, False: 23] ------------------ 29994| 28| wuffs_base__poke_u32le__no_bounds_check( 29995| 28| d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check( 29996| 28| dst_palette_ptr + ((size_t)s[0] * 4))); 29997| | 29998| 28| s += 1 * 1; 29999| 28| d += 1 * 4; 30000| 28| n -= 1; 30001| 28| } 30002| | 30003| 23| return len; 30004| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over: 27824| 25| size_t src_len) { 27825| 25| if (dst_palette_len != ------------------ | Branch (27825:7): [True: 0, False: 25] ------------------ 27826| 25| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 25|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 27827| 0| return 0; 27828| 0| } 27829| 25| size_t dst_len4 = dst_len / 4; 27830| 25| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (27830:16): [True: 13, False: 12] ------------------ 27831| 25| uint8_t* d = dst_ptr; 27832| 25| const uint8_t* s = src_ptr; 27833| 25| size_t n = len; 27834| | 27835| | // TODO: unroll. 27836| | 27837| 353| while (n >= 1) { ------------------ | Branch (27837:10): [True: 328, False: 25] ------------------ 27838| 328| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27839| 328| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 27840| 328| ((size_t)s[0] * 4)); 27841| 328| wuffs_base__poke_u32le__no_bounds_check( 27842| 328| d + (0 * 4), 27843| 328| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27844| | 27845| 328| s += 1 * 1; 27846| 328| d += 1 * 4; 27847| 328| n -= 1; 27848| 328| } 27849| | 27850| 25| return len; 27851| 25|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index__src: 30204| 14| size_t src_len) { 30205| 14| if (dst_palette_len != ------------------ | Branch (30205:7): [True: 0, False: 14] ------------------ 30206| 14| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 14|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30207| 0| return 0; 30208| 0| } 30209| 14| size_t dst_len8 = dst_len / 8; 30210| 14| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (30210:16): [True: 6, False: 8] ------------------ 30211| 14| uint8_t* d = dst_ptr; 30212| 14| const uint8_t* s = src_ptr; 30213| 14| size_t n = len; 30214| | 30215| 172| while (n >= 1) { ------------------ | Branch (30215:10): [True: 158, False: 14] ------------------ 30216| 158| wuffs_base__poke_u64le__no_bounds_check( 30217| 158| d + (0 * 8), wuffs_base__color_u32__as__color_u64( 30218| 158| wuffs_base__peek_u32le__no_bounds_check( 30219| 158| dst_palette_ptr + ((size_t)s[0] * 4)))); 30220| | 30221| 158| s += 1 * 1; 30222| 158| d += 1 * 8; 30223| 158| n -= 1; 30224| 158| } 30225| | 30226| 14| return len; 30227| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over: 28225| 44| size_t src_len) { 28226| 44| if (dst_palette_len != ------------------ | Branch (28226:7): [True: 0, False: 44] ------------------ 28227| 44| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 44|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 28228| 0| return 0; 28229| 0| } 28230| 44| size_t dst_len8 = dst_len / 8; 28231| 44| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (28231:16): [True: 32, False: 12] ------------------ 28232| 44| uint8_t* d = dst_ptr; 28233| 44| const uint8_t* s = src_ptr; 28234| 44| size_t n = len; 28235| | 28236| 405| while (n >= 1) { ------------------ | Branch (28236:10): [True: 361, False: 44] ------------------ 28237| 361| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28238| 361| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28239| 361| wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 28240| 361| ((size_t)s[0] * 4))); 28241| 361| wuffs_base__poke_u64le__no_bounds_check( 28242| 361| d + (0 * 8), 28243| 361| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28244| | 28245| 361| s += 1 * 1; 28246| 361| d += 1 * 8; 28247| 361| n -= 1; 28248| 361| } 28249| | 28250| 44| return len; 28251| 44|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over: 28670| 13| size_t src_len) { 28671| 13| if (dst_palette_len != ------------------ | Branch (28671:7): [True: 0, False: 13] ------------------ 28672| 13| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 13|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 28673| 0| return 0; 28674| 0| } 28675| 13| size_t dst_len4 = dst_len / 4; 28676| 13| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (28676:16): [True: 9, False: 4] ------------------ 28677| 13| uint8_t* d = dst_ptr; 28678| 13| const uint8_t* s = src_ptr; 28679| 13| size_t n = len; 28680| | 28681| | // TODO: unroll. 28682| | 28683| 195| while (n >= 1) { ------------------ | Branch (28683:10): [True: 182, False: 13] ------------------ 28684| 182| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28685| 182| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 28686| 182| ((size_t)s[0] * 4)); 28687| 182| wuffs_base__poke_u32le__no_bounds_check( 28688| 182| d + (0 * 4), 28689| 182| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28690| | 28691| 182| s += 1 * 1; 28692| 182| d += 1 * 4; 28693| 182| n -= 1; 28694| 182| } 28695| | 28696| 13| return len; 28697| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src: 28706| 26| size_t src_len) { 28707| 26| size_t dst_len4 = dst_len / 4; 28708| 26| size_t src_len4 = src_len / 4; 28709| 26| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28709:16): [True: 5, False: 21] ------------------ 28710| 26| uint8_t* d = dst_ptr; 28711| 26| const uint8_t* s = src_ptr; 28712| 26| size_t n = len; 28713| | 28714| | // TODO: unroll. 28715| | 28716| 2.84k| while (n >= 1) { ------------------ | Branch (28716:10): [True: 2.81k, False: 26] ------------------ 28717| 2.81k| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28718| 2.81k| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28719| 2.81k| wuffs_base__poke_u32le__no_bounds_check( 28720| 2.81k| d + (0 * 4), 28721| 2.81k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28722| | 28723| 2.81k| s += 1 * 4; 28724| 2.81k| d += 1 * 4; 28725| 2.81k| n -= 1; 28726| 2.81k| } 28727| | 28728| 26| return len; 28729| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx: 25865| 113| size_t src_len) { 25866| 113| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25866:17): [True: 0, False: 113] ------------------ 25867| 113| uint8_t* d = dst_ptr; 25868| 113| const uint8_t* s = src_ptr; 25869| | 25870| 113| size_t n = len; 25871| 29.0k| while (n--) { ------------------ | Branch (25871:10): [True: 28.9k, False: 113] ------------------ 25872| 28.9k| uint8_t s0 = s[0]; 25873| 28.9k| uint8_t s1 = s[1]; 25874| 28.9k| uint8_t s2 = s[2]; 25875| 28.9k| uint8_t s3 = s[3]; 25876| 28.9k| d[0] = s2; 25877| 28.9k| d[1] = s1; 25878| 28.9k| d[2] = s0; 25879| 28.9k| d[3] = s3; 25880| 28.9k| s += 4; 25881| 28.9k| d += 4; 25882| 28.9k| } 25883| 113| return len; 25884| 113|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary: 31564| 345| wuffs_base__pixel_blend blend) { 31565| 345| switch (dst_pixfmt.repr) { ------------------ | Branch (31565:11): [True: 325, False: 20] ------------------ 31566| 37| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 37|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31566:5): [True: 37, False: 308] ------------------ 31567| 37| if (wuffs_private_impl__swizzle_squash_align4_y_8888( ------------------ | Branch (31567:11): [True: 0, False: 37] ------------------ 31568| 37| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31569| 37| src_palette.len, false) != 31570| 37| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 37|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31571| 0| return NULL; 31572| 0| } 31573| 37| switch (blend) { ------------------ | Branch (31573:15): [True: 37, False: 0] ------------------ 31574| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31574:9): [True: 4, False: 33] ------------------ 31575| 4| return wuffs_private_impl__swizzle_y__index__src; 31576| 33| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 33|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31576:9): [True: 33, False: 4] ------------------ 31577| 33| return wuffs_private_impl__swizzle_y__index_binary_alpha__src_over; 31578| 37| } 31579| 0| return NULL; 31580| | 31581| 6| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 6|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (31581:5): [True: 6, False: 339] ------------------ 31582| 6| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4959| 6|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (31582:5): [True: 0, False: 345] ------------------ 31583| 14| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4960| 14|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (31583:5): [True: 8, False: 337] ------------------ 31584| 14| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31584:11): [True: 0, False: 14] ------------------ 31585| 14| src_palette) != 31586| 14| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 14|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31587| 0| return NULL; 31588| 0| } 31589| 14| switch (blend) { ------------------ | Branch (31589:15): [True: 6, False: 8] ------------------ 31590| 6| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31590:9): [True: 6, False: 8] ------------------ 31591| 6| return wuffs_private_impl__swizzle_copy_1_1; 31592| 14| } 31593| 8| return NULL; 31594| | 31595| 35| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 35|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31595:5): [True: 35, False: 310] ------------------ 31596| 35| if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888( ------------------ | Branch (31596:11): [True: 0, False: 35] ------------------ 31597| 35| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31598| 35| src_palette.len, false) != 31599| 35| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 35|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31600| 0| return NULL; 31601| 0| } 31602| 35| switch (blend) { ------------------ | Branch (31602:15): [True: 35, False: 0] ------------------ 31603| 12| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31603:9): [True: 12, False: 23] ------------------ 31604| 12| return wuffs_private_impl__swizzle_bgr_565__index__src; 31605| 23| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 23|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31605:9): [True: 23, False: 12] ------------------ 31606| 23| return wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over; 31607| 35| } 31608| 0| return NULL; 31609| | 31610| 61| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 61|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31610:5): [True: 61, False: 284] ------------------ 31611| 61| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31611:11): [True: 0, False: 61] ------------------ 31612| 61| src_palette) != 31613| 61| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 61|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31614| 0| return NULL; 31615| 0| } 31616| 61| switch (blend) { ------------------ | Branch (31616:15): [True: 61, False: 0] ------------------ 31617| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31617:9): [True: 4, False: 57] ------------------ 31618| 4| return wuffs_private_impl__swizzle_xxx__index__src; 31619| 57| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 57|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31619:9): [True: 57, False: 4] ------------------ 31620| 57| return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over; 31621| 61| } 31622| 0| return NULL; 31623| | 31624| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31624:5): [True: 18, False: 327] ------------------ 31625| 48| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 48|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31625:5): [True: 30, False: 315] ------------------ 31626| 48| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 48|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31626:5): [True: 0, False: 345] ------------------ 31627| 48| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31627:11): [True: 0, False: 48] ------------------ 31628| 48| src_palette) != 31629| 48| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 48|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31630| 0| return NULL; 31631| 0| } 31632| 48| switch (blend) { ------------------ | Branch (31632:15): [True: 48, False: 0] ------------------ 31633| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31633:9): [True: 2, False: 46] ------------------ 31634| 2| return wuffs_private_impl__swizzle_xxxx__index__src; 31635| 46| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 46|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31635:9): [True: 46, False: 2] ------------------ 31636| 46| return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over; 31637| 48| } 31638| 0| return NULL; 31639| | 31640| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31640:5): [True: 17, False: 328] ------------------ 31641| 41| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 41|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31641:5): [True: 24, False: 321] ------------------ 31642| 41| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31642:11): [True: 0, False: 41] ------------------ 31643| 41| src_palette) != 31644| 41| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 41|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31645| 0| return NULL; 31646| 0| } 31647| 41| switch (blend) { ------------------ | Branch (31647:15): [True: 41, False: 0] ------------------ 31648| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31648:9): [True: 9, False: 32] ------------------ 31649| 9| return wuffs_private_impl__swizzle_xxxxxxxx__index__src; 31650| 32| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31650:9): [True: 32, False: 9] ------------------ 31651| 32| return wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over; 31652| 41| } 31653| 0| return NULL; 31654| | 31655| 37| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 37|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31655:5): [True: 37, False: 308] ------------------ 31656| 37| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31656:11): [True: 0, False: 37] ------------------ 31657| 37| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31658| 37| src_palette.len) != 31659| 37| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 37|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31660| 0| return NULL; 31661| 0| } 31662| 37| switch (blend) { ------------------ | Branch (31662:15): [True: 37, False: 0] ------------------ 31663| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31663:9): [True: 3, False: 34] ------------------ 31664| 3| return wuffs_private_impl__swizzle_xxx__index__src; 31665| 34| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 34|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31665:9): [True: 34, False: 3] ------------------ 31666| 34| return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over; 31667| 37| } 31668| 0| return NULL; 31669| | 31670| 23| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31670:5): [True: 23, False: 322] ------------------ 31671| 52| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 52|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31671:5): [True: 29, False: 316] ------------------ 31672| 52| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 52|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31672:5): [True: 0, False: 345] ------------------ 31673| 52| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31673:11): [True: 0, False: 52] ------------------ 31674| 52| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31675| 52| src_palette.len) != 31676| 52| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 52|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31677| 0| return NULL; 31678| 0| } 31679| 52| switch (blend) { ------------------ | Branch (31679:15): [True: 52, False: 0] ------------------ 31680| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31680:9): [True: 5, False: 47] ------------------ 31681| 5| return wuffs_private_impl__swizzle_xxxx__index__src; 31682| 47| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 47|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31682:9): [True: 47, False: 5] ------------------ 31683| 47| return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over; 31684| 52| } 31685| 0| return NULL; 31686| 345| } 31687| 20| return NULL; 31688| 345|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_binary_alpha__src_over: 31036| 33| size_t src_len) { 31037| 33| if (dst_palette_len != ------------------ | Branch (31037:7): [True: 0, False: 33] ------------------ 31038| 33| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 33|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31039| 0| return 0; 31040| 0| } 31041| 33| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (31041:16): [True: 7, False: 26] ------------------ 31042| 33| uint8_t* d = dst_ptr; 31043| 33| const uint8_t* s = src_ptr; 31044| 33| size_t n = len; 31045| | 31046| | // TODO: unroll. 31047| | 31048| 2.85k| while (n >= 1) { ------------------ | Branch (31048:10): [True: 2.81k, False: 33] ------------------ 31049| 2.81k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 31050| 2.81k| ((size_t)s[0] * 4)); 31051| 2.81k| if (s0) { ------------------ | Branch (31051:9): [True: 2.28k, False: 536] ------------------ 31052| 2.28k| d[0] = (uint8_t)s0; 31053| 2.28k| } 31054| | 31055| 2.81k| s += 1 * 1; 31056| 2.81k| d += 1 * 1; 31057| 2.81k| n -= 1; 31058| 2.81k| } 31059| | 31060| 33| return len; 31061| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over: 26893| 23| size_t src_len) { 26894| 23| if (dst_palette_len != ------------------ | Branch (26894:7): [True: 0, False: 23] ------------------ 26895| 23| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 23|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26896| 0| return 0; 26897| 0| } 26898| 23| size_t dst_len2 = dst_len / 2; 26899| 23| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26899:16): [True: 8, False: 15] ------------------ 26900| 23| uint8_t* d = dst_ptr; 26901| 23| const uint8_t* s = src_ptr; 26902| 23| size_t n = len; 26903| | 26904| | // TODO: unroll. 26905| | 26906| 715| while (n >= 1) { ------------------ | Branch (26906:10): [True: 692, False: 23] ------------------ 26907| 692| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 26908| 692| ((size_t)s[0] * 4)); 26909| 692| if (s0) { ------------------ | Branch (26909:9): [True: 608, False: 84] ------------------ 26910| 608| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)s0); 26911| 608| } 26912| | 26913| 692| s += 1 * 1; 26914| 692| d += 1 * 2; 26915| 692| n -= 1; 26916| 692| } 26917| | 26918| 23| return len; 26919| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over: 29718| 91| size_t src_len) { 29719| 91| if (dst_palette_len != ------------------ | Branch (29719:7): [True: 0, False: 91] ------------------ 29720| 91| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 91|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29721| 0| return 0; 29722| 0| } 29723| 91| size_t dst_len3 = dst_len / 3; 29724| 91| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29724:16): [True: 52, False: 39] ------------------ 29725| 91| uint8_t* d = dst_ptr; 29726| 91| const uint8_t* s = src_ptr; 29727| 91| size_t n = len; 29728| | 29729| 91| const size_t loop_unroll_count = 4; 29730| | 29731| 1.00k| while (n >= loop_unroll_count) { ------------------ | Branch (29731:10): [True: 916, False: 91] ------------------ 29732| 916| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29733| 916| ((size_t)s[0] * 4)); 29734| 916| if (s0) { ------------------ | Branch (29734:9): [True: 732, False: 184] ------------------ 29735| 732| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29736| 732| } 29737| 916| uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29738| 916| ((size_t)s[1] * 4)); 29739| 916| if (s1) { ------------------ | Branch (29739:9): [True: 741, False: 175] ------------------ 29740| 741| wuffs_base__poke_u24le__no_bounds_check(d + (1 * 3), s1); 29741| 741| } 29742| 916| uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29743| 916| ((size_t)s[2] * 4)); 29744| 916| if (s2) { ------------------ | Branch (29744:9): [True: 738, False: 178] ------------------ 29745| 738| wuffs_base__poke_u24le__no_bounds_check(d + (2 * 3), s2); 29746| 738| } 29747| 916| uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29748| 916| ((size_t)s[3] * 4)); 29749| 916| if (s3) { ------------------ | Branch (29749:9): [True: 738, False: 178] ------------------ 29750| 738| wuffs_base__poke_u24le__no_bounds_check(d + (3 * 3), s3); 29751| 738| } 29752| | 29753| 916| s += loop_unroll_count * 1; 29754| 916| d += loop_unroll_count * 3; 29755| 916| n -= loop_unroll_count; 29756| 916| } 29757| | 29758| 246| while (n >= 1) { ------------------ | Branch (29758:10): [True: 155, False: 91] ------------------ 29759| 155| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29760| 155| ((size_t)s[0] * 4)); 29761| 155| if (s0) { ------------------ | Branch (29761:9): [True: 131, False: 24] ------------------ 29762| 131| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29763| 131| } 29764| | 29765| 155| s += 1 * 1; 29766| 155| d += 1 * 3; 29767| 155| n -= 1; 29768| 155| } 29769| | 29770| 91| return len; 29771| 91|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over: 30013| 93| size_t src_len) { 30014| 93| if (dst_palette_len != ------------------ | Branch (30014:7): [True: 0, False: 93] ------------------ 30015| 93| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 93|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30016| 0| return 0; 30017| 0| } 30018| 93| size_t dst_len4 = dst_len / 4; 30019| 93| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (30019:16): [True: 63, False: 30] ------------------ 30020| 93| uint8_t* d = dst_ptr; 30021| 93| const uint8_t* s = src_ptr; 30022| 93| size_t n = len; 30023| | 30024| 93| const size_t loop_unroll_count = 4; 30025| | 30026| 877| while (n >= loop_unroll_count) { ------------------ | Branch (30026:10): [True: 784, False: 93] ------------------ 30027| 784| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30028| 784| ((size_t)s[0] * 4)); 30029| 784| if (s0) { ------------------ | Branch (30029:9): [True: 661, False: 123] ------------------ 30030| 661| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 30031| 661| } 30032| 784| uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30033| 784| ((size_t)s[1] * 4)); 30034| 784| if (s1) { ------------------ | Branch (30034:9): [True: 649, False: 135] ------------------ 30035| 649| wuffs_base__poke_u32le__no_bounds_check(d + (1 * 4), s1); 30036| 649| } 30037| 784| uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30038| 784| ((size_t)s[2] * 4)); 30039| 784| if (s2) { ------------------ | Branch (30039:9): [True: 654, False: 130] ------------------ 30040| 654| wuffs_base__poke_u32le__no_bounds_check(d + (2 * 4), s2); 30041| 654| } 30042| 784| uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30043| 784| ((size_t)s[3] * 4)); 30044| 784| if (s3) { ------------------ | Branch (30044:9): [True: 654, False: 130] ------------------ 30045| 654| wuffs_base__poke_u32le__no_bounds_check(d + (3 * 4), s3); 30046| 654| } 30047| | 30048| 784| s += loop_unroll_count * 1; 30049| 784| d += loop_unroll_count * 4; 30050| 784| n -= loop_unroll_count; 30051| 784| } 30052| | 30053| 250| while (n >= 1) { ------------------ | Branch (30053:10): [True: 157, False: 93] ------------------ 30054| 157| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30055| 157| ((size_t)s[0] * 4)); 30056| 157| if (s0) { ------------------ | Branch (30056:9): [True: 134, False: 23] ------------------ 30057| 134| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 30058| 134| } 30059| | 30060| 157| s += 1 * 1; 30061| 157| d += 1 * 4; 30062| 157| n -= 1; 30063| 157| } 30064| | 30065| 93| return len; 30066| 93|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over: 30236| 32| size_t src_len) { 30237| 32| if (dst_palette_len != ------------------ | Branch (30237:7): [True: 0, False: 32] ------------------ 30238| 32| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 32|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30239| 0| return 0; 30240| 0| } 30241| 32| size_t dst_len8 = dst_len / 8; 30242| 32| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (30242:16): [True: 28, False: 4] ------------------ 30243| 32| uint8_t* d = dst_ptr; 30244| 32| const uint8_t* s = src_ptr; 30245| 32| size_t n = len; 30246| | 30247| 519| while (n >= 1) { ------------------ | Branch (30247:10): [True: 487, False: 32] ------------------ 30248| 487| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30249| 487| ((size_t)s[0] * 4)); 30250| 487| if (s0) { ------------------ | Branch (30250:9): [True: 377, False: 110] ------------------ 30251| 377| wuffs_base__poke_u64le__no_bounds_check( 30252| 377| d + (0 * 8), wuffs_base__color_u32__as__color_u64(s0)); 30253| 377| } 30254| | 30255| 487| s += 1 * 1; 30256| 487| d += 1 * 8; 30257| 487| n -= 1; 30258| 487| } 30259| | 30260| 32| return len; 30261| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr_565: 31696| 113| wuffs_base__pixel_blend blend) { 31697| 113| switch (dst_pixfmt.repr) { ------------------ | Branch (31697:11): [True: 102, False: 11] ------------------ 31698| 21| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 21|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31698:5): [True: 21, False: 92] ------------------ 31699| 21| return wuffs_private_impl__swizzle_y__bgr_565; 31700| | 31701| 4| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31701:5): [True: 4, False: 109] ------------------ 31702| 4| return wuffs_private_impl__swizzle_copy_2_2; 31703| | 31704| 11| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31704:5): [True: 11, False: 102] ------------------ 31705| 11| return wuffs_private_impl__swizzle_bgr__bgr_565; 31706| | 31707| 2| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 2|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31707:5): [True: 2, False: 111] ------------------ 31708| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31708:5): [True: 4, False: 109] ------------------ 31709| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31709:5): [True: 0, False: 113] ------------------ 31710| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31710:5): [True: 9, False: 104] ------------------ 31711| 15| return wuffs_private_impl__swizzle_bgrw__bgr_565; 31712| | 31713| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31713:5): [True: 4, False: 109] ------------------ 31714| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31714:5): [True: 11, False: 102] ------------------ 31715| 15| return wuffs_private_impl__swizzle_bgrw_4x16le__bgr_565; 31716| | 31717| 15| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 15|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31717:5): [True: 15, False: 98] ------------------ 31718| 15| return wuffs_private_impl__swizzle_rgb__bgr_565; 31719| | 31720| 4| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 4|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31720:5): [True: 4, False: 109] ------------------ 31721| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31721:5): [True: 17, False: 96] ------------------ 31722| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31722:5): [True: 0, False: 113] ------------------ 31723| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31723:5): [True: 0, False: 113] ------------------ 31724| 21| return wuffs_private_impl__swizzle_rgbw__bgr_565; 31725| 113| } 31726| 11| return NULL; 31727| 113|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr_565: 30380| 21| size_t src_len) { 30381| 21| size_t src_len2 = src_len / 2; 30382| 21| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30382:16): [True: 2, False: 19] ------------------ 30383| 21| uint8_t* d = dst_ptr; 30384| 21| const uint8_t* s = src_ptr; 30385| 21| size_t n = len; 30386| | 30387| | // TODO: unroll. 30388| | 30389| 759| while (n >= 1) { ------------------ | Branch (30389:10): [True: 738, False: 21] ------------------ 30390| 738| uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 30391| 738| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))); 30392| 738| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30393| | 30394| 738| s += 1 * 2; 30395| 738| d += 1 * 1; 30396| 738| n -= 1; 30397| 738| } 30398| | 30399| 21| return len; 30400| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgr_565: 26929| 11| size_t src_len) { 26930| 11| size_t dst_len3 = dst_len / 3; 26931| 11| size_t src_len2 = src_len / 2; 26932| 11| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (26932:16): [True: 3, False: 8] ------------------ 26933| 11| uint8_t* d = dst_ptr; 26934| 11| const uint8_t* s = src_ptr; 26935| 11| size_t n = len; 26936| | 26937| | // TODO: unroll. 26938| | 26939| 302| while (n >= 1) { ------------------ | Branch (26939:10): [True: 291, False: 11] ------------------ 26940| 291| uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 26941| 291| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))); 26942| 291| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26943| | 26944| 291| s += 1 * 2; 26945| 291| d += 1 * 3; 26946| 291| n -= 1; 26947| 291| } 26948| | 26949| 11| return len; 26950| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr_565: 29060| 15| size_t src_len) { 29061| 15| size_t dst_len4 = dst_len / 4; 29062| 15| size_t src_len2 = src_len / 2; 29063| 15| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (29063:16): [True: 10, False: 5] ------------------ 29064| 15| uint8_t* d = dst_ptr; 29065| 15| const uint8_t* s = src_ptr; 29066| 15| size_t n = len; 29067| | 29068| | // TODO: unroll. 29069| | 29070| 181| while (n >= 1) { ------------------ | Branch (29070:10): [True: 166, False: 15] ------------------ 29071| 166| wuffs_base__poke_u32le__no_bounds_check( 29072| 166| d + (0 * 4), wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29073| 166| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))); 29074| | 29075| 166| s += 1 * 2; 29076| 166| d += 1 * 4; 29077| 166| n -= 1; 29078| 166| } 29079| | 29080| 15| return len; 29081| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr_565: 29329| 15| size_t src_len) { 29330| 15| size_t dst_len8 = dst_len / 8; 29331| 15| size_t src_len2 = src_len / 2; 29332| 15| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (29332:16): [True: 9, False: 6] ------------------ 29333| 15| uint8_t* d = dst_ptr; 29334| 15| const uint8_t* s = src_ptr; 29335| 15| size_t n = len; 29336| | 29337| 136| while (n >= 1) { ------------------ | Branch (29337:10): [True: 121, False: 15] ------------------ 29338| 121| wuffs_base__poke_u64le__no_bounds_check( 29339| 121| d + (0 * 8), 29340| 121| wuffs_base__color_u32__as__color_u64( 29341| 121| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29342| 121| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 29343| | 29344| 121| s += 1 * 2; 29345| 121| d += 1 * 8; 29346| 121| n -= 1; 29347| 121| } 29348| | 29349| 15| return len; 29350| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgb__bgr_565: 29430| 15| size_t src_len) { 29431| 15| size_t dst_len3 = dst_len / 3; 29432| 15| size_t src_len2 = src_len / 2; 29433| 15| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29433:16): [True: 5, False: 10] ------------------ 29434| 15| uint8_t* d = dst_ptr; 29435| 15| const uint8_t* s = src_ptr; 29436| 15| size_t n = len; 29437| | 29438| | // TODO: unroll. 29439| | 29440| 294| while (n >= 1) { ------------------ | Branch (29440:10): [True: 279, False: 15] ------------------ 29441| 279| wuffs_base__poke_u24le__no_bounds_check( 29442| 279| d + (0 * 3), 29443| 279| wuffs_base__color_swap_u32_argb_abgr( 29444| 279| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29445| 279| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 29446| | 29447| 279| s += 1 * 2; 29448| 279| d += 1 * 3; 29449| 279| n -= 1; 29450| 279| } 29451| | 29452| 15| return len; 29453| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgbw__bgr_565: 29589| 21| size_t src_len) { 29590| 21| size_t dst_len4 = dst_len / 4; 29591| 21| size_t src_len2 = src_len / 2; 29592| 21| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (29592:16): [True: 7, False: 14] ------------------ 29593| 21| uint8_t* d = dst_ptr; 29594| 21| const uint8_t* s = src_ptr; 29595| 21| size_t n = len; 29596| | 29597| | // TODO: unroll. 29598| | 29599| 491| while (n >= 1) { ------------------ | Branch (29599:10): [True: 470, False: 21] ------------------ 29600| 470| wuffs_base__poke_u32le__no_bounds_check( 29601| 470| d + (0 * 4), 29602| 470| wuffs_base__color_swap_u32_argb_abgr( 29603| 470| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29604| 470| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 29605| | 29606| 470| s += 1 * 2; 29607| 470| d += 1 * 4; 29608| 470| n -= 1; 29609| 470| } 29610| | 29611| 21| return len; 29612| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr: 31735| 125| wuffs_base__pixel_blend blend) { 31736| 125| switch (dst_pixfmt.repr) { ------------------ | Branch (31736:11): [True: 111, False: 14] ------------------ 31737| 20| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31737:5): [True: 20, False: 105] ------------------ 31738| 20| return wuffs_private_impl__swizzle_y__bgr; 31739| | 31740| 20| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31740:5): [True: 20, False: 105] ------------------ 31741| 20| return wuffs_private_impl__swizzle_bgr_565__bgr; 31742| | 31743| 8| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 8|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31743:5): [True: 8, False: 117] ------------------ 31744| 8| return wuffs_private_impl__swizzle_copy_3_3; 31745| | 31746| 2| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 2|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31746:5): [True: 2, False: 123] ------------------ 31747| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31747:5): [True: 7, False: 118] ------------------ 31748| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31748:5): [True: 0, False: 125] ------------------ 31749| 23| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 23|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31749:5): [True: 14, False: 111] ------------------ 31750| 23|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31751| 23| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31751:11): [True: 23, False: 0] ------------------ 31752| 23| return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42; 31753| 23| } 31754| 0|#endif 31755| 0| return wuffs_private_impl__swizzle_bgrw__bgr; 31756| | 31757| 8| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31757:5): [True: 8, False: 117] ------------------ 31758| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31758:5): [True: 1, False: 124] ------------------ 31759| 9| return wuffs_private_impl__swizzle_bgrw_4x16le__bgr; 31760| | 31761| 15| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 15|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31761:5): [True: 15, False: 110] ------------------ 31762| 15| return wuffs_private_impl__swizzle_swap_rgb_bgr; 31763| | 31764| 10| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 10|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31764:5): [True: 10, False: 115] ------------------ 31765| 16| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31765:5): [True: 6, False: 119] ------------------ 31766| 16| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31766:5): [True: 0, False: 125] ------------------ 31767| 16| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31767:5): [True: 0, False: 125] ------------------ 31768| 16|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31769| 16| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31769:11): [True: 16, False: 0] ------------------ 31770| 16| return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42; 31771| 16| } 31772| 0|#endif 31773| 0| return wuffs_private_impl__swizzle_bgrw__rgb; 31774| 125| } 31775| 14| return NULL; 31776| 125|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr: 30352| 20| size_t src_len) { 30353| 20| size_t src_len3 = src_len / 3; 30354| 20| size_t len = (dst_len < src_len3) ? dst_len : src_len3; ------------------ | Branch (30354:16): [True: 4, False: 16] ------------------ 30355| 20| uint8_t* d = dst_ptr; 30356| 20| const uint8_t* s = src_ptr; 30357| 20| size_t n = len; 30358| | 30359| | // TODO: unroll. 30360| | 30361| 438| while (n >= 1) { ------------------ | Branch (30361:10): [True: 418, False: 20] ------------------ 30362| 418| uint32_t s0 = 30363| 418| 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(s + (0 * 3)); 30364| 418| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30365| | 30366| 418| s += 1 * 3; 30367| 418| d += 1 * 1; 30368| 418| n -= 1; 30369| 418| } 30370| | 30371| 20| return len; 30372| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgr: 26009| 20| size_t src_len) { 26010| 20| size_t dst_len2 = dst_len / 2; 26011| 20| size_t src_len3 = src_len / 3; 26012| 20| size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3; ------------------ | Branch (26012:16): [True: 4, False: 16] ------------------ 26013| 20| uint8_t* d = dst_ptr; 26014| 20| const uint8_t* s = src_ptr; 26015| 20| size_t n = len; 26016| | 26017| | // TODO: unroll. 26018| | 26019| 340| while (n >= 1) { ------------------ | Branch (26019:10): [True: 320, False: 20] ------------------ 26020| 320| uint32_t b5 = (uint32_t)(s[0] >> 3); 26021| 320| uint32_t g6 = (uint32_t)(s[1] >> 2); 26022| 320| uint32_t r5 = (uint32_t)(s[2] >> 3); 26023| 320| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 26024| 320| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26025| | 26026| 320| s += 1 * 3; 26027| 320| d += 1 * 2; 26028| 320| n -= 1; 26029| 320| } 26030| | 26031| 20| return len; 26032| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_3_3: 25959| 15| size_t src_len) { 25960| 15| size_t dst_len3 = dst_len / 3; 25961| 15| size_t src_len3 = src_len / 3; 25962| 15| size_t len = (dst_len3 < src_len3) ? dst_len3 : src_len3; ------------------ | Branch (25962:16): [True: 5, False: 10] ------------------ 25963| 15| if (len > 0) { ------------------ | Branch (25963:7): [True: 12, False: 3] ------------------ 25964| 12| memmove(dst_ptr, src_ptr, len * 3); 25965| 12| } 25966| 15| return len; 25967| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42: 29121| 34| size_t src_len) { 29122| 34| size_t dst_len4 = dst_len / 4; 29123| 34| size_t src_len3 = src_len / 3; 29124| 34| size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3; ------------------ | Branch (29124:16): [True: 13, False: 21] ------------------ 29125| 34| uint8_t* d = dst_ptr; 29126| 34| const uint8_t* s = src_ptr; 29127| 34| size_t n = len; 29128| | 29129| 34| __m128i shuffle = _mm_set_epi8(+0x00, +0x0B, +0x0A, +0x09, // 29130| 34| +0x00, +0x08, +0x07, +0x06, // 29131| 34| +0x00, +0x05, +0x04, +0x03, // 29132| 34| +0x00, +0x02, +0x01, +0x00); 29133| 34| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 29134| 34| -0x01, +0x00, +0x00, +0x00, // 29135| 34| -0x01, +0x00, +0x00, +0x00, // 29136| 34| -0x01, +0x00, +0x00, +0x00); 29137| | 29138| 174| while (n >= 6) { ------------------ | Branch (29138:10): [True: 140, False: 34] ------------------ 29139| 140| __m128i x; 29140| 140| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 29141| 140| x = _mm_shuffle_epi8(x, shuffle); 29142| 140| x = _mm_or_si128(x, or_ff); 29143| 140| _mm_storeu_si128((__m128i*)(void*)d, x); 29144| | 29145| 140| s += 4 * 3; 29146| 140| d += 4 * 4; 29147| 140| n -= 4; 29148| 140| } 29149| | 29150| 120| while (n >= 1) { ------------------ | Branch (29150:10): [True: 86, False: 34] ------------------ 29151| 86| uint8_t b0 = s[0]; 29152| 86| uint8_t b1 = s[1]; 29153| 86| uint8_t b2 = s[2]; 29154| 86| d[0] = b0; 29155| 86| d[1] = b1; 29156| 86| d[2] = b2; 29157| 86| d[3] = 0xFF; 29158| | 29159| 86| s += 1 * 3; 29160| 86| d += 1 * 4; 29161| 86| n -= 1; 29162| 86| } 29163| | 29164| 34| return len; 29165| 34|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr: 29294| 9| size_t src_len) { 29295| 9| size_t dst_len8 = dst_len / 8; 29296| 9| size_t src_len3 = src_len / 3; 29297| 9| size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3; ------------------ | Branch (29297:16): [True: 2, False: 7] ------------------ 29298| 9| uint8_t* d = dst_ptr; 29299| 9| const uint8_t* s = src_ptr; 29300| 9| size_t n = len; 29301| | 29302| 93| while (n >= 1) { ------------------ | Branch (29302:10): [True: 84, False: 9] ------------------ 29303| 84| uint8_t s0 = s[0]; 29304| 84| uint8_t s1 = s[1]; 29305| 84| uint8_t s2 = s[2]; 29306| 84| d[0] = s0; 29307| 84| d[1] = s0; 29308| 84| d[2] = s1; 29309| 84| d[3] = s1; 29310| 84| d[4] = s2; 29311| 84| d[5] = s2; 29312| 84| d[6] = 0xFF; 29313| 84| d[7] = 0xFF; 29314| | 29315| 84| s += 1 * 3; 29316| 84| d += 1 * 8; 29317| 84| n -= 1; 29318| 84| } 29319| | 29320| 9| return len; 29321| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgb_bgr: 25792| 22| size_t src_len) { 25793| 22| size_t len = (dst_len < src_len ? dst_len : src_len) / 3; ------------------ | Branch (25793:17): [True: 2, False: 20] ------------------ 25794| 22| uint8_t* d = dst_ptr; 25795| 22| const uint8_t* s = src_ptr; 25796| | 25797| 22| size_t n = len; 25798| 608| while (n--) { ------------------ | Branch (25798:10): [True: 586, False: 22] ------------------ 25799| 586| uint8_t s0 = s[0]; 25800| 586| uint8_t s1 = s[1]; 25801| 586| uint8_t s2 = s[2]; 25802| 586| d[0] = s2; 25803| 586| d[1] = s1; 25804| 586| d[2] = s0; 25805| 586| s += 3; 25806| 586| d += 3; 25807| 586| } 25808| 22| return len; 25809| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42: 29174| 31| size_t src_len) { 29175| 31| size_t dst_len4 = dst_len / 4; 29176| 31| size_t src_len3 = src_len / 3; 29177| 31| size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3; ------------------ | Branch (29177:16): [True: 11, False: 20] ------------------ 29178| 31| uint8_t* d = dst_ptr; 29179| 31| const uint8_t* s = src_ptr; 29180| 31| size_t n = len; 29181| | 29182| 31| __m128i shuffle = _mm_set_epi8(+0x00, +0x09, +0x0A, +0x0B, // 29183| 31| +0x00, +0x06, +0x07, +0x08, // 29184| 31| +0x00, +0x03, +0x04, +0x05, // 29185| 31| +0x00, +0x00, +0x01, +0x02); 29186| 31| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 29187| 31| -0x01, +0x00, +0x00, +0x00, // 29188| 31| -0x01, +0x00, +0x00, +0x00, // 29189| 31| -0x01, +0x00, +0x00, +0x00); 29190| | 29191| 192| while (n >= 6) { ------------------ | Branch (29191:10): [True: 161, False: 31] ------------------ 29192| 161| __m128i x; 29193| 161| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 29194| 161| x = _mm_shuffle_epi8(x, shuffle); 29195| 161| x = _mm_or_si128(x, or_ff); 29196| 161| _mm_storeu_si128((__m128i*)(void*)d, x); 29197| | 29198| 161| s += 4 * 3; 29199| 161| d += 4 * 4; 29200| 161| n -= 4; 29201| 161| } 29202| | 29203| 110| while (n >= 1) { ------------------ | Branch (29203:10): [True: 79, False: 31] ------------------ 29204| 79| uint8_t b0 = s[0]; 29205| 79| uint8_t b1 = s[1]; 29206| 79| uint8_t b2 = s[2]; 29207| 79| d[0] = b2; 29208| 79| d[1] = b1; 29209| 79| d[2] = b0; 29210| 79| d[3] = 0xFF; 29211| | 29212| 79| s += 1 * 3; 29213| 79| d += 1 * 4; 29214| 79| n -= 1; 29215| 79| } 29216| | 29217| 31| return len; 29218| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul: 31784| 216| wuffs_base__pixel_blend blend) { 31785| 216| switch (dst_pixfmt.repr) { ------------------ | Branch (31785:11): [True: 204, False: 12] ------------------ 31786| 26| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 26|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31786:5): [True: 26, False: 190] ------------------ 31787| 26| switch (blend) { ------------------ | Branch (31787:15): [True: 26, False: 0] ------------------ 31788| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31788:9): [True: 16, False: 10] ------------------ 31789| 16| return wuffs_private_impl__swizzle_y__bgra_nonpremul__src; 31790| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31790:9): [True: 10, False: 16] ------------------ 31791| 10| return wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over; 31792| 26| } 31793| 0| return NULL; 31794| | 31795| 33| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 33|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31795:5): [True: 33, False: 183] ------------------ 31796| 33| switch (blend) { ------------------ | Branch (31796:15): [True: 33, False: 0] ------------------ 31797| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31797:9): [True: 18, False: 15] ------------------ 31798| 18| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src; 31799| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31799:9): [True: 15, False: 18] ------------------ 31800| 15| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src_over; 31801| 33| } 31802| 0| return NULL; 31803| | 31804| 18| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31804:5): [True: 18, False: 198] ------------------ 31805| 18| switch (blend) { ------------------ | Branch (31805:15): [True: 18, False: 0] ------------------ 31806| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31806:9): [True: 3, False: 15] ------------------ 31807| 3| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src; 31808| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31808:9): [True: 15, False: 3] ------------------ 31809| 15| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over; 31810| 18| } 31811| 0| return NULL; 31812| | 31813| 10| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31813:5): [True: 10, False: 206] ------------------ 31814| 10| switch (blend) { ------------------ | Branch (31814:15): [True: 10, False: 0] ------------------ 31815| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31815:9): [True: 1, False: 9] ------------------ 31816| 1| return wuffs_private_impl__swizzle_copy_4_4; 31817| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31817:9): [True: 9, False: 1] ------------------ 31818| 9| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over; 31819| 10| } 31820| 0| return NULL; 31821| | 31822| 39| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 39|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31822:5): [True: 39, False: 177] ------------------ 31823| 39| switch (blend) { ------------------ | Branch (31823:15): [True: 39, False: 0] ------------------ 31824| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31824:9): [True: 10, False: 29] ------------------ 31825| 10| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src; 31826| 29| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 29|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31826:9): [True: 29, False: 10] ------------------ 31827| 29| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over; 31828| 39| } 31829| 0| return NULL; 31830| | 31831| 5| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 5|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31831:5): [True: 5, False: 211] ------------------ 31832| 5| switch (blend) { ------------------ | Branch (31832:15): [True: 5, False: 0] ------------------ 31833| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31833:9): [True: 2, False: 3] ------------------ 31834| 2| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src; 31835| 3| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31835:9): [True: 3, False: 2] ------------------ 31836| 3| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over; 31837| 5| } 31838| 0| return NULL; 31839| | 31840| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31840:5): [True: 0, False: 216] ------------------ 31841| 7| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31841:5): [True: 7, False: 209] ------------------ 31842| | // TODO. 31843| 7| break; 31844| | 31845| 21| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31845:5): [True: 21, False: 195] ------------------ 31846| 21| switch (blend) { ------------------ | Branch (31846:15): [True: 21, False: 0] ------------------ 31847| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31847:9): [True: 11, False: 10] ------------------ 31848| 11| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src; 31849| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31849:9): [True: 10, False: 11] ------------------ 31850| 10| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over; 31851| 21| } 31852| 0| return NULL; 31853| | 31854| 24| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 24|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31854:5): [True: 24, False: 192] ------------------ 31855| 24| switch (blend) { ------------------ | Branch (31855:15): [True: 24, False: 0] ------------------ 31856| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31856:9): [True: 18, False: 6] ------------------ 31857| 18|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31858| 18| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31858:15): [True: 18, False: 0] ------------------ 31859| 18| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 31860| 18| } 31861| 0|#endif 31862| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 31863| 6| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31863:9): [True: 6, False: 18] ------------------ 31864| 6| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over; 31865| 24| } 31866| 0| return NULL; 31867| | 31868| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31868:5): [True: 21, False: 195] ------------------ 31869| 21| switch (blend) { ------------------ | Branch (31869:15): [True: 21, False: 0] ------------------ 31870| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31870:9): [True: 8, False: 13] ------------------ 31871| 8| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src; 31872| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31872:9): [True: 13, False: 8] ------------------ 31873| 13| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over; 31874| 21| } 31875| 0| return NULL; 31876| | 31877| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31877:5): [True: 0, False: 216] ------------------ 31878| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31878:5): [True: 0, False: 216] ------------------ 31879| | // TODO. 31880| 0| break; 31881| 216| } 31882| 19| return NULL; 31883| 216|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src: 30408| 16| size_t src_len) { 30409| 16| size_t src_len4 = src_len / 4; 30410| 16| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30410:16): [True: 1, False: 15] ------------------ 30411| 16| uint8_t* d = dst_ptr; 30412| 16| const uint8_t* s = src_ptr; 30413| 16| size_t n = len; 30414| | 30415| | // TODO: unroll. 30416| | 30417| 367| while (n >= 1) { ------------------ | Branch (30417:10): [True: 351, False: 16] ------------------ 30418| 351| uint32_t s0 = 30419| 351| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 30420| 351| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30421| 351| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30422| | 30423| 351| s += 1 * 4; 30424| 351| d += 1 * 1; 30425| 351| n -= 1; 30426| 351| } 30427| | 30428| 16| return len; 30429| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over: 30438| 10| size_t src_len) { 30439| 10| size_t src_len4 = src_len / 4; 30440| 10| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30440:16): [True: 2, False: 8] ------------------ 30441| 10| uint8_t* d = dst_ptr; 30442| 10| const uint8_t* s = src_ptr; 30443| 10| size_t n = len; 30444| | 30445| | // TODO: unroll. 30446| | 30447| 140| while (n >= 1) { ------------------ | Branch (30447:10): [True: 130, False: 10] ------------------ 30448| 130| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30449| 130| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 30450| 130| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30451| 130| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 30452| | 30453| 130| s += 1 * 4; 30454| 130| d += 1 * 1; 30455| 130| n -= 1; 30456| 130| } 30457| | 30458| 10| return len; 30459| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src: 26072| 18| size_t src_len) { 26073| 18| size_t dst_len2 = dst_len / 2; 26074| 18| size_t src_len4 = src_len / 4; 26075| 18| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26075:16): [True: 1, False: 17] ------------------ 26076| 18| uint8_t* d = dst_ptr; 26077| 18| const uint8_t* s = src_ptr; 26078| 18| size_t n = len; 26079| | 26080| | // TODO: unroll. 26081| | 26082| 468| while (n >= 1) { ------------------ | Branch (26082:10): [True: 450, False: 18] ------------------ 26083| 450| wuffs_base__poke_u16le__no_bounds_check( 26084| 450| d + (0 * 2), 26085| 450| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26086| 450| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26087| 450| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 26088| | 26089| 450| s += 1 * 4; 26090| 450| d += 1 * 2; 26091| 450| n -= 1; 26092| 450| } 26093| | 26094| 18| return len; 26095| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src_over: 26136| 15| size_t src_len) { 26137| 15| size_t dst_len2 = dst_len / 2; 26138| 15| size_t src_len4 = src_len / 4; 26139| 15| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26139:16): [True: 1, False: 14] ------------------ 26140| 15| uint8_t* d = dst_ptr; 26141| 15| const uint8_t* s = src_ptr; 26142| 15| size_t n = len; 26143| | 26144| | // TODO: unroll. 26145| | 26146| 388| while (n >= 1) { ------------------ | Branch (26146:10): [True: 373, False: 15] ------------------ 26147| | // Extract 16-bit color components. 26148| 373| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26149| 373| uint32_t sr = 0x101 * ((uint32_t)s[2]); 26150| 373| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26151| 373| uint32_t sb = 0x101 * ((uint32_t)s[0]); 26152| | 26153| | // Convert from 565 color to 16-bit color. 26154| 373| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26155| 373| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26156| 373| uint32_t dr = (0x8421 * old_r5) >> 4; 26157| 373| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26158| 373| uint32_t dg = (0x1041 * old_g6) >> 2; 26159| 373| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26160| 373| uint32_t db = (0x8421 * old_b5) >> 4; 26161| | 26162| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26163| 373| uint32_t ia = 0xFFFF - sa; 26164| | 26165| | // Composite src (nonpremul) over dst (premul). 26166| 373| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26167| 373| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26168| 373| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26169| | 26170| | // Convert from 16-bit color to 565 color and combine the components. 26171| 373| uint32_t new_r5 = 0x1F & (dr >> 11); 26172| 373| uint32_t new_g6 = 0x3F & (dg >> 10); 26173| 373| uint32_t new_b5 = 0x1F & (db >> 11); 26174| 373| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26175| 373| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26176| | 26177| 373| s += 1 * 4; 26178| 373| d += 1 * 2; 26179| 373| n -= 1; 26180| 373| } 26181| | 26182| 15| return len; 26183| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src: 26958| 15| size_t src_len) { 26959| 15| size_t dst_len3 = dst_len / 3; 26960| 15| size_t src_len4 = src_len / 4; 26961| 15| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26961:16): [True: 1, False: 14] ------------------ 26962| 15| uint8_t* d = dst_ptr; 26963| 15| const uint8_t* s = src_ptr; 26964| 15| size_t n = len; 26965| | 26966| | // TODO: unroll. 26967| | 26968| 299| while (n >= 1) { ------------------ | Branch (26968:10): [True: 284, False: 15] ------------------ 26969| 284| uint32_t s0 = 26970| 284| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26971| 284| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 26972| 284| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26973| | 26974| 284| s += 1 * 4; 26975| 284| d += 1 * 3; 26976| 284| n -= 1; 26977| 284| } 26978| | 26979| 15| return len; 26980| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over: 27020| 17| size_t src_len) { 27021| 17| size_t dst_len3 = dst_len / 3; 27022| 17| size_t src_len4 = src_len / 4; 27023| 17| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27023:16): [True: 1, False: 16] ------------------ 27024| 17| uint8_t* d = dst_ptr; 27025| 17| const uint8_t* s = src_ptr; 27026| 17| size_t n = len; 27027| | 27028| | // TODO: unroll. 27029| | 27030| 311| while (n >= 1) { ------------------ | Branch (27030:10): [True: 294, False: 17] ------------------ 27031| | // Extract 16-bit color components. 27032| 294| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27033| 294| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27034| 294| uint32_t db = 0x101 * ((uint32_t)d[0]); 27035| 294| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27036| 294| uint32_t sr = 0x101 * ((uint32_t)s[2]); 27037| 294| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27038| 294| uint32_t sb = 0x101 * ((uint32_t)s[0]); 27039| | 27040| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27041| 294| uint32_t ia = 0xFFFF - sa; 27042| | 27043| | // Composite src (nonpremul) over dst (premul). 27044| 294| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27045| 294| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27046| 294| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27047| | 27048| | // Convert from 16-bit color to 8-bit color. 27049| 294| d[0] = (uint8_t)(db >> 8); 27050| 294| d[1] = (uint8_t)(dg >> 8); 27051| 294| d[2] = (uint8_t)(dr >> 8); 27052| | 27053| 294| s += 1 * 4; 27054| 294| d += 1 * 3; 27055| 294| n -= 1; 27056| 294| } 27057| | 27058| 17| return len; 27059| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_4_4: 25975| 19| size_t src_len) { 25976| 19| size_t dst_len4 = dst_len / 4; 25977| 19| size_t src_len4 = src_len / 4; 25978| 19| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (25978:16): [True: 4, False: 15] ------------------ 25979| 19| if (len > 0) { ------------------ | Branch (25979:7): [True: 15, False: 4] ------------------ 25980| 15| memmove(dst_ptr, src_ptr, len * 4); 25981| 15| } 25982| 19| return len; 25983| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over: 27614| 19| size_t src_len) { 27615| 19| size_t dst_len4 = dst_len / 4; 27616| 19| size_t src_len4 = src_len / 4; 27617| 19| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27617:16): [True: 5, False: 14] ------------------ 27618| 19| uint8_t* d = dst_ptr; 27619| 19| const uint8_t* s = src_ptr; 27620| 19| size_t n = len; 27621| | 27622| 204| while (n >= 1) { ------------------ | Branch (27622:10): [True: 185, False: 19] ------------------ 27623| 185| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27624| 185| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27625| 185| wuffs_base__poke_u32le__no_bounds_check( 27626| 185| d + (0 * 4), 27627| 185| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27628| | 27629| 185| s += 1 * 4; 27630| 185| d += 1 * 4; 27631| 185| n -= 1; 27632| 185| } 27633| | 27634| 19| return len; 27635| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src: 28015| 10| size_t src_len) { 28016| 10| size_t dst_len8 = dst_len / 8; 28017| 10| size_t src_len4 = src_len / 4; 28018| 10| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28018:16): [True: 3, False: 7] ------------------ 28019| 10| uint8_t* d = dst_ptr; 28020| 10| const uint8_t* s = src_ptr; 28021| | 28022| 10| size_t n = len; 28023| 117| while (n >= 1) { ------------------ | Branch (28023:10): [True: 107, False: 10] ------------------ 28024| 107| uint8_t s0 = s[0]; 28025| 107| uint8_t s1 = s[1]; 28026| 107| uint8_t s2 = s[2]; 28027| 107| uint8_t s3 = s[3]; 28028| 107| d[0] = s0; 28029| 107| d[1] = s0; 28030| 107| d[2] = s1; 28031| 107| d[3] = s1; 28032| 107| d[4] = s2; 28033| 107| d[5] = s2; 28034| 107| d[6] = s3; 28035| 107| d[7] = s3; 28036| | 28037| 107| s += 1 * 4; 28038| 107| d += 1 * 8; 28039| 107| n -= 1; 28040| 107| } 28041| 10| return len; 28042| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over: 28051| 29| size_t src_len) { 28052| 29| size_t dst_len8 = dst_len / 8; 28053| 29| size_t src_len4 = src_len / 4; 28054| 29| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28054:16): [True: 10, False: 19] ------------------ 28055| 29| uint8_t* d = dst_ptr; 28056| 29| const uint8_t* s = src_ptr; 28057| | 28058| 29| size_t n = len; 28059| 164| while (n >= 1) { ------------------ | Branch (28059:10): [True: 135, False: 29] ------------------ 28060| 135| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28061| 135| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28062| 135| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28063| 135| wuffs_base__poke_u64le__no_bounds_check( 28064| 135| d + (0 * 8), 28065| 135| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28066| | 28067| 135| s += 1 * 4; 28068| 135| d += 1 * 8; 28069| 135| n -= 1; 28070| 135| } 28071| 29| return len; 28072| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over: 28508| 20| size_t src_len) { 28509| 20| size_t dst_len4 = dst_len / 4; 28510| 20| size_t src_len4 = src_len / 4; 28511| 20| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28511:16): [True: 4, False: 16] ------------------ 28512| 20| uint8_t* d = dst_ptr; 28513| 20| const uint8_t* s = src_ptr; 28514| 20| size_t n = len; 28515| | 28516| | // TODO: unroll. 28517| | 28518| 339| while (n >= 1) { ------------------ | Branch (28518:10): [True: 319, False: 20] ------------------ 28519| 319| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28520| 319| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 28521| 319| wuffs_base__poke_u32le__no_bounds_check( 28522| 319| d + (0 * 4), 28523| 319| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28524| | 28525| 319| s += 1 * 4; 28526| 319| d += 1 * 4; 28527| 319| n -= 1; 28528| 319| } 28529| | 28530| 20| return len; 28531| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src: 27268| 12| size_t src_len) { 27269| 12| size_t dst_len3 = dst_len / 3; 27270| 12| size_t src_len4 = src_len / 4; 27271| 12| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27271:16): [True: 1, False: 11] ------------------ 27272| 12| uint8_t* d = dst_ptr; 27273| 12| const uint8_t* s = src_ptr; 27274| 12| size_t n = len; 27275| | 27276| | // TODO: unroll. 27277| | 27278| 213| while (n >= 1) { ------------------ | Branch (27278:10): [True: 201, False: 12] ------------------ 27279| 201| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27280| 201| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 27281| 201| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 27282| 201| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27283| | 27284| 201| s += 1 * 4; 27285| 201| d += 1 * 3; 27286| 201| n -= 1; 27287| 201| } 27288| | 27289| 12| return len; 27290| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over: 27330| 18| size_t src_len) { 27331| 18| size_t dst_len3 = dst_len / 3; 27332| 18| size_t src_len4 = src_len / 4; 27333| 18| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27333:16): [True: 3, False: 15] ------------------ 27334| 18| uint8_t* d = dst_ptr; 27335| 18| const uint8_t* s = src_ptr; 27336| 18| size_t n = len; 27337| | 27338| | // TODO: unroll. 27339| | 27340| 281| while (n >= 1) { ------------------ | Branch (27340:10): [True: 263, False: 18] ------------------ 27341| | // Extract 16-bit color components. 27342| 263| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27343| 263| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27344| 263| uint32_t db = 0x101 * ((uint32_t)d[0]); 27345| 263| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27346| 263| uint32_t sb = 0x101 * ((uint32_t)s[2]); 27347| 263| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27348| 263| uint32_t sr = 0x101 * ((uint32_t)s[0]); 27349| | 27350| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27351| 263| uint32_t ia = 0xFFFF - sa; 27352| | 27353| | // Composite src (nonpremul) over dst (premul). 27354| 263| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27355| 263| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27356| 263| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27357| | 27358| | // Convert from 16-bit color to 8-bit color. 27359| 263| d[0] = (uint8_t)(db >> 8); 27360| 263| d[1] = (uint8_t)(dg >> 8); 27361| 263| d[2] = (uint8_t)(dr >> 8); 27362| | 27363| 263| s += 1 * 4; 27364| 263| d += 1 * 3; 27365| 263| n -= 1; 27366| 263| } 27367| | 27368| 18| return len; 27369| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42: 25820| 37| size_t src_len) { 25821| 37| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25821:17): [True: 7, False: 30] ------------------ 25822| 37| uint8_t* d = dst_ptr; 25823| 37| const uint8_t* s = src_ptr; 25824| 37| size_t n = len; 25825| | 25826| 37| __m128i shuffle = _mm_set_epi8(+0x0F, +0x0C, +0x0D, +0x0E, // 25827| 37| +0x0B, +0x08, +0x09, +0x0A, // 25828| 37| +0x07, +0x04, +0x05, +0x06, // 25829| 37| +0x03, +0x00, +0x01, +0x02); 25830| | 25831| 157| while (n >= 4) { ------------------ | Branch (25831:10): [True: 120, False: 37] ------------------ 25832| 120| __m128i x; 25833| 120| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 25834| 120| x = _mm_shuffle_epi8(x, shuffle); 25835| 120| _mm_storeu_si128((__m128i*)(void*)d, x); 25836| | 25837| 120| s += 4 * 4; 25838| 120| d += 4 * 4; 25839| 120| n -= 4; 25840| 120| } 25841| | 25842| 85| while (n--) { ------------------ | Branch (25842:10): [True: 48, False: 37] ------------------ 25843| 48| uint8_t s0 = s[0]; 25844| 48| uint8_t s1 = s[1]; 25845| 48| uint8_t s2 = s[2]; 25846| 48| uint8_t s3 = s[3]; 25847| 48| d[0] = s2; 25848| 48| d[1] = s1; 25849| 48| d[2] = s0; 25850| 48| d[3] = s3; 25851| 48| s += 4; 25852| 48| d += 4; 25853| 48| } 25854| 37| return len; 25855| 37|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over: 27860| 33| size_t src_len) { 27861| 33| size_t dst_len4 = dst_len / 4; 27862| 33| size_t src_len4 = src_len / 4; 27863| 33| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27863:16): [True: 6, False: 27] ------------------ 27864| 33| uint8_t* d = dst_ptr; 27865| 33| const uint8_t* s = src_ptr; 27866| 33| size_t n = len; 27867| | 27868| 763| while (n >= 1) { ------------------ | Branch (27868:10): [True: 730, False: 33] ------------------ 27869| 730| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27870| 730| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27871| 730| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27872| 730| wuffs_base__poke_u32le__no_bounds_check( 27873| 730| d + (0 * 4), 27874| 730| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27875| | 27876| 730| s += 1 * 4; 27877| 730| d += 1 * 4; 27878| 730| n -= 1; 27879| 730| } 27880| | 27881| 33| return len; 27882| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over: 28738| 20| size_t src_len) { 28739| 20| size_t dst_len4 = dst_len / 4; 28740| 20| size_t src_len4 = src_len / 4; 28741| 20| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28741:16): [True: 2, False: 18] ------------------ 28742| 20| uint8_t* d = dst_ptr; 28743| 20| const uint8_t* s = src_ptr; 28744| 20| size_t n = len; 28745| | 28746| | // TODO: unroll. 28747| | 28748| 402| while (n >= 1) { ------------------ | Branch (28748:10): [True: 382, False: 20] ------------------ 28749| 382| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28750| 382| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28751| 382| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28752| 382| wuffs_base__poke_u32le__no_bounds_check( 28753| 382| d + (0 * 4), 28754| 382| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28755| | 28756| 382| s += 1 * 4; 28757| 382| d += 1 * 4; 28758| 382| n -= 1; 28759| 382| } 28760| | 28761| 20| return len; 28762| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le: 31891| 289| wuffs_base__pixel_blend blend) { 31892| 289| switch (dst_pixfmt.repr) { ------------------ | Branch (31892:11): [True: 276, False: 13] ------------------ 31893| 19| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 19|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31893:5): [True: 19, False: 270] ------------------ 31894| 19| switch (blend) { ------------------ | Branch (31894:15): [True: 19, False: 0] ------------------ 31895| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31895:9): [True: 8, False: 11] ------------------ 31896| 8| return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src; 31897| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31897:9): [True: 11, False: 8] ------------------ 31898| 11| return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over; 31899| 19| } 31900| 0| return NULL; 31901| | 31902| 37| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 37|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31902:5): [True: 37, False: 252] ------------------ 31903| 37| switch (blend) { ------------------ | Branch (31903:15): [True: 37, False: 0] ------------------ 31904| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31904:9): [True: 18, False: 19] ------------------ 31905| 18| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src; 31906| 19| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31906:9): [True: 19, False: 18] ------------------ 31907| 19| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over; 31908| 37| } 31909| 0| return NULL; 31910| | 31911| 18| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31911:5): [True: 18, False: 271] ------------------ 31912| 18| switch (blend) { ------------------ | Branch (31912:15): [True: 18, False: 0] ------------------ 31913| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31913:9): [True: 9, False: 9] ------------------ 31914| 9| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src; 31915| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31915:9): [True: 9, False: 9] ------------------ 31916| 9| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src_over; 31917| 18| } 31918| 0| return NULL; 31919| | 31920| 48| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 48|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31920:5): [True: 48, False: 241] ------------------ 31921| 48| switch (blend) { ------------------ | Branch (31921:15): [True: 48, False: 0] ------------------ 31922| 14| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31922:9): [True: 14, False: 34] ------------------ 31923| 14| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src; 31924| 34| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 34|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31924:9): [True: 34, False: 14] ------------------ 31925| 34| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over; 31926| 48| } 31927| 0| return NULL; 31928| | 31929| 36| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 36|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31929:5): [True: 36, False: 253] ------------------ 31930| 36| switch (blend) { ------------------ | Branch (31930:15): [True: 36, False: 0] ------------------ 31931| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31931:9): [True: 4, False: 32] ------------------ 31932| 4| return wuffs_private_impl__swizzle_copy_8_8; 31933| 32| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31933:9): [True: 32, False: 4] ------------------ 31934| 32| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over; 31935| 36| } 31936| 0| return NULL; 31937| | 31938| 26| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 26|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31938:5): [True: 26, False: 263] ------------------ 31939| 26| switch (blend) { ------------------ | Branch (31939:15): [True: 26, False: 0] ------------------ 31940| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31940:9): [True: 9, False: 17] ------------------ 31941| 9| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src; 31942| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31942:9): [True: 17, False: 9] ------------------ 31943| 17| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over; 31944| 26| } 31945| 0| return NULL; 31946| | 31947| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31947:5): [True: 0, False: 289] ------------------ 31948| 3| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 3|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31948:5): [True: 3, False: 286] ------------------ 31949| | // TODO. 31950| 3| break; 31951| | 31952| 28| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 28|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31952:5): [True: 28, False: 261] ------------------ 31953| 28| switch (blend) { ------------------ | Branch (31953:15): [True: 28, False: 0] ------------------ 31954| 15| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31954:9): [True: 15, False: 13] ------------------ 31955| 15| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src; 31956| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31956:9): [True: 13, False: 15] ------------------ 31957| 13| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over; 31958| 28| } 31959| 0| return NULL; 31960| | 31961| 36| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 36|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31961:5): [True: 36, False: 253] ------------------ 31962| 36| switch (blend) { ------------------ | Branch (31962:15): [True: 36, False: 0] ------------------ 31963| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31963:9): [True: 13, False: 23] ------------------ 31964| 13| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src; 31965| 23| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 23|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31965:9): [True: 23, False: 13] ------------------ 31966| 23| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over; 31967| 36| } 31968| 0| break; 31969| | 31970| 25| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 25|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31970:5): [True: 25, False: 264] ------------------ 31971| 25| switch (blend) { ------------------ | Branch (31971:15): [True: 25, False: 0] ------------------ 31972| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31972:9): [True: 10, False: 15] ------------------ 31973| 10| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src; 31974| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31974:9): [True: 15, False: 10] ------------------ 31975| 15| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over; 31976| 25| } 31977| 0| return NULL; 31978| | 31979| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31979:5): [True: 0, False: 289] ------------------ 31980| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31980:5): [True: 0, False: 289] ------------------ 31981| | // TODO. 31982| 0| break; 31983| 289| } 31984| 16| return NULL; 31985| 289|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src: 30468| 8| size_t src_len) { 30469| 8| size_t src_len8 = src_len / 8; 30470| 8| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (30470:16): [True: 1, False: 7] ------------------ 30471| 8| uint8_t* d = dst_ptr; 30472| 8| const uint8_t* s = src_ptr; 30473| 8| size_t n = len; 30474| | 30475| | // TODO: unroll. 30476| | 30477| 56| while (n >= 1) { ------------------ | Branch (30477:10): [True: 48, False: 8] ------------------ 30478| 48| d[0] = wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray( 30479| 48| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 30480| | 30481| 48| s += 1 * 8; 30482| 48| d += 1 * 1; 30483| 48| n -= 1; 30484| 48| } 30485| | 30486| 8| return len; 30487| 8|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray: 4629| 48| uint64_t argb_nonpremul) { 4630| 48| uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); 4631| | 4632| 48| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); 4633| 48| r16 = (r16 * a16) / 0xFFFF; 4634| 48| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); 4635| 48| g16 = (g16 * a16) / 0xFFFF; 4636| 48| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); 4637| 48| b16 = (b16 * a16) / 0xFFFF; 4638| | 4639| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4640| | // as those given by the JFIF specification. 4641| | // 4642| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We 4643| | // shift by 24, not just by 16, because the return value is 8-bit color, not 4644| | // 16-bit color. 4645| 48| uint32_t weighted_average = 4646| 48| (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; 4647| 48| return (uint8_t)(weighted_average >> 24); 4648| 48|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over: 30496| 11| size_t src_len) { 30497| 11| size_t src_len8 = src_len / 8; 30498| 11| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (30498:16): [True: 1, False: 10] ------------------ 30499| 11| uint8_t* d = dst_ptr; 30500| 11| const uint8_t* s = src_ptr; 30501| 11| size_t n = len; 30502| | 30503| | // TODO: unroll. 30504| | 30505| 102| while (n >= 1) { ------------------ | Branch (30505:10): [True: 91, False: 11] ------------------ 30506| | // Extract 16-bit color components. 30507| 91| uint32_t dr = 0x101 * ((uint32_t)d[0]); 30508| 91| uint32_t dg = 0x101 * ((uint32_t)d[0]); 30509| 91| uint32_t db = 0x101 * ((uint32_t)d[0]); 30510| 91| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 30511| 91| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 30512| 91| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 30513| 91| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 30514| | 30515| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 30516| 91| uint32_t ia = 0xFFFF - sa; 30517| | 30518| | // Composite src (nonpremul) over dst (premul). 30519| 91| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 30520| 91| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 30521| 91| db = ((sb * sa) + (db * ia)) / 0xFFFF; 30522| | 30523| | // Convert to 16-bit color to 8-bit gray. 30524| 91| uint32_t weighted_average = 30525| 91| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 30526| 91| d[0] = (uint8_t)(weighted_average >> 24); 30527| | 30528| 91| s += 1 * 8; 30529| 91| d += 1 * 1; 30530| 91| n -= 1; 30531| 91| } 30532| | 30533| 11| return len; 30534| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src: 26104| 18| size_t src_len) { 26105| 18| size_t dst_len2 = dst_len / 2; 26106| 18| size_t src_len8 = src_len / 8; 26107| 18| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (26107:16): [True: 1, False: 17] ------------------ 26108| 18| uint8_t* d = dst_ptr; 26109| 18| const uint8_t* s = src_ptr; 26110| 18| size_t n = len; 26111| | 26112| | // TODO: unroll. 26113| | 26114| 181| while (n >= 1) { ------------------ | Branch (26114:10): [True: 163, False: 18] ------------------ 26115| 163| wuffs_base__poke_u16le__no_bounds_check( 26116| 163| d + (0 * 2), 26117| 163| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26118| 163| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 26119| 163| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 26120| | 26121| 163| s += 1 * 8; 26122| 163| d += 1 * 2; 26123| 163| n -= 1; 26124| 163| } 26125| | 26126| 18| return len; 26127| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over: 26192| 19| size_t src_len) { 26193| 19| size_t dst_len2 = dst_len / 2; 26194| 19| size_t src_len8 = src_len / 8; 26195| 19| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (26195:16): [True: 2, False: 17] ------------------ 26196| 19| uint8_t* d = dst_ptr; 26197| 19| const uint8_t* s = src_ptr; 26198| 19| size_t n = len; 26199| | 26200| | // TODO: unroll. 26201| | 26202| 249| while (n >= 1) { ------------------ | Branch (26202:10): [True: 230, False: 19] ------------------ 26203| | // Extract 16-bit color components. 26204| 230| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26205| 230| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26206| 230| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26207| 230| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 26208| | 26209| | // Convert from 565 color to 16-bit color. 26210| 230| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26211| 230| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26212| 230| uint32_t dr = (0x8421 * old_r5) >> 4; 26213| 230| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26214| 230| uint32_t dg = (0x1041 * old_g6) >> 2; 26215| 230| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26216| 230| uint32_t db = (0x8421 * old_b5) >> 4; 26217| | 26218| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26219| 230| uint32_t ia = 0xFFFF - sa; 26220| | 26221| | // Composite src (nonpremul) over dst (premul). 26222| 230| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26223| 230| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26224| 230| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26225| | 26226| | // Convert from 16-bit color to 565 color and combine the components. 26227| 230| uint32_t new_r5 = 0x1F & (dr >> 11); 26228| 230| uint32_t new_g6 = 0x3F & (dg >> 10); 26229| 230| uint32_t new_b5 = 0x1F & (db >> 11); 26230| 230| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26231| 230| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26232| | 26233| 230| s += 1 * 8; 26234| 230| d += 1 * 2; 26235| 230| n -= 1; 26236| 230| } 26237| | 26238| 19| return len; 26239| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src: 26989| 9| size_t src_len) { 26990| 9| size_t dst_len3 = dst_len / 3; 26991| 9| size_t src_len8 = src_len / 8; 26992| 9| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26992:16): [True: 1, False: 8] ------------------ 26993| 9| uint8_t* d = dst_ptr; 26994| 9| const uint8_t* s = src_ptr; 26995| 9| size_t n = len; 26996| | 26997| | // TODO: unroll. 26998| | 26999| 90| while (n >= 1) { ------------------ | Branch (26999:10): [True: 81, False: 9] ------------------ 27000| 81| uint32_t s0 = 27001| 81| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 27002| 81| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 27003| 81| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27004| | 27005| 81| s += 1 * 8; 27006| 81| d += 1 * 3; 27007| 81| n -= 1; 27008| 81| } 27009| | 27010| 9| return len; 27011| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src_over: 27068| 9| size_t src_len) { 27069| 9| size_t dst_len3 = dst_len / 3; 27070| 9| size_t src_len8 = src_len / 8; 27071| 9| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27071:16): [True: 1, False: 8] ------------------ 27072| 9| uint8_t* d = dst_ptr; 27073| 9| const uint8_t* s = src_ptr; 27074| 9| size_t n = len; 27075| | 27076| | // TODO: unroll. 27077| | 27078| 76| while (n >= 1) { ------------------ | Branch (27078:10): [True: 67, False: 9] ------------------ 27079| | // Extract 16-bit color components. 27080| 67| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27081| 67| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27082| 67| uint32_t db = 0x101 * ((uint32_t)d[0]); 27083| 67| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27084| 67| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27085| 67| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27086| 67| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 27087| | 27088| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27089| 67| uint32_t ia = 0xFFFF - sa; 27090| | 27091| | // Composite src (nonpremul) over dst (premul). 27092| 67| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27093| 67| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27094| 67| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27095| | 27096| | // Convert from 16-bit color to 8-bit color. 27097| 67| d[0] = (uint8_t)(db >> 8); 27098| 67| d[1] = (uint8_t)(dg >> 8); 27099| 67| d[2] = (uint8_t)(dr >> 8); 27100| | 27101| 67| s += 1 * 8; 27102| 67| d += 1 * 3; 27103| 67| n -= 1; 27104| 67| } 27105| | 27106| 9| return len; 27107| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src: 27644| 14| size_t src_len) { 27645| 14| size_t dst_len4 = dst_len / 4; 27646| 14| size_t src_len8 = src_len / 8; 27647| 14| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27647:16): [True: 2, False: 12] ------------------ 27648| 14| uint8_t* d = dst_ptr; 27649| 14| const uint8_t* s = src_ptr; 27650| | 27651| 14| size_t n = len; 27652| 204| while (n >= 1) { ------------------ | Branch (27652:10): [True: 190, False: 14] ------------------ 27653| 190| wuffs_base__poke_u32le__no_bounds_check( 27654| 190| d + (0 * 4), wuffs_base__color_u64__as__color_u32( 27655| 190| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 27656| | 27657| 190| s += 1 * 8; 27658| 190| d += 1 * 4; 27659| 190| n -= 1; 27660| 190| } 27661| 14| return len; 27662| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over: 27671| 34| size_t src_len) { 27672| 34| size_t dst_len4 = dst_len / 4; 27673| 34| size_t src_len8 = src_len / 8; 27674| 34| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27674:16): [True: 1, False: 33] ------------------ 27675| 34| uint8_t* d = dst_ptr; 27676| 34| const uint8_t* s = src_ptr; 27677| 34| size_t n = len; 27678| | 27679| 313| while (n >= 1) { ------------------ | Branch (27679:10): [True: 279, False: 34] ------------------ 27680| 279| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 27681| 279| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 27682| 279| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27683| 279| wuffs_base__poke_u32le__no_bounds_check( 27684| 279| d + (0 * 4), 27685| 279| wuffs_base__color_u64__as__color_u32( 27686| 279| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, 27687| 279| s0))); 27688| | 27689| 279| s += 1 * 8; 27690| 279| d += 1 * 4; 27691| 279| n -= 1; 27692| 279| } 27693| | 27694| 34| return len; 27695| 34|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_8_8: 25991| 4| size_t src_len) { 25992| 4| size_t dst_len8 = dst_len / 8; 25993| 4| size_t src_len8 = src_len / 8; 25994| 4| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (25994:16): [True: 1, False: 3] ------------------ 25995| 4| if (len > 0) { ------------------ | Branch (25995:7): [True: 2, False: 2] ------------------ 25996| 2| memmove(dst_ptr, src_ptr, len * 8); 25997| 2| } 25998| 4| return len; 25999| 4|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over: 28081| 32| size_t src_len) { 28082| 32| size_t dst_len8 = dst_len / 8; 28083| 32| size_t src_len8 = src_len / 8; 28084| 32| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (28084:16): [True: 6, False: 26] ------------------ 28085| 32| uint8_t* d = dst_ptr; 28086| 32| const uint8_t* s = src_ptr; 28087| | 28088| 32| size_t n = len; 28089| 211| while (n >= 1) { ------------------ | Branch (28089:10): [True: 179, False: 32] ------------------ 28090| 179| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28091| 179| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28092| 179| wuffs_base__poke_u64le__no_bounds_check( 28093| 179| d + (0 * 8), 28094| 179| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28095| | 28096| 179| s += 1 * 8; 28097| 179| d += 1 * 8; 28098| 179| n -= 1; 28099| 179| } 28100| 32| return len; 28101| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src: 28477| 9| size_t src_len) { 28478| 9| size_t dst_len4 = dst_len / 4; 28479| 9| size_t src_len8 = src_len / 8; 28480| 9| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28480:16): [True: 1, False: 8] ------------------ 28481| 9| uint8_t* d = dst_ptr; 28482| 9| const uint8_t* s = src_ptr; 28483| 9| size_t n = len; 28484| | 28485| | // TODO: unroll. 28486| | 28487| 106| while (n >= 1) { ------------------ | Branch (28487:10): [True: 97, False: 9] ------------------ 28488| 97| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28489| 97| wuffs_base__poke_u32le__no_bounds_check( 28490| 97| d + (0 * 4), 28491| 97| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(s0)); 28492| | 28493| 97| s += 1 * 8; 28494| 97| d += 1 * 4; 28495| 97| n -= 1; 28496| 97| } 28497| | 28498| 9| return len; 28499| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over: 28540| 17| size_t src_len) { 28541| 17| size_t dst_len4 = dst_len / 4; 28542| 17| size_t src_len8 = src_len / 8; 28543| 17| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28543:16): [True: 1, False: 16] ------------------ 28544| 17| uint8_t* d = dst_ptr; 28545| 17| const uint8_t* s = src_ptr; 28546| 17| size_t n = len; 28547| | 28548| | // TODO: unroll. 28549| | 28550| 183| while (n >= 1) { ------------------ | Branch (28550:10): [True: 166, False: 17] ------------------ 28551| 166| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28552| 166| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28553| 166| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28554| 166| wuffs_base__poke_u32le__no_bounds_check( 28555| 166| d + (0 * 4), 28556| 166| wuffs_base__color_u64__as__color_u32( 28557| 166| wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0))); 28558| | 28559| 166| s += 1 * 8; 28560| 166| d += 1 * 4; 28561| 166| n -= 1; 28562| 166| } 28563| | 28564| 17| return len; 28565| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u64_axxx: 25643| 285| uint64_t src_nonpremul) { 25644| | // Extract components. 25645| 285| uint64_t da = 0xFFFF & (dst_premul >> 48); 25646| 285| uint64_t dr = 0xFFFF & (dst_premul >> 32); 25647| 285| uint64_t dg = 0xFFFF & (dst_premul >> 16); 25648| 285| uint64_t db = 0xFFFF & (dst_premul >> 0); 25649| 285| uint64_t sa = 0xFFFF & (src_nonpremul >> 48); 25650| 285| uint64_t sr = 0xFFFF & (src_nonpremul >> 32); 25651| 285| uint64_t sg = 0xFFFF & (src_nonpremul >> 16); 25652| 285| uint64_t sb = 0xFFFF & (src_nonpremul >> 0); 25653| | 25654| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25655| 285| uint64_t ia = 0xFFFF - sa; 25656| | 25657| | // Composite src (nonpremul) over dst (premul). 25658| 285| da = sa + ((da * ia) / 0xFFFF); 25659| 285| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25660| 285| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25661| 285| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25662| | 25663| | // Combine components. 25664| 285| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25665| 285|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src: 27299| 15| size_t src_len) { 27300| 15| size_t dst_len3 = dst_len / 3; 27301| 15| size_t src_len8 = src_len / 8; 27302| 15| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27302:16): [True: 3, False: 12] ------------------ 27303| 15| uint8_t* d = dst_ptr; 27304| 15| const uint8_t* s = src_ptr; 27305| 15| size_t n = len; 27306| | 27307| | // TODO: unroll. 27308| | 27309| 161| while (n >= 1) { ------------------ | Branch (27309:10): [True: 146, False: 15] ------------------ 27310| 146| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27311| 146| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 27312| 146| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 27313| 146| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27314| | 27315| 146| s += 1 * 8; 27316| 146| d += 1 * 3; 27317| 146| n -= 1; 27318| 146| } 27319| | 27320| 15| return len; 27321| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over: 27378| 13| size_t src_len) { 27379| 13| size_t dst_len3 = dst_len / 3; 27380| 13| size_t src_len8 = src_len / 8; 27381| 13| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27381:16): [True: 3, False: 10] ------------------ 27382| 13| uint8_t* d = dst_ptr; 27383| 13| const uint8_t* s = src_ptr; 27384| 13| size_t n = len; 27385| | 27386| | // TODO: unroll. 27387| | 27388| 189| while (n >= 1) { ------------------ | Branch (27388:10): [True: 176, False: 13] ------------------ 27389| | // Extract 16-bit color components. 27390| 176| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27391| 176| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27392| 176| uint32_t db = 0x101 * ((uint32_t)d[0]); 27393| 176| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27394| 176| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27395| 176| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27396| 176| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 27397| | 27398| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27399| 176| uint32_t ia = 0xFFFF - sa; 27400| | 27401| | // Composite src (nonpremul) over dst (premul). 27402| 176| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27403| 176| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27404| 176| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27405| | 27406| | // Convert from 16-bit color to 8-bit color. 27407| 176| d[0] = (uint8_t)(db >> 8); 27408| 176| d[1] = (uint8_t)(dg >> 8); 27409| 176| d[2] = (uint8_t)(dr >> 8); 27410| | 27411| 176| s += 1 * 8; 27412| 176| d += 1 * 3; 27413| 176| n -= 1; 27414| 176| } 27415| | 27416| 13| return len; 27417| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src: 29464| 13| size_t src_len) { 29465| 13| size_t dst_len4 = dst_len / 4; 29466| 13| size_t src_len8 = src_len / 8; 29467| 13| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29467:16): [True: 2, False: 11] ------------------ 29468| 13| uint8_t* d = dst_ptr; 29469| 13| const uint8_t* s = src_ptr; 29470| | 29471| 13| size_t n = len; 29472| 153| while (n >= 1) { ------------------ | Branch (29472:10): [True: 140, False: 13] ------------------ 29473| 140| wuffs_base__poke_u32le__no_bounds_check( 29474| 140| d + (0 * 4), 29475| 140| wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr( 29476| 140| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 29477| | 29478| 140| s += 1 * 8; 29479| 140| d += 1 * 4; 29480| 140| n -= 1; 29481| 140| } 29482| 13| return len; 29483| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr: 24486| 451|wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) { 24487| 451| uint32_t a = ((uint32_t)(0xFF & (c >> 56))); 24488| 451| uint32_t r = ((uint32_t)(0xFF & (c >> 40))); 24489| 451| uint32_t g = ((uint32_t)(0xFF & (c >> 24))); 24490| 451| uint32_t b = ((uint32_t)(0xFF & (c >> 8))); 24491| 451| return (a << 24) | (b << 16) | (g << 8) | (r << 0); 24492| 451|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over: 29492| 23| size_t src_len) { 29493| 23| size_t dst_len4 = dst_len / 4; 29494| 23| size_t src_len8 = src_len / 8; 29495| 23| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29495:16): [True: 1, False: 22] ------------------ 29496| 23| uint8_t* d = dst_ptr; 29497| 23| const uint8_t* s = src_ptr; 29498| 23| size_t n = len; 29499| | 29500| 206| while (n >= 1) { ------------------ | Branch (29500:10): [True: 183, False: 23] ------------------ 29501| 183| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 29502| 183| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 29503| 183| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 29504| 183| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 29505| 183| wuffs_base__poke_u32le__no_bounds_check( 29506| 183| d + (0 * 4), 29507| 183| wuffs_base__color_u64__as__color_u32( 29508| 183| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, 29509| 183| s0))); 29510| | 29511| 183| s += 1 * 8; 29512| 183| d += 1 * 4; 29513| 183| n -= 1; 29514| 183| } 29515| | 29516| 23| return len; 29517| 23|} pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u64_argb_abgr: 4839| 657|wuffs_base__color_swap_u64_argb_abgr(uint64_t u) { 4840| 657| uint64_t o = u & 0xFFFF0000FFFF0000ull; 4841| 657| uint64_t r = u & 0x0000FFFF00000000ull; 4842| 657| uint64_t b = u & 0x000000000000FFFFull; 4843| 657| return o | (r >> 32) | (b << 32); 4844| 657|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src: 28771| 10| size_t src_len) { 28772| 10| size_t dst_len4 = dst_len / 4; 28773| 10| size_t src_len8 = src_len / 8; 28774| 10| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28774:16): [True: 1, False: 9] ------------------ 28775| 10| uint8_t* d = dst_ptr; 28776| 10| const uint8_t* s = src_ptr; 28777| 10| size_t n = len; 28778| | 28779| | // TODO: unroll. 28780| | 28781| 79| while (n >= 1) { ------------------ | Branch (28781:10): [True: 69, False: 10] ------------------ 28782| 69| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28783| 69| wuffs_base__poke_u32le__no_bounds_check( 28784| 69| d + (0 * 4), 28785| 69| wuffs_base__color_swap_u32_argb_abgr( 28786| 69| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 28787| 69| s0))); 28788| | 28789| 69| s += 1 * 8; 28790| 69| d += 1 * 4; 28791| 69| n -= 1; 28792| 69| } 28793| | 28794| 10| return len; 28795| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over: 28804| 15| size_t src_len) { 28805| 15| size_t dst_len4 = dst_len / 4; 28806| 15| size_t src_len8 = src_len / 8; 28807| 15| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28807:16): [True: 2, False: 13] ------------------ 28808| 15| uint8_t* d = dst_ptr; 28809| 15| const uint8_t* s = src_ptr; 28810| 15| size_t n = len; 28811| | 28812| | // TODO: unroll. 28813| | 28814| 134| while (n >= 1) { ------------------ | Branch (28814:10): [True: 119, False: 15] ------------------ 28815| 119| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28816| 119| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28817| 119| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28818| 119| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28819| 119| wuffs_base__poke_u32le__no_bounds_check( 28820| 119| d + (0 * 4), 28821| 119| wuffs_base__color_u64__as__color_u32( 28822| 119| wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0))); 28823| | 28824| 119| s += 1 * 8; 28825| 119| d += 1 * 4; 28826| 119| n -= 1; 28827| 119| } 28828| | 28829| 15| return len; 28830| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul: 31993| 262| wuffs_base__pixel_blend blend) { 31994| 262| switch (dst_pixfmt.repr) { ------------------ | Branch (31994:11): [True: 237, False: 25] ------------------ 31995| 34| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 34|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31995:5): [True: 34, False: 228] ------------------ 31996| 34| switch (blend) { ------------------ | Branch (31996:15): [True: 34, False: 0] ------------------ 31997| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31997:9): [True: 16, False: 18] ------------------ 31998| 16| return wuffs_private_impl__swizzle_y__bgra_premul__src; 31999| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31999:9): [True: 18, False: 16] ------------------ 32000| 18| return wuffs_private_impl__swizzle_y__bgra_premul__src_over; 32001| 34| } 32002| 0| return NULL; 32003| | 32004| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32004:5): [True: 19, False: 243] ------------------ 32005| 19| switch (blend) { ------------------ | Branch (32005:15): [True: 19, False: 0] ------------------ 32006| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32006:9): [True: 9, False: 10] ------------------ 32007| 9| return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src; 32008| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32008:9): [True: 10, False: 9] ------------------ 32009| 10| return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over; 32010| 19| } 32011| 0| return NULL; 32012| | 32013| 17| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32013:5): [True: 17, False: 245] ------------------ 32014| 17| switch (blend) { ------------------ | Branch (32014:15): [True: 17, False: 0] ------------------ 32015| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32015:9): [True: 7, False: 10] ------------------ 32016| 7| return wuffs_private_impl__swizzle_bgr__bgra_premul__src; 32017| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32017:9): [True: 10, False: 7] ------------------ 32018| 10| return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; 32019| 17| } 32020| 0| return NULL; 32021| | 32022| 30| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 30|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32022:5): [True: 30, False: 232] ------------------ 32023| 30| switch (blend) { ------------------ | Branch (32023:15): [True: 30, False: 0] ------------------ 32024| 20| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32024:9): [True: 20, False: 10] ------------------ 32025| 20| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src; 32026| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32026:9): [True: 10, False: 20] ------------------ 32027| 10| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; 32028| 30| } 32029| 0| return NULL; 32030| | 32031| 56| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 56|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32031:5): [True: 56, False: 206] ------------------ 32032| 56| switch (blend) { ------------------ | Branch (32032:15): [True: 56, False: 0] ------------------ 32033| 29| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 29|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32033:9): [True: 29, False: 27] ------------------ 32034| 29| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src; 32035| 27| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 27|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32035:9): [True: 27, False: 29] ------------------ 32036| 27| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over; 32037| 56| } 32038| 0| return NULL; 32039| | 32040| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32040:5): [True: 18, False: 244] ------------------ 32041| 18| switch (blend) { ------------------ | Branch (32041:15): [True: 18, False: 0] ------------------ 32042| 14| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32042:9): [True: 14, False: 4] ------------------ 32043| 14| return wuffs_private_impl__swizzle_copy_4_4; 32044| 4| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32044:9): [True: 4, False: 14] ------------------ 32045| 4| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; 32046| 18| } 32047| 0| return NULL; 32048| | 32049| 9| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 9|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32049:5): [True: 9, False: 253] ------------------ 32050| 9| switch (blend) { ------------------ | Branch (32050:15): [True: 9, False: 0] ------------------ 32051| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32051:9): [True: 5, False: 4] ------------------ 32052| 5| return wuffs_private_impl__swizzle_bgr__rgba_premul__src; 32053| 4| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32053:9): [True: 4, False: 5] ------------------ 32054| 4| return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; 32055| 9| } 32056| 0| return NULL; 32057| | 32058| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32058:5): [True: 47, False: 215] ------------------ 32059| 47| switch (blend) { ------------------ | Branch (32059:15): [True: 47, False: 0] ------------------ 32060| 23| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 23|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32060:9): [True: 23, False: 24] ------------------ 32061| 23| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src; 32062| 24| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 24|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32062:9): [True: 24, False: 23] ------------------ 32063| 24| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; 32064| 47| } 32065| 0| return NULL; 32066| | 32067| 7| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 7|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32067:5): [True: 7, False: 255] ------------------ 32068| 7| switch (blend) { ------------------ | Branch (32068:15): [True: 7, False: 0] ------------------ 32069| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32069:9): [True: 5, False: 2] ------------------ 32070| 5|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32071| 5| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32071:15): [True: 5, False: 0] ------------------ 32072| 5| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 32073| 5| } 32074| 0|#endif 32075| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 32076| 2| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32076:9): [True: 2, False: 5] ------------------ 32077| 2| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; 32078| 7| } 32079| 0| return NULL; 32080| 262| } 32081| 25| return NULL; 32082| 262|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src: 30542| 16| size_t src_len) { 30543| 16| size_t src_len4 = src_len / 4; 30544| 16| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30544:16): [True: 1, False: 15] ------------------ 30545| 16| uint8_t* d = dst_ptr; 30546| 16| const uint8_t* s = src_ptr; 30547| 16| size_t n = len; 30548| | 30549| | // TODO: unroll. 30550| | 30551| 400| while (n >= 1) { ------------------ | Branch (30551:10): [True: 384, False: 16] ------------------ 30552| 384| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 30553| 384| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30554| | 30555| 384| s += 1 * 4; 30556| 384| d += 1 * 1; 30557| 384| n -= 1; 30558| 384| } 30559| | 30560| 16| return len; 30561| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src_over: 30569| 18| size_t src_len) { 30570| 18| size_t src_len4 = src_len / 4; 30571| 18| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30571:16): [True: 4, False: 14] ------------------ 30572| 18| uint8_t* d = dst_ptr; 30573| 18| const uint8_t* s = src_ptr; 30574| 18| size_t n = len; 30575| | 30576| | // TODO: unroll. 30577| | 30578| 239| while (n >= 1) { ------------------ | Branch (30578:10): [True: 221, False: 18] ------------------ 30579| | // Extract 16-bit color components. 30580| 221| uint32_t dr = 0x101 * ((uint32_t)d[0]); 30581| 221| uint32_t dg = 0x101 * ((uint32_t)d[0]); 30582| 221| uint32_t db = 0x101 * ((uint32_t)d[0]); 30583| 221| uint32_t sa = 0x101 * ((uint32_t)s[3]); 30584| 221| uint32_t sr = 0x101 * ((uint32_t)s[2]); 30585| 221| uint32_t sg = 0x101 * ((uint32_t)s[1]); 30586| 221| uint32_t sb = 0x101 * ((uint32_t)s[0]); 30587| | 30588| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 30589| 221| uint32_t ia = 0xFFFF - sa; 30590| | 30591| | // Composite src (premul) over dst (premul). 30592| 221| dr = sr + ((dr * ia) / 0xFFFF); 30593| 221| dg = sg + ((dg * ia) / 0xFFFF); 30594| 221| db = sb + ((db * ia) / 0xFFFF); 30595| | 30596| | // Convert to 16-bit color to 8-bit gray. 30597| 221| uint32_t weighted_average = 30598| 221| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 30599| 221| d[0] = (uint8_t)(weighted_average >> 24); 30600| | 30601| 221| s += 1 * 4; 30602| 221| d += 1 * 1; 30603| 221| n -= 1; 30604| 221| } 30605| | 30606| 18| return len; 30607| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src: 26247| 9| size_t src_len) { 26248| 9| size_t dst_len2 = dst_len / 2; 26249| 9| size_t src_len4 = src_len / 4; 26250| 9| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26250:16): [True: 3, False: 6] ------------------ 26251| 9| uint8_t* d = dst_ptr; 26252| 9| const uint8_t* s = src_ptr; 26253| 9| size_t n = len; 26254| | 26255| | // TODO: unroll. 26256| | 26257| 171| while (n >= 1) { ------------------ | Branch (26257:10): [True: 162, False: 9] ------------------ 26258| 162| wuffs_base__poke_u16le__no_bounds_check( 26259| 162| d + (0 * 2), wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26260| 162| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 26261| | 26262| 162| s += 1 * 4; 26263| 162| d += 1 * 2; 26264| 162| n -= 1; 26265| 162| } 26266| | 26267| 9| return len; 26268| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over: 26309| 10| size_t src_len) { 26310| 10| size_t dst_len2 = dst_len / 2; 26311| 10| size_t src_len4 = src_len / 4; 26312| 10| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26312:16): [True: 1, False: 9] ------------------ 26313| 10| uint8_t* d = dst_ptr; 26314| 10| const uint8_t* s = src_ptr; 26315| 10| size_t n = len; 26316| | 26317| | // TODO: unroll. 26318| | 26319| 195| while (n >= 1) { ------------------ | Branch (26319:10): [True: 185, False: 10] ------------------ 26320| | // Extract 16-bit color components. 26321| 185| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26322| 185| uint32_t sr = 0x101 * ((uint32_t)s[2]); 26323| 185| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26324| 185| uint32_t sb = 0x101 * ((uint32_t)s[0]); 26325| | 26326| | // Convert from 565 color to 16-bit color. 26327| 185| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26328| 185| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26329| 185| uint32_t dr = (0x8421 * old_r5) >> 4; 26330| 185| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26331| 185| uint32_t dg = (0x1041 * old_g6) >> 2; 26332| 185| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26333| 185| uint32_t db = (0x8421 * old_b5) >> 4; 26334| | 26335| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26336| 185| uint32_t ia = 0xFFFF - sa; 26337| | 26338| | // Composite src (premul) over dst (premul). 26339| 185| dr = sr + ((dr * ia) / 0xFFFF); 26340| 185| dg = sg + ((dg * ia) / 0xFFFF); 26341| 185| db = sb + ((db * ia) / 0xFFFF); 26342| | 26343| | // Convert from 16-bit color to 565 color and combine the components. 26344| 185| uint32_t new_r5 = 0x1F & (dr >> 11); 26345| 185| uint32_t new_g6 = 0x3F & (dg >> 10); 26346| 185| uint32_t new_b5 = 0x1F & (db >> 11); 26347| 185| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26348| 185| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26349| | 26350| 185| s += 1 * 4; 26351| 185| d += 1 * 2; 26352| 185| n -= 1; 26353| 185| } 26354| | 26355| 10| return len; 26356| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src: 27115| 16| size_t src_len) { 27116| 16| size_t dst_len3 = dst_len / 3; 27117| 16| size_t src_len4 = src_len / 4; 27118| 16| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27118:16): [True: 2, False: 14] ------------------ 27119| 16| uint8_t* d = dst_ptr; 27120| 16| const uint8_t* s = src_ptr; 27121| 16| size_t n = len; 27122| | 27123| 376| while (n >= 1) { ------------------ | Branch (27123:10): [True: 360, False: 16] ------------------ 27124| 360| uint8_t s0 = s[0]; 27125| 360| uint8_t s1 = s[1]; 27126| 360| uint8_t s2 = s[2]; 27127| 360| d[0] = s0; 27128| 360| d[1] = s1; 27129| 360| d[2] = s2; 27130| | 27131| 360| s += 1 * 4; 27132| 360| d += 1 * 3; 27133| 360| n -= 1; 27134| 360| } 27135| | 27136| 16| return len; 27137| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src_over: 27175| 15| size_t src_len) { 27176| 15| size_t dst_len3 = dst_len / 3; 27177| 15| size_t src_len4 = src_len / 4; 27178| 15| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27178:16): [True: 3, False: 12] ------------------ 27179| 15| uint8_t* d = dst_ptr; 27180| 15| const uint8_t* s = src_ptr; 27181| 15| size_t n = len; 27182| | 27183| 320| while (n >= 1) { ------------------ | Branch (27183:10): [True: 305, False: 15] ------------------ 27184| | // Extract 16-bit color components. 27185| 305| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27186| 305| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27187| 305| uint32_t db = 0x101 * ((uint32_t)d[0]); 27188| 305| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27189| 305| uint32_t sr = 0x101 * ((uint32_t)s[2]); 27190| 305| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27191| 305| uint32_t sb = 0x101 * ((uint32_t)s[0]); 27192| | 27193| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27194| 305| uint32_t ia = 0xFFFF - sa; 27195| | 27196| | // Composite src (premul) over dst (premul). 27197| 305| dr = sr + ((dr * ia) / 0xFFFF); 27198| 305| dg = sg + ((dg * ia) / 0xFFFF); 27199| 305| db = sb + ((db * ia) / 0xFFFF); 27200| | 27201| | // Convert from 16-bit color to 8-bit color. 27202| 305| d[0] = (uint8_t)(db >> 8); 27203| 305| d[1] = (uint8_t)(dg >> 8); 27204| 305| d[2] = (uint8_t)(dr >> 8); 27205| | 27206| 305| s += 1 * 4; 27207| 305| d += 1 * 3; 27208| 305| n -= 1; 27209| 305| } 27210| | 27211| 15| return len; 27212| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src: 27704| 35| size_t src_len) { 27705| 35| size_t dst_len4 = dst_len / 4; 27706| 35| size_t src_len4 = src_len / 4; 27707| 35| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27707:16): [True: 7, False: 28] ------------------ 27708| 35| uint8_t* d = dst_ptr; 27709| 35| const uint8_t* s = src_ptr; 27710| 35| size_t n = len; 27711| | 27712| 457| while (n >= 1) { ------------------ | Branch (27712:10): [True: 422, False: 35] ------------------ 27713| 422| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27714| 422| wuffs_base__poke_u32le__no_bounds_check( 27715| 422| d + (0 * 4), 27716| 422| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0)); 27717| | 27718| 422| s += 1 * 4; 27719| 422| d += 1 * 4; 27720| 422| n -= 1; 27721| 422| } 27722| | 27723| 35| return len; 27724| 35|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over: 27733| 30| size_t src_len) { 27734| 30| size_t dst_len4 = dst_len / 4; 27735| 30| size_t src_len4 = src_len / 4; 27736| 30| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27736:16): [True: 6, False: 24] ------------------ 27737| 30| uint8_t* d = dst_ptr; 27738| 30| const uint8_t* s = src_ptr; 27739| 30| size_t n = len; 27740| | 27741| 361| while (n >= 1) { ------------------ | Branch (27741:10): [True: 331, False: 30] ------------------ 27742| 331| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27743| 331| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27744| 331| wuffs_base__poke_u32le__no_bounds_check( 27745| 331| d + (0 * 4), 27746| 331| wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0)); 27747| | 27748| 331| s += 1 * 4; 27749| 331| d += 1 * 4; 27750| 331| n -= 1; 27751| 331| } 27752| | 27753| 30| return len; 27754| 30|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u32_axxx: 25527| 668| uint32_t src_premul) { 25528| | // Extract 16-bit color components. 25529| 668| uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24)); 25530| 668| uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16)); 25531| 668| uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8)); 25532| 668| uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0)); 25533| 668| uint32_t sa = 0x101 * (0xFF & (src_premul >> 24)); 25534| 668| uint32_t sr = 0x101 * (0xFF & (src_premul >> 16)); 25535| 668| uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)); 25536| 668| uint32_t sb = 0x101 * (0xFF & (src_premul >> 0)); 25537| | 25538| | // Convert dst from nonpremul to premul. 25539| 668| dr = (dr * da) / 0xFFFF; 25540| 668| dg = (dg * da) / 0xFFFF; 25541| 668| db = (db * da) / 0xFFFF; 25542| | 25543| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25544| 668| uint32_t ia = 0xFFFF - sa; 25545| | 25546| | // Composite src (premul) over dst (premul). 25547| 668| da = sa + ((da * ia) / 0xFFFF); 25548| 668| dr = sr + ((dr * ia) / 0xFFFF); 25549| 668| dg = sg + ((dg * ia) / 0xFFFF); 25550| 668| db = sb + ((db * ia) / 0xFFFF); 25551| | 25552| | // Convert dst from premul to nonpremul. 25553| 668| if (da != 0) { ------------------ | Branch (25553:7): [True: 533, False: 135] ------------------ 25554| 533| dr = (dr * 0xFFFF) / da; 25555| 533| dg = (dg * 0xFFFF) / da; 25556| 533| db = (db * 0xFFFF) / da; 25557| 533| } 25558| | 25559| | // Convert from 16-bit color to 8-bit color. 25560| 668| da >>= 8; 25561| 668| dr >>= 8; 25562| 668| dg >>= 8; 25563| 668| db >>= 8; 25564| | 25565| | // Combine components. 25566| 668| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25567| 668|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src: 28110| 29| size_t src_len) { 28111| 29| size_t dst_len8 = dst_len / 8; 28112| 29| size_t src_len4 = src_len / 4; 28113| 29| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28113:16): [True: 9, False: 20] ------------------ 28114| 29| uint8_t* d = dst_ptr; 28115| 29| const uint8_t* s = src_ptr; 28116| | 28117| 29| size_t n = len; 28118| 172| while (n >= 1) { ------------------ | Branch (28118:10): [True: 143, False: 29] ------------------ 28119| 143| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28120| 143| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 28121| 143| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 28122| 143| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 28123| | 28124| 143| s += 1 * 4; 28125| 143| d += 1 * 8; 28126| 143| n -= 1; 28127| 143| } 28128| 29| return len; 28129| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over: 28138| 27| size_t src_len) { 28139| 27| size_t dst_len8 = dst_len / 8; 28140| 27| size_t src_len4 = src_len / 4; 28141| 27| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28141:16): [True: 5, False: 22] ------------------ 28142| 27| uint8_t* d = dst_ptr; 28143| 27| const uint8_t* s = src_ptr; 28144| | 28145| 27| size_t n = len; 28146| 213| while (n >= 1) { ------------------ | Branch (28146:10): [True: 186, False: 27] ------------------ 28147| 186| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28148| 186| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28149| 186| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28150| 186| wuffs_base__poke_u64le__no_bounds_check( 28151| 186| d + (0 * 8), 28152| 186| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 28153| | 28154| 186| s += 1 * 4; 28155| 186| d += 1 * 8; 28156| 186| n -= 1; 28157| 186| } 28158| 27| return len; 28159| 27|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u64_axxx: 25571| 974| uint64_t src_premul) { 25572| | // Extract components. 25573| 974| uint64_t da = 0xFFFF & (dst_nonpremul >> 48); 25574| 974| uint64_t dr = 0xFFFF & (dst_nonpremul >> 32); 25575| 974| uint64_t dg = 0xFFFF & (dst_nonpremul >> 16); 25576| 974| uint64_t db = 0xFFFF & (dst_nonpremul >> 0); 25577| 974| uint64_t sa = 0xFFFF & (src_premul >> 48); 25578| 974| uint64_t sr = 0xFFFF & (src_premul >> 32); 25579| 974| uint64_t sg = 0xFFFF & (src_premul >> 16); 25580| 974| uint64_t sb = 0xFFFF & (src_premul >> 0); 25581| | 25582| | // Convert dst from nonpremul to premul. 25583| 974| dr = (dr * da) / 0xFFFF; 25584| 974| dg = (dg * da) / 0xFFFF; 25585| 974| db = (db * da) / 0xFFFF; 25586| | 25587| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25588| 974| uint64_t ia = 0xFFFF - sa; 25589| | 25590| | // Composite src (premul) over dst (premul). 25591| 974| da = sa + ((da * ia) / 0xFFFF); 25592| 974| dr = sr + ((dr * ia) / 0xFFFF); 25593| 974| dg = sg + ((dg * ia) / 0xFFFF); 25594| 974| db = sb + ((db * ia) / 0xFFFF); 25595| | 25596| | // Convert dst from premul to nonpremul. 25597| 974| if (da != 0) { ------------------ | Branch (25597:7): [True: 795, False: 179] ------------------ 25598| 795| dr = (dr * 0xFFFF) / da; 25599| 795| dg = (dg * 0xFFFF) / da; 25600| 795| db = (db * 0xFFFF) / da; 25601| 795| } 25602| | 25603| | // Combine components. 25604| 974| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25605| 974|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over: 28604| 16| size_t src_len) { 28605| 16| size_t dst_len4 = dst_len / 4; 28606| 16| size_t src_len4 = src_len / 4; 28607| 16| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28607:16): [True: 4, False: 12] ------------------ 28608| 16| uint8_t* d = dst_ptr; 28609| 16| const uint8_t* s = src_ptr; 28610| 16| size_t n = len; 28611| | 28612| | // TODO: unroll. 28613| | 28614| 188| while (n >= 1) { ------------------ | Branch (28614:10): [True: 172, False: 16] ------------------ 28615| 172| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28616| 172| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 28617| 172| wuffs_base__poke_u32le__no_bounds_check( 28618| 172| d + (0 * 4), 28619| 172| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 28620| | 28621| 172| s += 1 * 4; 28622| 172| d += 1 * 4; 28623| 172| n -= 1; 28624| 172| } 28625| | 28626| 16| return len; 28627| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u32_axxx: 25669| 667| uint32_t src_premul) { 25670| | // Extract 16-bit color components. 25671| 667| uint32_t da = 0x101 * (0xFF & (dst_premul >> 24)); 25672| 667| uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16)); 25673| 667| uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8)); 25674| 667| uint32_t db = 0x101 * (0xFF & (dst_premul >> 0)); 25675| 667| uint32_t sa = 0x101 * (0xFF & (src_premul >> 24)); 25676| 667| uint32_t sr = 0x101 * (0xFF & (src_premul >> 16)); 25677| 667| uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)); 25678| 667| uint32_t sb = 0x101 * (0xFF & (src_premul >> 0)); 25679| | 25680| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25681| 667| uint32_t ia = 0xFFFF - sa; 25682| | 25683| | // Composite src (premul) over dst (premul). 25684| 667| da = sa + ((da * ia) / 0xFFFF); 25685| 667| dr = sr + ((dr * ia) / 0xFFFF); 25686| 667| dg = sg + ((dg * ia) / 0xFFFF); 25687| 667| db = sb + ((db * ia) / 0xFFFF); 25688| | 25689| | // Convert from 16-bit color to 8-bit color. 25690| 667| da >>= 8; 25691| 667| dr >>= 8; 25692| 667| dg >>= 8; 25693| 667| db >>= 8; 25694| | 25695| | // Combine components. 25696| 667| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25697| 667|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul__src: 27425| 11| size_t src_len) { 27426| 11| size_t dst_len3 = dst_len / 3; 27427| 11| size_t src_len4 = src_len / 4; 27428| 11| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27428:16): [True: 2, False: 9] ------------------ 27429| 11| uint8_t* d = dst_ptr; 27430| 11| const uint8_t* s = src_ptr; 27431| 11| size_t n = len; 27432| | 27433| 252| while (n >= 1) { ------------------ | Branch (27433:10): [True: 241, False: 11] ------------------ 27434| 241| uint8_t s0 = s[0]; 27435| 241| uint8_t s1 = s[1]; 27436| 241| uint8_t s2 = s[2]; 27437| 241| d[0] = s2; 27438| 241| d[1] = s1; 27439| 241| d[2] = s0; 27440| | 27441| 241| s += 1 * 4; 27442| 241| d += 1 * 3; 27443| 241| n -= 1; 27444| 241| } 27445| | 27446| 11| return len; 27447| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul__src_over: 27486| 10| size_t src_len) { 27487| 10| size_t dst_len3 = dst_len / 3; 27488| 10| size_t src_len4 = src_len / 4; 27489| 10| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27489:16): [True: 3, False: 7] ------------------ 27490| 10| uint8_t* d = dst_ptr; 27491| 10| const uint8_t* s = src_ptr; 27492| 10| size_t n = len; 27493| | 27494| 140| while (n >= 1) { ------------------ | Branch (27494:10): [True: 130, False: 10] ------------------ 27495| | // Extract 16-bit color components. 27496| 130| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27497| 130| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27498| 130| uint32_t db = 0x101 * ((uint32_t)d[0]); 27499| 130| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27500| 130| uint32_t sb = 0x101 * ((uint32_t)s[2]); 27501| 130| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27502| 130| uint32_t sr = 0x101 * ((uint32_t)s[0]); 27503| | 27504| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27505| 130| uint32_t ia = 0xFFFF - sa; 27506| | 27507| | // Composite src (premul) over dst (premul). 27508| 130| dr = sr + ((dr * ia) / 0xFFFF); 27509| 130| dg = sg + ((dg * ia) / 0xFFFF); 27510| 130| db = sb + ((db * ia) / 0xFFFF); 27511| | 27512| | // Convert from 16-bit color to 8-bit color. 27513| 130| d[0] = (uint8_t)(db >> 8); 27514| 130| d[1] = (uint8_t)(dg >> 8); 27515| 130| d[2] = (uint8_t)(dr >> 8); 27516| | 27517| 130| s += 1 * 4; 27518| 130| d += 1 * 3; 27519| 130| n -= 1; 27520| 130| } 27521| | 27522| 10| return len; 27523| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src: 27891| 33| size_t src_len) { 27892| 33| size_t dst_len4 = dst_len / 4; 27893| 33| size_t src_len4 = src_len / 4; 27894| 33| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27894:16): [True: 6, False: 27] ------------------ 27895| 33| uint8_t* d = dst_ptr; 27896| 33| const uint8_t* s = src_ptr; 27897| 33| size_t n = len; 27898| | 27899| 478| while (n >= 1) { ------------------ | Branch (27899:10): [True: 445, False: 33] ------------------ 27900| 445| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27901| 445| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27902| 445| wuffs_base__poke_u32le__no_bounds_check( 27903| 445| d + (0 * 4), 27904| 445| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0)); 27905| | 27906| 445| s += 1 * 4; 27907| 445| d += 1 * 4; 27908| 445| n -= 1; 27909| 445| } 27910| | 27911| 33| return len; 27912| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over: 27921| 31| size_t src_len) { 27922| 31| size_t dst_len4 = dst_len / 4; 27923| 31| size_t src_len4 = src_len / 4; 27924| 31| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27924:16): [True: 7, False: 24] ------------------ 27925| 31| uint8_t* d = dst_ptr; 27926| 31| const uint8_t* s = src_ptr; 27927| 31| size_t n = len; 27928| | 27929| 368| while (n >= 1) { ------------------ | Branch (27929:10): [True: 337, False: 31] ------------------ 27930| 337| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27931| 337| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27932| 337| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27933| 337| wuffs_base__poke_u32le__no_bounds_check( 27934| 337| d + (0 * 4), 27935| 337| wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0)); 27936| | 27937| 337| s += 1 * 4; 27938| 337| d += 1 * 4; 27939| 337| n -= 1; 27940| 337| } 27941| | 27942| 31| return len; 27943| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over: 28839| 13| size_t src_len) { 28840| 13| size_t dst_len4 = dst_len / 4; 28841| 13| size_t src_len4 = src_len / 4; 28842| 13| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28842:16): [True: 2, False: 11] ------------------ 28843| 13| uint8_t* d = dst_ptr; 28844| 13| const uint8_t* s = src_ptr; 28845| 13| size_t n = len; 28846| | 28847| 243| while (n >= 1) { ------------------ | Branch (28847:10): [True: 230, False: 13] ------------------ 28848| 230| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28849| 230| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28850| 230| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28851| 230| wuffs_base__poke_u32le__no_bounds_check( 28852| 230| d + (0 * 4), 28853| 230| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 28854| | 28855| 230| s += 1 * 4; 28856| 230| d += 1 * 4; 28857| 230| n -= 1; 28858| 230| } 28859| | 28860| 13| return len; 28861| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le: 32090| 420| wuffs_base__pixel_blend blend) { 32091| 420| switch (dst_pixfmt.repr) { ------------------ | Branch (32091:11): [True: 407, False: 13] ------------------ 32092| 24| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 24|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32092:5): [True: 24, False: 396] ------------------ 32093| 24| switch (blend) { ------------------ | Branch (32093:15): [True: 24, False: 0] ------------------ 32094| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32094:9): [True: 8, False: 16] ------------------ 32095| 8| return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src; 32096| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32096:9): [True: 16, False: 8] ------------------ 32097| 16| return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over; 32098| 24| } 32099| 0| return NULL; 32100| | 32101| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32101:5): [True: 19, False: 401] ------------------ 32102| 19| switch (blend) { ------------------ | Branch (32102:15): [True: 19, False: 0] ------------------ 32103| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32103:9): [True: 9, False: 10] ------------------ 32104| 9| return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src; 32105| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32105:9): [True: 10, False: 9] ------------------ 32106| 10| return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over; 32107| 19| } 32108| 0| return NULL; 32109| | 32110| 25| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32110:5): [True: 25, False: 395] ------------------ 32111| 25| switch (blend) { ------------------ | Branch (32111:15): [True: 25, False: 0] ------------------ 32112| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32112:9): [True: 9, False: 16] ------------------ 32113| 9| return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src; 32114| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32114:9): [True: 16, False: 9] ------------------ 32115| 16| return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over; 32116| 25| } 32117| 0| return NULL; 32118| | 32119| 77| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 77|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32119:5): [True: 77, False: 343] ------------------ 32120| 77| switch (blend) { ------------------ | Branch (32120:15): [True: 77, False: 0] ------------------ 32121| 50| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 50|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32121:9): [True: 50, False: 27] ------------------ 32122| 50| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src; 32123| 27| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 27|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32123:9): [True: 27, False: 50] ------------------ 32124| 27| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over; 32125| 77| } 32126| 0| return NULL; 32127| | 32128| 74| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 74|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32128:5): [True: 74, False: 346] ------------------ 32129| | 32130| 74| switch (blend) { ------------------ | Branch (32130:15): [True: 74, False: 0] ------------------ 32131| 48| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 48|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32131:9): [True: 48, False: 26] ------------------ 32132| 48| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src; 32133| 26| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 26|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32133:9): [True: 26, False: 48] ------------------ 32134| 26| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over; 32135| 74| } 32136| 0| return NULL; 32137| | 32138| 22| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32138:5): [True: 22, False: 398] ------------------ 32139| 22| switch (blend) { ------------------ | Branch (32139:15): [True: 22, False: 0] ------------------ 32140| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32140:9): [True: 11, False: 11] ------------------ 32141| 11| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src; 32142| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32142:9): [True: 11, False: 11] ------------------ 32143| 11| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src_over; 32144| 22| } 32145| 0| return NULL; 32146| | 32147| 14| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (32147:5): [True: 14, False: 406] ------------------ 32148| 14| switch (blend) { ------------------ | Branch (32148:15): [True: 14, False: 0] ------------------ 32149| 0| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32149:9): [True: 0, False: 14] ------------------ 32150| 0| return wuffs_private_impl__swizzle_copy_8_8; 32151| 14| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 14|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32151:9): [True: 14, False: 0] ------------------ 32152| 14| return wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over; 32153| 14| } 32154| 0| return NULL; 32155| | 32156| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32156:5): [True: 0, False: 420] ------------------ 32157| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32157:5): [True: 4, False: 416] ------------------ 32158| | // TODO. 32159| 4| break; 32160| | 32161| 27| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 27|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32161:5): [True: 27, False: 393] ------------------ 32162| 27| switch (blend) { ------------------ | Branch (32162:15): [True: 27, False: 0] ------------------ 32163| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32163:9): [True: 11, False: 16] ------------------ 32164| 11| return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src; 32165| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32165:9): [True: 16, False: 11] ------------------ 32166| 16| return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over; 32167| 27| } 32168| 0| return NULL; 32169| | 32170| 92| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 92|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32170:5): [True: 92, False: 328] ------------------ 32171| 92| switch (blend) { ------------------ | Branch (32171:15): [True: 92, False: 0] ------------------ 32172| 56| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 56|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32172:9): [True: 56, False: 36] ------------------ 32173| 56| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src; 32174| 36| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 36|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32174:9): [True: 36, False: 56] ------------------ 32175| 36| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over; 32176| 92| } 32177| 0| break; 32178| | 32179| 29| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 29|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32179:5): [True: 29, False: 391] ------------------ 32180| 29| switch (blend) { ------------------ | Branch (32180:15): [True: 29, False: 0] ------------------ 32181| 19| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32181:9): [True: 19, False: 10] ------------------ 32182| 19| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src; 32183| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32183:9): [True: 10, False: 19] ------------------ 32184| 10| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src_over; 32185| 29| } 32186| 0| return NULL; 32187| | 32188| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (32188:5): [True: 0, False: 420] ------------------ 32189| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (32189:5): [True: 0, False: 420] ------------------ 32190| | // TODO. 32191| 0| break; 32192| 420| } 32193| 17| return NULL; 32194| 420|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src: 30615| 8| size_t src_len) { 30616| 8| size_t src_len8 = src_len / 8; 30617| 8| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (30617:16): [True: 1, False: 7] ------------------ 30618| 8| uint8_t* d = dst_ptr; 30619| 8| const uint8_t* s = src_ptr; 30620| 8| size_t n = len; 30621| | 30622| | // TODO: unroll. 30623| | 30624| 74| while (n >= 1) { ------------------ | Branch (30624:10): [True: 66, False: 8] ------------------ 30625| 66| d[0] = wuffs_base__color_u64_argb_premul__as__color_u8_gray( 30626| 66| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 30627| | 30628| 66| s += 1 * 8; 30629| 66| d += 1 * 1; 30630| 66| n -= 1; 30631| 66| } 30632| | 30633| 8| return len; 30634| 8|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u8_gray: 4576| 66|wuffs_base__color_u64_argb_premul__as__color_u8_gray(uint64_t argb_premul) { 4577| 66| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_premul >> 32))); 4578| 66| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_premul >> 16))); 4579| 66| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_premul >> 0))); 4580| | 4581| | // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same 4582| | // as those given by the JFIF specification. 4583| | // 4584| | // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We 4585| | // shift by 24, not just by 16, because the return value is 8-bit color, not 4586| | // 16-bit color. 4587| 66| uint32_t weighted_average = 4588| 66| (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; 4589| 66| return (uint8_t)(weighted_average >> 24); 4590| 66|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over: 30643| 16| size_t src_len) { 30644| 16| size_t src_len8 = src_len / 8; 30645| 16| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (30645:16): [True: 1, False: 15] ------------------ 30646| 16| uint8_t* d = dst_ptr; 30647| 16| const uint8_t* s = src_ptr; 30648| 16| size_t n = len; 30649| | 30650| | // TODO: unroll. 30651| | 30652| 155| while (n >= 1) { ------------------ | Branch (30652:10): [True: 139, False: 16] ------------------ 30653| | // Extract 16-bit color components. 30654| 139| uint32_t dr = 0x101 * ((uint32_t)d[0]); 30655| 139| uint32_t dg = 0x101 * ((uint32_t)d[0]); 30656| 139| uint32_t db = 0x101 * ((uint32_t)d[0]); 30657| 139| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 30658| 139| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 30659| 139| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 30660| 139| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 30661| | 30662| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 30663| 139| uint32_t ia = 0xFFFF - sa; 30664| | 30665| | // Composite src (premul) over dst (premul). 30666| 139| dr = sr + ((dr * ia) / 0xFFFF); 30667| 139| dg = sg + ((dg * ia) / 0xFFFF); 30668| 139| db = sb + ((db * ia) / 0xFFFF); 30669| | 30670| | // Convert to 16-bit color to 8-bit gray. 30671| 139| uint32_t weighted_average = 30672| 139| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 30673| 139| d[0] = (uint8_t)(weighted_average >> 24); 30674| | 30675| 139| s += 1 * 8; 30676| 139| d += 1 * 1; 30677| 139| n -= 1; 30678| 139| } 30679| | 30680| 16| return len; 30681| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src: 26277| 9| size_t src_len) { 26278| 9| size_t dst_len2 = dst_len / 2; 26279| 9| size_t src_len8 = src_len / 8; 26280| 9| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (26280:16): [True: 1, False: 8] ------------------ 26281| 9| uint8_t* d = dst_ptr; 26282| 9| const uint8_t* s = src_ptr; 26283| 9| size_t n = len; 26284| | 26285| | // TODO: unroll. 26286| | 26287| 84| while (n >= 1) { ------------------ | Branch (26287:10): [True: 75, False: 9] ------------------ 26288| 75| wuffs_base__poke_u16le__no_bounds_check( 26289| 75| d + (0 * 2), 26290| 75| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26291| 75| wuffs_base__color_u64__as__color_u32( 26292| 75| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 26293| | 26294| 75| s += 1 * 8; 26295| 75| d += 1 * 2; 26296| 75| n -= 1; 26297| 75| } 26298| | 26299| 9| return len; 26300| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over: 26365| 10| size_t src_len) { 26366| 10| size_t dst_len2 = dst_len / 2; 26367| 10| size_t src_len8 = src_len / 8; 26368| 10| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (26368:16): [True: 1, False: 9] ------------------ 26369| 10| uint8_t* d = dst_ptr; 26370| 10| const uint8_t* s = src_ptr; 26371| 10| size_t n = len; 26372| | 26373| | // TODO: unroll. 26374| | 26375| 137| while (n >= 1) { ------------------ | Branch (26375:10): [True: 127, False: 10] ------------------ 26376| | // Extract 16-bit color components. 26377| 127| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26378| 127| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26379| 127| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26380| 127| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 26381| | 26382| | // Convert from 565 color to 16-bit color. 26383| 127| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26384| 127| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26385| 127| uint32_t dr = (0x8421 * old_r5) >> 4; 26386| 127| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26387| 127| uint32_t dg = (0x1041 * old_g6) >> 2; 26388| 127| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26389| 127| uint32_t db = (0x8421 * old_b5) >> 4; 26390| | 26391| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26392| 127| uint32_t ia = 0xFFFF - sa; 26393| | 26394| | // Composite src (premul) over dst (premul). 26395| 127| dr = sr + ((dr * ia) / 0xFFFF); 26396| 127| dg = sg + ((dg * ia) / 0xFFFF); 26397| 127| db = sb + ((db * ia) / 0xFFFF); 26398| | 26399| | // Convert from 16-bit color to 565 color and combine the components. 26400| 127| uint32_t new_r5 = 0x1F & (dr >> 11); 26401| 127| uint32_t new_g6 = 0x3F & (dg >> 10); 26402| 127| uint32_t new_b5 = 0x1F & (db >> 11); 26403| 127| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26404| 127| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26405| | 26406| 127| s += 1 * 8; 26407| 127| d += 1 * 2; 26408| 127| n -= 1; 26409| 127| } 26410| | 26411| 10| return len; 26412| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src: 27146| 9| size_t src_len) { 27147| 9| size_t dst_len3 = dst_len / 3; 27148| 9| size_t src_len8 = src_len / 8; 27149| 9| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27149:16): [True: 1, False: 8] ------------------ 27150| 9| uint8_t* d = dst_ptr; 27151| 9| const uint8_t* s = src_ptr; 27152| 9| size_t n = len; 27153| | 27154| | // TODO: unroll. 27155| | 27156| 58| while (n >= 1) { ------------------ | Branch (27156:10): [True: 49, False: 9] ------------------ 27157| 49| uint32_t s0 = wuffs_base__color_u64__as__color_u32( 27158| 49| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 27159| 49| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27160| | 27161| 49| s += 1 * 8; 27162| 49| d += 1 * 3; 27163| 49| n -= 1; 27164| 49| } 27165| | 27166| 9| return len; 27167| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over: 27221| 16| size_t src_len) { 27222| 16| size_t dst_len3 = dst_len / 3; 27223| 16| size_t src_len8 = src_len / 8; 27224| 16| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27224:16): [True: 4, False: 12] ------------------ 27225| 16| uint8_t* d = dst_ptr; 27226| 16| const uint8_t* s = src_ptr; 27227| 16| size_t n = len; 27228| | 27229| | // TODO: unroll. 27230| | 27231| 205| while (n >= 1) { ------------------ | Branch (27231:10): [True: 189, False: 16] ------------------ 27232| | // Extract 16-bit color components. 27233| 189| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27234| 189| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27235| 189| uint32_t db = 0x101 * ((uint32_t)d[0]); 27236| 189| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27237| 189| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27238| 189| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27239| 189| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 27240| | 27241| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27242| 189| uint32_t ia = 0xFFFF - sa; 27243| | 27244| | // Composite src (premul) over dst (premul). 27245| 189| dr = sr + ((dr * ia) / 0xFFFF); 27246| 189| dg = sg + ((dg * ia) / 0xFFFF); 27247| 189| db = sb + ((db * ia) / 0xFFFF); 27248| | 27249| | // Convert from 16-bit color to 8-bit color. 27250| 189| d[0] = (uint8_t)(db >> 8); 27251| 189| d[1] = (uint8_t)(dg >> 8); 27252| 189| d[2] = (uint8_t)(dr >> 8); 27253| | 27254| 189| s += 1 * 8; 27255| 189| d += 1 * 3; 27256| 189| n -= 1; 27257| 189| } 27258| | 27259| 16| return len; 27260| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src: 27763| 50| size_t src_len) { 27764| 50| size_t dst_len4 = dst_len / 4; 27765| 50| size_t src_len8 = src_len / 8; 27766| 50| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27766:16): [True: 7, False: 43] ------------------ 27767| 50| uint8_t* d = dst_ptr; 27768| 50| const uint8_t* s = src_ptr; 27769| | 27770| 50| size_t n = len; 27771| 432| while (n >= 1) { ------------------ | Branch (27771:10): [True: 382, False: 50] ------------------ 27772| 382| wuffs_base__poke_u32le__no_bounds_check( 27773| 382| d + (0 * 4), 27774| 382| wuffs_base__color_u64__as__color_u32( 27775| 382| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul( 27776| 382| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 27777| | 27778| 382| s += 1 * 8; 27779| 382| d += 1 * 4; 27780| 382| n -= 1; 27781| 382| } 27782| 50| return len; 27783| 50|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul: 4594| 954| uint64_t argb_premul) { 4595| 954| uint64_t a = 0xFFFF & (argb_premul >> 48); 4596| 954| if (a == 0xFFFF) { ------------------ | Branch (4596:7): [True: 131, False: 823] ------------------ 4597| 131| return argb_premul; 4598| 823| } else if (a == 0) { ------------------ | Branch (4598:14): [True: 148, False: 675] ------------------ 4599| 148| return 0; 4600| 148| } 4601| | 4602| 675| uint64_t r = 0xFFFF & (argb_premul >> 32); 4603| 675| r = (r * 0xFFFF) / a; 4604| 675| uint64_t g = 0xFFFF & (argb_premul >> 16); 4605| 675| g = (g * 0xFFFF) / a; 4606| 675| uint64_t b = 0xFFFF & (argb_premul >> 0); 4607| 675| b = (b * 0xFFFF) / a; 4608| | 4609| 675| return (a << 48) | (r << 32) | (g << 16) | (b << 0); 4610| 954|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over: 27792| 27| size_t src_len) { 27793| 27| size_t dst_len4 = dst_len / 4; 27794| 27| size_t src_len8 = src_len / 8; 27795| 27| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27795:16): [True: 3, False: 24] ------------------ 27796| 27| uint8_t* d = dst_ptr; 27797| 27| const uint8_t* s = src_ptr; 27798| 27| size_t n = len; 27799| | 27800| 180| while (n >= 1) { ------------------ | Branch (27800:10): [True: 153, False: 27] ------------------ 27801| 153| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 27802| 153| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 27803| 153| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27804| 153| wuffs_base__poke_u32le__no_bounds_check( 27805| 153| d + (0 * 4), 27806| 153| wuffs_base__color_u64__as__color_u32( 27807| 153| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0))); 27808| | 27809| 153| s += 1 * 8; 27810| 153| d += 1 * 4; 27811| 153| n -= 1; 27812| 153| } 27813| | 27814| 27| return len; 27815| 27|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src: 28168| 48| size_t src_len) { 28169| 48| size_t dst_len8 = dst_len / 8; 28170| 48| size_t src_len8 = src_len / 8; 28171| 48| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (28171:16): [True: 12, False: 36] ------------------ 28172| 48| uint8_t* d = dst_ptr; 28173| 48| const uint8_t* s = src_ptr; 28174| | 28175| 48| size_t n = len; 28176| 309| while (n >= 1) { ------------------ | Branch (28176:10): [True: 261, False: 48] ------------------ 28177| 261| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28178| 261| wuffs_base__poke_u64le__no_bounds_check( 28179| 261| d + (0 * 8), 28180| 261| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(s0)); 28181| | 28182| 261| s += 1 * 8; 28183| 261| d += 1 * 8; 28184| 261| n -= 1; 28185| 261| } 28186| 48| return len; 28187| 48|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over: 28196| 26| size_t src_len) { 28197| 26| size_t dst_len8 = dst_len / 8; 28198| 26| size_t src_len8 = src_len / 8; 28199| 26| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (28199:16): [True: 5, False: 21] ------------------ 28200| 26| uint8_t* d = dst_ptr; 28201| 26| const uint8_t* s = src_ptr; 28202| | 28203| 26| size_t n = len; 28204| 226| while (n >= 1) { ------------------ | Branch (28204:10): [True: 200, False: 26] ------------------ 28205| 200| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28206| 200| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28207| 200| wuffs_base__poke_u64le__no_bounds_check( 28208| 200| d + (0 * 8), 28209| 200| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 28210| | 28211| 200| s += 1 * 8; 28212| 200| d += 1 * 8; 28213| 200| n -= 1; 28214| 200| } 28215| 26| return len; 28216| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src: 28574| 11| size_t src_len) { 28575| 11| size_t dst_len4 = dst_len / 4; 28576| 11| size_t src_len8 = src_len / 8; 28577| 11| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28577:16): [True: 1, False: 10] ------------------ 28578| 11| uint8_t* d = dst_ptr; 28579| 11| const uint8_t* s = src_ptr; 28580| 11| size_t n = len; 28581| | 28582| | // TODO: unroll. 28583| | 28584| 89| while (n >= 1) { ------------------ | Branch (28584:10): [True: 78, False: 11] ------------------ 28585| 78| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28586| 78| wuffs_base__poke_u32le__no_bounds_check( 28587| 78| d + (0 * 4), wuffs_base__color_u64__as__color_u32(s0)); 28588| | 28589| 78| s += 1 * 8; 28590| 78| d += 1 * 4; 28591| 78| n -= 1; 28592| 78| } 28593| | 28594| 11| return len; 28595| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src_over: 28636| 11| size_t src_len) { 28637| 11| size_t dst_len4 = dst_len / 4; 28638| 11| size_t src_len8 = src_len / 8; 28639| 11| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28639:16): [True: 3, False: 8] ------------------ 28640| 11| uint8_t* d = dst_ptr; 28641| 11| const uint8_t* s = src_ptr; 28642| 11| size_t n = len; 28643| | 28644| | // TODO: unroll. 28645| | 28646| 110| while (n >= 1) { ------------------ | Branch (28646:10): [True: 99, False: 11] ------------------ 28647| 99| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28648| 99| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28649| 99| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28650| 99| wuffs_base__poke_u32le__no_bounds_check( 28651| 99| d + (0 * 4), 28652| 99| wuffs_base__color_u64__as__color_u32( 28653| 99| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0))); 28654| | 28655| 99| s += 1 * 8; 28656| 99| d += 1 * 4; 28657| 99| n -= 1; 28658| 99| } 28659| | 28660| 11| return len; 28661| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u64_axxx: 25701| 298| uint64_t src_premul) { 25702| | // Extract components. 25703| 298| uint64_t da = 0xFFFF & (dst_premul >> 48); 25704| 298| uint64_t dr = 0xFFFF & (dst_premul >> 32); 25705| 298| uint64_t dg = 0xFFFF & (dst_premul >> 16); 25706| 298| uint64_t db = 0xFFFF & (dst_premul >> 0); 25707| 298| uint64_t sa = 0xFFFF & (src_premul >> 48); 25708| 298| uint64_t sr = 0xFFFF & (src_premul >> 32); 25709| 298| uint64_t sg = 0xFFFF & (src_premul >> 16); 25710| 298| uint64_t sb = 0xFFFF & (src_premul >> 0); 25711| | 25712| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25713| 298| uint64_t ia = 0xFFFF - sa; 25714| | 25715| | // Composite src (premul) over dst (premul). 25716| 298| da = sa + ((da * ia) / 0xFFFF); 25717| 298| dr = sr + ((dr * ia) / 0xFFFF); 25718| 298| dg = sg + ((dg * ia) / 0xFFFF); 25719| 298| db = sb + ((db * ia) / 0xFFFF); 25720| | 25721| | // Combine components. 25722| 298| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25723| 298|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over: 29001| 14| size_t src_len) { 29002| 14| size_t dst_len8 = dst_len / 8; 29003| 14| size_t src_len8 = src_len / 8; 29004| 14| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (29004:16): [True: 4, False: 10] ------------------ 29005| 14| uint8_t* d = dst_ptr; 29006| 14| const uint8_t* s = src_ptr; 29007| | 29008| 14| size_t n = len; 29009| 120| while (n >= 1) { ------------------ | Branch (29009:10): [True: 106, False: 14] ------------------ 29010| 106| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 29011| 106| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 29012| 106| wuffs_base__poke_u64le__no_bounds_check( 29013| 106| d + (0 * 8), 29014| 106| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0)); 29015| | 29016| 106| s += 1 * 8; 29017| 106| d += 1 * 8; 29018| 106| n -= 1; 29019| 106| } 29020| 14| return len; 29021| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src: 27456| 11| size_t src_len) { 27457| 11| size_t dst_len3 = dst_len / 3; 27458| 11| size_t src_len8 = src_len / 8; 27459| 11| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27459:16): [True: 1, False: 10] ------------------ 27460| 11| uint8_t* d = dst_ptr; 27461| 11| const uint8_t* s = src_ptr; 27462| 11| size_t n = len; 27463| | 27464| | // TODO: unroll. 27465| | 27466| 133| while (n >= 1) { ------------------ | Branch (27466:10): [True: 122, False: 11] ------------------ 27467| 122| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27468| 122| wuffs_base__color_u64__as__color_u32( 27469| 122| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 27470| 122| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27471| | 27472| 122| s += 1 * 8; 27473| 122| d += 1 * 3; 27474| 122| n -= 1; 27475| 122| } 27476| | 27477| 11| return len; 27478| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over: 27532| 16| size_t src_len) { 27533| 16| size_t dst_len3 = dst_len / 3; 27534| 16| size_t src_len8 = src_len / 8; 27535| 16| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27535:16): [True: 1, False: 15] ------------------ 27536| 16| uint8_t* d = dst_ptr; 27537| 16| const uint8_t* s = src_ptr; 27538| 16| size_t n = len; 27539| | 27540| | // TODO: unroll. 27541| | 27542| 167| while (n >= 1) { ------------------ | Branch (27542:10): [True: 151, False: 16] ------------------ 27543| | // Extract 16-bit color components. 27544| 151| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27545| 151| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27546| 151| uint32_t db = 0x101 * ((uint32_t)d[0]); 27547| 151| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27548| 151| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27549| 151| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27550| 151| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); 27551| | 27552| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 27553| 151| uint32_t ia = 0xFFFF - sa; 27554| | 27555| | // Composite src (premul) over dst (premul). 27556| 151| dr = sr + ((dr * ia) / 0xFFFF); 27557| 151| dg = sg + ((dg * ia) / 0xFFFF); 27558| 151| db = sb + ((db * ia) / 0xFFFF); 27559| | 27560| | // Convert from 16-bit color to 8-bit color. 27561| 151| d[0] = (uint8_t)(db >> 8); 27562| 151| d[1] = (uint8_t)(dg >> 8); 27563| 151| d[2] = (uint8_t)(dr >> 8); 27564| | 27565| 151| s += 1 * 8; 27566| 151| d += 1 * 3; 27567| 151| n -= 1; 27568| 151| } 27569| | 27570| 16| return len; 27571| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src: 29526| 56| size_t src_len) { 29527| 56| size_t dst_len4 = dst_len / 4; 29528| 56| size_t src_len8 = src_len / 8; 29529| 56| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29529:16): [True: 2, False: 54] ------------------ 29530| 56| uint8_t* d = dst_ptr; 29531| 56| const uint8_t* s = src_ptr; 29532| | 29533| 56| size_t n = len; 29534| 367| while (n >= 1) { ------------------ | Branch (29534:10): [True: 311, False: 56] ------------------ 29535| 311| wuffs_base__poke_u32le__no_bounds_check( 29536| 311| d + (0 * 4), 29537| 311| wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr( 29538| 311| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul( 29539| 311| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 29540| | 29541| 311| s += 1 * 8; 29542| 311| d += 1 * 4; 29543| 311| n -= 1; 29544| 311| } 29545| 56| return len; 29546| 56|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over: 29555| 36| size_t src_len) { 29556| 36| size_t dst_len4 = dst_len / 4; 29557| 36| size_t src_len8 = src_len / 8; 29558| 36| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29558:16): [True: 2, False: 34] ------------------ 29559| 36| uint8_t* d = dst_ptr; 29560| 36| const uint8_t* s = src_ptr; 29561| 36| size_t n = len; 29562| | 29563| 298| while (n >= 1) { ------------------ | Branch (29563:10): [True: 262, False: 36] ------------------ 29564| 262| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 29565| 262| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 29566| 262| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 29567| 262| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 29568| 262| wuffs_base__poke_u32le__no_bounds_check( 29569| 262| d + (0 * 4), 29570| 262| wuffs_base__color_u64__as__color_u32( 29571| 262| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0))); 29572| | 29573| 262| s += 1 * 8; 29574| 262| d += 1 * 4; 29575| 262| n -= 1; 29576| 262| } 29577| | 29578| 36| return len; 29579| 36|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src: 28870| 19| size_t src_len) { 28871| 19| size_t dst_len4 = dst_len / 4; 28872| 19| size_t src_len8 = src_len / 8; 28873| 19| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28873:16): [True: 1, False: 18] ------------------ 28874| 19| uint8_t* d = dst_ptr; 28875| 19| const uint8_t* s = src_ptr; 28876| 19| size_t n = len; 28877| | 28878| | // TODO: unroll. 28879| | 28880| 207| while (n >= 1) { ------------------ | Branch (28880:10): [True: 188, False: 19] ------------------ 28881| 188| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28882| 188| wuffs_base__poke_u32le__no_bounds_check( 28883| 188| d + (0 * 4), wuffs_base__color_swap_u32_argb_abgr( 28884| 188| wuffs_base__color_u64__as__color_u32(s0))); 28885| | 28886| 188| s += 1 * 8; 28887| 188| d += 1 * 4; 28888| 188| n -= 1; 28889| 188| } 28890| | 28891| 19| return len; 28892| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src_over: 28901| 10| size_t src_len) { 28902| 10| size_t dst_len4 = dst_len / 4; 28903| 10| size_t src_len8 = src_len / 8; 28904| 10| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28904:16): [True: 2, False: 8] ------------------ 28905| 10| uint8_t* d = dst_ptr; 28906| 10| const uint8_t* s = src_ptr; 28907| 10| size_t n = len; 28908| | 28909| | // TODO: unroll. 28910| | 28911| 103| while (n >= 1) { ------------------ | Branch (28911:10): [True: 93, False: 10] ------------------ 28912| 93| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28913| 93| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28914| 93| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28915| 93| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28916| 93| wuffs_base__poke_u32le__no_bounds_check( 28917| 93| d + (0 * 4), 28918| 93| wuffs_base__color_u64__as__color_u32( 28919| 93| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0))); 28920| | 28921| 93| s += 1 * 8; 28922| 93| d += 1 * 4; 28923| 93| n -= 1; 28924| 93| } 28925| | 28926| 10| return len; 28927| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgrx: 32305| 133| wuffs_base__pixel_blend blend) { 32306| 133| switch (dst_pixfmt.repr) { ------------------ | Branch (32306:11): [True: 122, False: 11] ------------------ 32307| 22| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 22|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32307:5): [True: 22, False: 111] ------------------ 32308| 22| return wuffs_private_impl__swizzle_y__bgrx; 32309| | 32310| 15| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32310:5): [True: 15, False: 118] ------------------ 32311| 15| return wuffs_private_impl__swizzle_bgr_565__bgrx; 32312| | 32313| 9| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32313:5): [True: 9, False: 124] ------------------ 32314| 9| return wuffs_private_impl__swizzle_xxx__xxxx; 32315| | 32316| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32316:5): [True: 9, False: 124] ------------------ 32317| 22| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32317:5): [True: 13, False: 120] ------------------ 32318| 22| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32318:5): [True: 0, False: 133] ------------------ 32319| 22| return wuffs_private_impl__swizzle_bgrw__bgrx; 32320| | 32321| 14| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32321:5): [True: 14, False: 119] ------------------ 32322| 14| return wuffs_private_impl__swizzle_bgrw_4x16le__bgrx; 32323| | 32324| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32324:5): [True: 4, False: 129] ------------------ 32325| 4| return wuffs_private_impl__swizzle_copy_4_4; 32326| | 32327| 14| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 14|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32327:5): [True: 14, False: 119] ------------------ 32328| 14| return wuffs_private_impl__swizzle_bgr__rgbx; 32329| | 32330| 19| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 19|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32330:5): [True: 19, False: 114] ------------------ 32331| 22| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 22|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32331:5): [True: 3, False: 130] ------------------ 32332| 22| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 22|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (32332:5): [True: 0, False: 133] ------------------ 32333| 22| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 22|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (32333:5): [True: 0, False: 133] ------------------ 32334| 22| return wuffs_private_impl__swizzle_bgrw__rgbx; 32335| 133| } 32336| 11| return NULL; 32337| 133|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgrx: 30689| 22| size_t src_len) { 30690| 22| size_t src_len4 = src_len / 4; 30691| 22| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30691:16): [True: 2, False: 20] ------------------ 30692| 22| uint8_t* d = dst_ptr; 30693| 22| const uint8_t* s = src_ptr; 30694| 22| size_t n = len; 30695| | 30696| | // TODO: unroll. 30697| | 30698| 460| while (n >= 1) { ------------------ | Branch (30698:10): [True: 438, False: 22] ------------------ 30699| 438| uint32_t s0 = 30700| 438| 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 30701| 438| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30702| | 30703| 438| s += 1 * 4; 30704| 438| d += 1 * 1; 30705| 438| n -= 1; 30706| 438| } 30707| | 30708| 22| return len; 30709| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgrx: 26040| 15| size_t src_len) { 26041| 15| size_t dst_len2 = dst_len / 2; 26042| 15| size_t src_len4 = src_len / 4; 26043| 15| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26043:16): [True: 1, False: 14] ------------------ 26044| 15| uint8_t* d = dst_ptr; 26045| 15| const uint8_t* s = src_ptr; 26046| 15| size_t n = len; 26047| | 26048| | // TODO: unroll. 26049| | 26050| 368| while (n >= 1) { ------------------ | Branch (26050:10): [True: 353, False: 15] ------------------ 26051| 353| uint32_t b5 = (uint32_t)(s[0] >> 3); 26052| 353| uint32_t g6 = (uint32_t)(s[1] >> 2); 26053| 353| uint32_t r5 = (uint32_t)(s[2] >> 3); 26054| 353| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 26055| 353| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26056| | 26057| 353| s += 1 * 4; 26058| 353| d += 1 * 2; 26059| 353| n -= 1; 26060| 353| } 26061| | 26062| 15| return len; 26063| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__xxxx: 29779| 9| size_t src_len) { 29780| 9| size_t dst_len3 = dst_len / 3; 29781| 9| size_t src_len4 = src_len / 4; 29782| 9| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (29782:16): [True: 1, False: 8] ------------------ 29783| 9| uint8_t* d = dst_ptr; 29784| 9| const uint8_t* s = src_ptr; 29785| 9| size_t n = len; 29786| | 29787| | // TODO: unroll. 29788| | 29789| 149| while (n >= 1) { ------------------ | Branch (29789:10): [True: 140, False: 9] ------------------ 29790| 140| wuffs_base__poke_u24le__no_bounds_check( 29791| 140| d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 29792| | 29793| 140| s += 1 * 4; 29794| 140| d += 1 * 3; 29795| 140| n -= 1; 29796| 140| } 29797| | 29798| 9| return len; 29799| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgrx: 29089| 22| size_t src_len) { 29090| 22| size_t dst_len4 = dst_len / 4; 29091| 22| size_t src_len4 = src_len / 4; 29092| 22| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (29092:16): [True: 3, False: 19] ------------------ 29093| 22| uint8_t* d = dst_ptr; 29094| 22| const uint8_t* s = src_ptr; 29095| 22| size_t n = len; 29096| | 29097| | // TODO: unroll. 29098| | 29099| 349| while (n >= 1) { ------------------ | Branch (29099:10): [True: 327, False: 22] ------------------ 29100| 327| wuffs_base__poke_u32le__no_bounds_check( 29101| 327| d + (0 * 4), 29102| 327| 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 29103| | 29104| 327| s += 1 * 4; 29105| 327| d += 1 * 4; 29106| 327| n -= 1; 29107| 327| } 29108| | 29109| 22| return len; 29110| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgrx: 29358| 14| size_t src_len) { 29359| 14| size_t dst_len8 = dst_len / 8; 29360| 14| size_t src_len4 = src_len / 4; 29361| 14| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (29361:16): [True: 7, False: 7] ------------------ 29362| 14| uint8_t* d = dst_ptr; 29363| 14| const uint8_t* s = src_ptr; 29364| 14| size_t n = len; 29365| | 29366| 191| while (n >= 1) { ------------------ | Branch (29366:10): [True: 177, False: 14] ------------------ 29367| 177| uint8_t s0 = s[0]; 29368| 177| uint8_t s1 = s[1]; 29369| 177| uint8_t s2 = s[2]; 29370| 177| d[0] = s0; 29371| 177| d[1] = s0; 29372| 177| d[2] = s1; 29373| 177| d[3] = s1; 29374| 177| d[4] = s2; 29375| 177| d[5] = s2; 29376| 177| d[6] = 0xFF; 29377| 177| d[7] = 0xFF; 29378| | 29379| 177| s += 1 * 4; 29380| 177| d += 1 * 8; 29381| 177| n -= 1; 29382| 177| } 29383| | 29384| 14| return len; 29385| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgbx: 27579| 14| size_t src_len) { 27580| 14| size_t dst_len3 = dst_len / 3; 27581| 14| size_t src_len4 = src_len / 4; 27582| 14| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27582:16): [True: 2, False: 12] ------------------ 27583| 14| uint8_t* d = dst_ptr; 27584| 14| const uint8_t* s = src_ptr; 27585| 14| size_t n = len; 27586| | 27587| | // TODO: unroll. 27588| | 27589| 218| while (n >= 1) { ------------------ | Branch (27589:10): [True: 204, False: 14] ------------------ 27590| 204| uint8_t b0 = s[0]; 27591| 204| uint8_t b1 = s[1]; 27592| 204| uint8_t b2 = s[2]; 27593| 204| d[0] = b2; 27594| 204| d[1] = b1; 27595| 204| d[2] = b0; 27596| | 27597| 204| s += 1 * 4; 27598| 204| d += 1 * 3; 27599| 204| n -= 1; 27600| 204| } 27601| | 27602| 14| return len; 27603| 14|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgbx: 29259| 22| size_t src_len) { 29260| 22| size_t dst_len4 = dst_len / 4; 29261| 22| size_t src_len4 = src_len / 4; 29262| 22| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (29262:16): [True: 2, False: 20] ------------------ 29263| 22| uint8_t* d = dst_ptr; 29264| 22| const uint8_t* s = src_ptr; 29265| 22| size_t n = len; 29266| | 29267| | // TODO: unroll. 29268| | 29269| 480| while (n >= 1) { ------------------ | Branch (29269:10): [True: 458, False: 22] ------------------ 29270| 458| uint8_t b0 = s[0]; 29271| 458| uint8_t b1 = s[1]; 29272| 458| uint8_t b2 = s[2]; 29273| 458| d[0] = b2; 29274| 458| d[1] = b1; 29275| 458| d[2] = b0; 29276| 458| d[3] = 0xFF; 29277| | 29278| 458| s += 1 * 4; 29279| 458| d += 1 * 4; 29280| 458| n -= 1; 29281| 458| } 29282| | 29283| 22| return len; 29284| 22|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgb: 32345| 101| wuffs_base__pixel_blend blend) { 32346| 101| switch (dst_pixfmt.repr) { ------------------ | Branch (32346:11): [True: 88, False: 13] ------------------ 32347| 20| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32347:5): [True: 20, False: 81] ------------------ 32348| 20| return wuffs_private_impl__swizzle_y__rgb; 32349| | 32350| 13| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32350:5): [True: 13, False: 88] ------------------ 32351| 13| return wuffs_private_impl__swizzle_bgr_565__rgb; 32352| | 32353| 7| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32353:5): [True: 7, False: 94] ------------------ 32354| 7| return wuffs_private_impl__swizzle_swap_rgb_bgr; 32355| | 32356| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32356:5): [True: 9, False: 92] ------------------ 32357| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32357:5): [True: 4, False: 97] ------------------ 32358| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32358:5): [True: 0, False: 101] ------------------ 32359| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32359:5): [True: 2, False: 99] ------------------ 32360| 15|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32361| 15| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32361:11): [True: 15, False: 0] ------------------ 32362| 15| return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42; 32363| 15| } 32364| 0|#endif 32365| 0| return wuffs_private_impl__swizzle_bgrw__rgb; 32366| | 32367| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32367:5): [True: 15, False: 86] ------------------ 32368| 15| return wuffs_private_impl__swizzle_bgrw_4x16le__rgb; 32369| | 32370| 7| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 7|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32370:5): [True: 7, False: 94] ------------------ 32371| 7| return wuffs_private_impl__swizzle_copy_3_3; 32372| | 32373| 5| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 5|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32373:5): [True: 5, False: 96] ------------------ 32374| 11| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32374:5): [True: 6, False: 95] ------------------ 32375| 11| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (32375:5): [True: 0, False: 101] ------------------ 32376| 11| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (32376:5): [True: 0, False: 101] ------------------ 32377| 11|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32378| 11| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32378:11): [True: 11, False: 0] ------------------ 32379| 11| return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42; 32380| 11| } 32381| 0|#endif 32382| 0| return wuffs_private_impl__swizzle_bgrw__bgr; 32383| 101| } 32384| 13| return NULL; 32385| 101|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgb: 30717| 20| size_t src_len) { 30718| 20| size_t src_len3 = src_len / 3; 30719| 20| size_t len = (dst_len < src_len3) ? dst_len : src_len3; ------------------ | Branch (30719:16): [True: 2, False: 18] ------------------ 30720| 20| uint8_t* d = dst_ptr; 30721| 20| const uint8_t* s = src_ptr; 30722| 20| size_t n = len; 30723| | 30724| | // TODO: unroll. 30725| | 30726| 721| while (n >= 1) { ------------------ | Branch (30726:10): [True: 701, False: 20] ------------------ 30727| 701| uint32_t s0 = 30728| 701| 0xFF000000 | wuffs_base__peek_u24be__no_bounds_check(s + (0 * 3)); 30729| 701| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30730| | 30731| 701| s += 1 * 3; 30732| 701| d += 1 * 1; 30733| 701| n -= 1; 30734| 701| } 30735| | 30736| 20| return len; 30737| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgb: 26420| 13| size_t src_len) { 26421| 13| size_t dst_len2 = dst_len / 2; 26422| 13| size_t src_len3 = src_len / 3; 26423| 13| size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3; ------------------ | Branch (26423:16): [True: 1, False: 12] ------------------ 26424| 13| uint8_t* d = dst_ptr; 26425| 13| const uint8_t* s = src_ptr; 26426| 13| size_t n = len; 26427| | 26428| | // TODO: unroll. 26429| | 26430| 330| while (n >= 1) { ------------------ | Branch (26430:10): [True: 317, False: 13] ------------------ 26431| 317| uint32_t r5 = (uint32_t)(s[0] >> 3); 26432| 317| uint32_t g6 = (uint32_t)(s[1] >> 2); 26433| 317| uint32_t b5 = (uint32_t)(s[2] >> 3); 26434| 317| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 26435| 317| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26436| | 26437| 317| s += 1 * 3; 26438| 317| d += 1 * 2; 26439| 317| n -= 1; 26440| 317| } 26441| | 26442| 13| return len; 26443| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__rgb: 29393| 15| size_t src_len) { 29394| 15| size_t dst_len8 = dst_len / 8; 29395| 15| size_t src_len3 = src_len / 3; 29396| 15| size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3; ------------------ | Branch (29396:16): [True: 7, False: 8] ------------------ 29397| 15| uint8_t* d = dst_ptr; 29398| 15| const uint8_t* s = src_ptr; 29399| 15| size_t n = len; 29400| | 29401| 134| while (n >= 1) { ------------------ | Branch (29401:10): [True: 119, False: 15] ------------------ 29402| 119| uint8_t s0 = s[0]; 29403| 119| uint8_t s1 = s[1]; 29404| 119| uint8_t s2 = s[2]; 29405| 119| d[0] = s2; 29406| 119| d[1] = s2; 29407| 119| d[2] = s1; 29408| 119| d[3] = s1; 29409| 119| d[4] = s0; 29410| 119| d[5] = s0; 29411| 119| d[6] = 0xFF; 29412| 119| d[7] = 0xFF; 29413| | 29414| 119| s += 1 * 3; 29415| 119| d += 1 * 8; 29416| 119| n -= 1; 29417| 119| } 29418| | 29419| 15| return len; 29420| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgba_nonpremul: 32393| 217| wuffs_base__pixel_blend blend) { 32394| 217| switch (dst_pixfmt.repr) { ------------------ | Branch (32394:11): [True: 201, False: 16] ------------------ 32395| 20| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32395:5): [True: 20, False: 197] ------------------ 32396| 20| switch (blend) { ------------------ | Branch (32396:15): [True: 20, False: 0] ------------------ 32397| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32397:9): [True: 10, False: 10] ------------------ 32398| 10| return wuffs_private_impl__swizzle_y__rgba_nonpremul__src; 32399| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32399:9): [True: 10, False: 10] ------------------ 32400| 10| return wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over; 32401| 20| } 32402| 0| return NULL; 32403| | 32404| 26| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 26|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32404:5): [True: 26, False: 191] ------------------ 32405| 26| switch (blend) { ------------------ | Branch (32405:15): [True: 26, False: 0] ------------------ 32406| 15| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32406:9): [True: 15, False: 11] ------------------ 32407| 15| return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src; 32408| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32408:9): [True: 11, False: 15] ------------------ 32409| 11| return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over; 32410| 26| } 32411| 0| return NULL; 32412| | 32413| 9| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32413:5): [True: 9, False: 208] ------------------ 32414| 9| switch (blend) { ------------------ | Branch (32414:15): [True: 9, False: 0] ------------------ 32415| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32415:9): [True: 1, False: 8] ------------------ 32416| 1| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src; 32417| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32417:9): [True: 8, False: 1] ------------------ 32418| 8| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over; 32419| 9| } 32420| 0| return NULL; 32421| | 32422| 36| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 36|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32422:5): [True: 36, False: 181] ------------------ 32423| 36| switch (blend) { ------------------ | Branch (32423:15): [True: 36, False: 0] ------------------ 32424| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32424:9): [True: 9, False: 27] ------------------ 32425| 9|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32426| 9| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32426:15): [True: 9, False: 0] ------------------ 32427| 9| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 32428| 9| } 32429| 0|#endif 32430| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 32431| 27| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 27|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32431:9): [True: 27, False: 9] ------------------ 32432| 27| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over; 32433| 36| } 32434| 0| return NULL; 32435| | 32436| 38| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 38|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32436:5): [True: 38, False: 179] ------------------ 32437| 38| switch (blend) { ------------------ | Branch (32437:15): [True: 38, False: 0] ------------------ 32438| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32438:9): [True: 11, False: 27] ------------------ 32439| 11| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src; 32440| 27| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 27|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32440:9): [True: 27, False: 11] ------------------ 32441| 27| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over; 32442| 38| } 32443| 0| return NULL; 32444| | 32445| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32445:5): [True: 15, False: 202] ------------------ 32446| 15| switch (blend) { ------------------ | Branch (32446:15): [True: 15, False: 0] ------------------ 32447| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32447:9): [True: 8, False: 7] ------------------ 32448| 8| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src; 32449| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32449:9): [True: 7, False: 8] ------------------ 32450| 7| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over; 32451| 15| } 32452| 0| return NULL; 32453| | 32454| 0| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32454:5): [True: 0, False: 217] ------------------ 32455| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32455:5): [True: 4, False: 213] ------------------ 32456| | // TODO. 32457| 4| break; 32458| | 32459| 14| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 14|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32459:5): [True: 14, False: 203] ------------------ 32460| 14| switch (blend) { ------------------ | Branch (32460:15): [True: 14, False: 0] ------------------ 32461| 12| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32461:9): [True: 12, False: 2] ------------------ 32462| 12| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src; 32463| 2| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32463:9): [True: 2, False: 12] ------------------ 32464| 2| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over; 32465| 14| } 32466| 0| return NULL; 32467| | 32468| 10| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 10|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32468:5): [True: 10, False: 207] ------------------ 32469| 10| switch (blend) { ------------------ | Branch (32469:15): [True: 10, False: 0] ------------------ 32470| 0| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32470:9): [True: 0, False: 10] ------------------ 32471| 0| return wuffs_private_impl__swizzle_copy_4_4; 32472| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32472:9): [True: 10, False: 0] ------------------ 32473| 10| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over; 32474| 10| } 32475| 0| return NULL; 32476| | 32477| 29| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 29|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32477:5): [True: 29, False: 188] ------------------ 32478| 29| switch (blend) { ------------------ | Branch (32478:15): [True: 29, False: 0] ------------------ 32479| 12| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32479:9): [True: 12, False: 17] ------------------ 32480| 12| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src; 32481| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32481:9): [True: 17, False: 12] ------------------ 32482| 17| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over; 32483| 29| } 32484| 0| return NULL; 32485| | 32486| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (32486:5): [True: 0, False: 217] ------------------ 32487| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (32487:5): [True: 0, False: 217] ------------------ 32488| | // TODO. 32489| 0| break; 32490| 217| } 32491| 20| return NULL; 32492| 217|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src: 30745| 10| size_t src_len) { 30746| 10| size_t src_len4 = src_len / 4; 30747| 10| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30747:16): [True: 1, False: 9] ------------------ 30748| 10| uint8_t* d = dst_ptr; 30749| 10| const uint8_t* s = src_ptr; 30750| 10| size_t n = len; 30751| | 30752| | // TODO: unroll. 30753| | 30754| 164| while (n >= 1) { ------------------ | Branch (30754:10): [True: 154, False: 10] ------------------ 30755| 154| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30756| 154| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 30757| 154| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 30758| 154| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30759| | 30760| 154| s += 1 * 4; 30761| 154| d += 1 * 1; 30762| 154| n -= 1; 30763| 154| } 30764| | 30765| 10| return len; 30766| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over: 30775| 10| size_t src_len) { 30776| 10| size_t src_len4 = src_len / 4; 30777| 10| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30777:16): [True: 3, False: 7] ------------------ 30778| 10| uint8_t* d = dst_ptr; 30779| 10| const uint8_t* s = src_ptr; 30780| 10| size_t n = len; 30781| | 30782| | // TODO: unroll. 30783| | 30784| 170| while (n >= 1) { ------------------ | Branch (30784:10): [True: 160, False: 10] ------------------ 30785| 160| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30786| 160| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30787| 160| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30788| 160| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30789| 160| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 30790| | 30791| 160| s += 1 * 4; 30792| 160| d += 1 * 1; 30793| 160| n -= 1; 30794| 160| } 30795| | 30796| 10| return len; 30797| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src: 26452| 15| size_t src_len) { 26453| 15| size_t dst_len2 = dst_len / 2; 26454| 15| size_t src_len4 = src_len / 4; 26455| 15| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26455:16): [True: 3, False: 12] ------------------ 26456| 15| uint8_t* d = dst_ptr; 26457| 15| const uint8_t* s = src_ptr; 26458| 15| size_t n = len; 26459| | 26460| | // TODO: unroll. 26461| | 26462| 192| while (n >= 1) { ------------------ | Branch (26462:10): [True: 177, False: 15] ------------------ 26463| 177| wuffs_base__poke_u16le__no_bounds_check( 26464| 177| d + (0 * 2), 26465| 177| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26466| 177| wuffs_base__color_swap_u32_argb_abgr( 26467| 177| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26468| 177| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))))); 26469| | 26470| 177| s += 1 * 4; 26471| 177| d += 1 * 2; 26472| 177| n -= 1; 26473| 177| } 26474| | 26475| 15| return len; 26476| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over: 26485| 11| size_t src_len) { 26486| 11| size_t dst_len2 = dst_len / 2; 26487| 11| size_t src_len4 = src_len / 4; 26488| 11| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26488:16): [True: 2, False: 9] ------------------ 26489| 11| uint8_t* d = dst_ptr; 26490| 11| const uint8_t* s = src_ptr; 26491| 11| size_t n = len; 26492| | 26493| | // TODO: unroll. 26494| | 26495| 121| while (n >= 1) { ------------------ | Branch (26495:10): [True: 110, False: 11] ------------------ 26496| | // Extract 16-bit color components. 26497| 110| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26498| 110| uint32_t sb = 0x101 * ((uint32_t)s[2]); 26499| 110| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26500| 110| uint32_t sr = 0x101 * ((uint32_t)s[0]); 26501| | 26502| | // Convert from 565 color to 16-bit color. 26503| 110| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26504| 110| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26505| 110| uint32_t dr = (0x8421 * old_r5) >> 4; 26506| 110| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26507| 110| uint32_t dg = (0x1041 * old_g6) >> 2; 26508| 110| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26509| 110| uint32_t db = (0x8421 * old_b5) >> 4; 26510| | 26511| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26512| 110| uint32_t ia = 0xFFFF - sa; 26513| | 26514| | // Composite src (nonpremul) over dst (premul). 26515| 110| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26516| 110| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26517| 110| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26518| | 26519| | // Convert from 16-bit color to 565 color and combine the components. 26520| 110| uint32_t new_r5 = 0x1F & (dr >> 11); 26521| 110| uint32_t new_g6 = 0x3F & (dg >> 10); 26522| 110| uint32_t new_b5 = 0x1F & (db >> 11); 26523| 110| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26524| 110| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26525| | 26526| 110| s += 1 * 4; 26527| 110| d += 1 * 2; 26528| 110| n -= 1; 26529| 110| } 26530| | 26531| 11| return len; 26532| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src: 28260| 11| size_t src_len) { 28261| 11| size_t dst_len8 = dst_len / 8; 28262| 11| size_t src_len4 = src_len / 4; 28263| 11| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28263:16): [True: 5, False: 6] ------------------ 28264| 11| uint8_t* d = dst_ptr; 28265| 11| const uint8_t* s = src_ptr; 28266| | 28267| 11| size_t n = len; 28268| 78| while (n >= 1) { ------------------ | Branch (28268:10): [True: 67, False: 11] ------------------ 28269| 67| uint8_t s0 = s[0]; 28270| 67| uint8_t s1 = s[1]; 28271| 67| uint8_t s2 = s[2]; 28272| 67| uint8_t s3 = s[3]; 28273| 67| d[0] = s2; 28274| 67| d[1] = s2; 28275| 67| d[2] = s1; 28276| 67| d[3] = s1; 28277| 67| d[4] = s0; 28278| 67| d[5] = s0; 28279| 67| d[6] = s3; 28280| 67| d[7] = s3; 28281| | 28282| 67| s += 1 * 4; 28283| 67| d += 1 * 8; 28284| 67| n -= 1; 28285| 67| } 28286| 11| return len; 28287| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over: 28296| 27| size_t src_len) { 28297| 27| size_t dst_len8 = dst_len / 8; 28298| 27| size_t src_len4 = src_len / 4; 28299| 27| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28299:16): [True: 11, False: 16] ------------------ 28300| 27| uint8_t* d = dst_ptr; 28301| 27| const uint8_t* s = src_ptr; 28302| | 28303| 27| size_t n = len; 28304| 163| while (n >= 1) { ------------------ | Branch (28304:10): [True: 136, False: 27] ------------------ 28305| 136| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28306| 136| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28307| 136| wuffs_base__color_swap_u32_argb_abgr( 28308| 136| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 28309| 136| wuffs_base__poke_u64le__no_bounds_check( 28310| 136| d + (0 * 8), 28311| 136| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28312| | 28313| 136| s += 1 * 4; 28314| 136| d += 1 * 8; 28315| 136| n -= 1; 28316| 136| } 28317| 27| return len; 28318| 27|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgba_premul: 32500| 245| wuffs_base__pixel_blend blend) { 32501| 245| switch (dst_pixfmt.repr) { ------------------ | Branch (32501:11): [True: 215, False: 30] ------------------ 32502| 33| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 33|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32502:5): [True: 33, False: 212] ------------------ 32503| 33| switch (blend) { ------------------ | Branch (32503:15): [True: 33, False: 0] ------------------ 32504| 17| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32504:9): [True: 17, False: 16] ------------------ 32505| 17| return wuffs_private_impl__swizzle_y__rgba_premul__src; 32506| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32506:9): [True: 16, False: 17] ------------------ 32507| 16| return wuffs_private_impl__swizzle_y__rgba_premul__src_over; 32508| 33| } 32509| 0| return NULL; 32510| | 32511| 29| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 29|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32511:5): [True: 29, False: 216] ------------------ 32512| 29| switch (blend) { ------------------ | Branch (32512:15): [True: 29, False: 0] ------------------ 32513| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32513:9): [True: 16, False: 13] ------------------ 32514| 16| return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src; 32515| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32515:9): [True: 13, False: 16] ------------------ 32516| 13| return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over; 32517| 29| } 32518| 0| return NULL; 32519| | 32520| 12| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32520:5): [True: 12, False: 233] ------------------ 32521| 12| switch (blend) { ------------------ | Branch (32521:15): [True: 12, False: 0] ------------------ 32522| 6| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32522:9): [True: 6, False: 6] ------------------ 32523| 6| return wuffs_private_impl__swizzle_bgr__rgba_premul__src; 32524| 6| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32524:9): [True: 6, False: 6] ------------------ 32525| 6| return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; 32526| 12| } 32527| 0| return NULL; 32528| | 32529| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32529:5): [True: 17, False: 228] ------------------ 32530| 17| switch (blend) { ------------------ | Branch (32530:15): [True: 17, False: 0] ------------------ 32531| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32531:9): [True: 10, False: 7] ------------------ 32532| 10| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src; 32533| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32533:9): [True: 7, False: 10] ------------------ 32534| 7| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; 32535| 17| } 32536| 0| return NULL; 32537| | 32538| 47| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 47|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32538:5): [True: 47, False: 198] ------------------ 32539| 47| switch (blend) { ------------------ | Branch (32539:15): [True: 47, False: 0] ------------------ 32540| 24| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 24|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32540:9): [True: 24, False: 23] ------------------ 32541| 24| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src; 32542| 23| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 23|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32542:9): [True: 23, False: 24] ------------------ 32543| 23| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src_over; 32544| 47| } 32545| 0| return NULL; 32546| | 32547| 16| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32547:5): [True: 16, False: 229] ------------------ 32548| 16| switch (blend) { ------------------ | Branch (32548:15): [True: 16, False: 0] ------------------ 32549| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32549:9): [True: 5, False: 11] ------------------ 32550| 5|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32551| 5| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32551:15): [True: 5, False: 0] ------------------ 32552| 5| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 32553| 5| } 32554| 0|#endif 32555| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 32556| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32556:9): [True: 11, False: 5] ------------------ 32557| 11| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; 32558| 16| } 32559| 0| return NULL; 32560| | 32561| 14| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 14|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32561:5): [True: 14, False: 231] ------------------ 32562| 14| switch (blend) { ------------------ | Branch (32562:15): [True: 14, False: 0] ------------------ 32563| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32563:9): [True: 9, False: 5] ------------------ 32564| 9| return wuffs_private_impl__swizzle_bgr__bgra_premul__src; 32565| 5| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32565:9): [True: 5, False: 9] ------------------ 32566| 5| return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; 32567| 14| } 32568| 0| return NULL; 32569| | 32570| 35| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 35|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32570:5): [True: 35, False: 210] ------------------ 32571| 35| switch (blend) { ------------------ | Branch (32571:15): [True: 35, False: 0] ------------------ 32572| 15| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32572:9): [True: 15, False: 20] ------------------ 32573| 15| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src; 32574| 20| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32574:9): [True: 20, False: 15] ------------------ 32575| 20| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; 32576| 35| } 32577| 0| return NULL; 32578| | 32579| 12| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32579:5): [True: 12, False: 233] ------------------ 32580| 12| switch (blend) { ------------------ | Branch (32580:15): [True: 12, False: 0] ------------------ 32581| 0| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32581:9): [True: 0, False: 12] ------------------ 32582| 0| return wuffs_private_impl__swizzle_copy_4_4; 32583| 12| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32583:9): [True: 12, False: 0] ------------------ 32584| 12| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; 32585| 12| } 32586| 0| return NULL; 32587| 245| } 32588| 30| return NULL; 32589| 245|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src: 30805| 17| size_t src_len) { 30806| 17| size_t src_len4 = src_len / 4; 30807| 17| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30807:16): [True: 2, False: 15] ------------------ 30808| 17| uint8_t* d = dst_ptr; 30809| 17| const uint8_t* s = src_ptr; 30810| 17| size_t n = len; 30811| | 30812| | // TODO: unroll. 30813| | 30814| 287| while (n >= 1) { ------------------ | Branch (30814:10): [True: 270, False: 17] ------------------ 30815| 270| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30816| 270| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30817| 270| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30818| | 30819| 270| s += 1 * 4; 30820| 270| d += 1 * 1; 30821| 270| n -= 1; 30822| 270| } 30823| | 30824| 17| return len; 30825| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src_over: 30833| 16| size_t src_len) { 30834| 16| size_t src_len4 = src_len / 4; 30835| 16| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30835:16): [True: 3, False: 13] ------------------ 30836| 16| uint8_t* d = dst_ptr; 30837| 16| const uint8_t* s = src_ptr; 30838| 16| size_t n = len; 30839| | 30840| | // TODO: unroll. 30841| | 30842| 281| while (n >= 1) { ------------------ | Branch (30842:10): [True: 265, False: 16] ------------------ 30843| 265| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30844| 265| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30845| 265| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30846| 265| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30847| 265| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 30848| | 30849| 265| s += 1 * 4; 30850| 265| d += 1 * 1; 30851| 265| n -= 1; 30852| 265| } 30853| | 30854| 16| return len; 30855| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src: 26540| 16| size_t src_len) { 26541| 16| size_t dst_len2 = dst_len / 2; 26542| 16| size_t src_len4 = src_len / 4; 26543| 16| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26543:16): [True: 3, False: 13] ------------------ 26544| 16| uint8_t* d = dst_ptr; 26545| 16| const uint8_t* s = src_ptr; 26546| 16| size_t n = len; 26547| | 26548| | // TODO: unroll. 26549| | 26550| 397| while (n >= 1) { ------------------ | Branch (26550:10): [True: 381, False: 16] ------------------ 26551| 381| wuffs_base__poke_u16le__no_bounds_check( 26552| 381| d + (0 * 2), 26553| 381| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26554| 381| wuffs_base__color_swap_u32_argb_abgr( 26555| 381| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 26556| | 26557| 381| s += 1 * 4; 26558| 381| d += 1 * 2; 26559| 381| n -= 1; 26560| 381| } 26561| | 26562| 16| return len; 26563| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over: 26572| 13| size_t src_len) { 26573| 13| size_t dst_len2 = dst_len / 2; 26574| 13| size_t src_len4 = src_len / 4; 26575| 13| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26575:16): [True: 1, False: 12] ------------------ 26576| 13| uint8_t* d = dst_ptr; 26577| 13| const uint8_t* s = src_ptr; 26578| 13| size_t n = len; 26579| | 26580| | // TODO: unroll. 26581| | 26582| 304| while (n >= 1) { ------------------ | Branch (26582:10): [True: 291, False: 13] ------------------ 26583| | // Extract 16-bit color components. 26584| 291| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26585| 291| uint32_t sb = 0x101 * ((uint32_t)s[2]); 26586| 291| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26587| 291| uint32_t sr = 0x101 * ((uint32_t)s[0]); 26588| | 26589| | // Convert from 565 color to 16-bit color. 26590| 291| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26591| 291| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26592| 291| uint32_t dr = (0x8421 * old_r5) >> 4; 26593| 291| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26594| 291| uint32_t dg = (0x1041 * old_g6) >> 2; 26595| 291| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26596| 291| uint32_t db = (0x8421 * old_b5) >> 4; 26597| | 26598| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26599| 291| uint32_t ia = 0xFFFF - sa; 26600| | 26601| | // Composite src (premul) over dst (premul). 26602| 291| dr = sr + ((dr * ia) / 0xFFFF); 26603| 291| dg = sg + ((dg * ia) / 0xFFFF); 26604| 291| db = sb + ((db * ia) / 0xFFFF); 26605| | 26606| | // Convert from 16-bit color to 565 color and combine the components. 26607| 291| uint32_t new_r5 = 0x1F & (dr >> 11); 26608| 291| uint32_t new_g6 = 0x3F & (dg >> 10); 26609| 291| uint32_t new_b5 = 0x1F & (db >> 11); 26610| 291| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26611| 291| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26612| | 26613| 291| s += 1 * 4; 26614| 291| d += 1 * 2; 26615| 291| n -= 1; 26616| 291| } 26617| | 26618| 13| return len; 26619| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src: 28327| 24| size_t src_len) { 28328| 24| size_t dst_len8 = dst_len / 8; 28329| 24| size_t src_len4 = src_len / 4; 28330| 24| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28330:16): [True: 8, False: 16] ------------------ 28331| 24| uint8_t* d = dst_ptr; 28332| 24| const uint8_t* s = src_ptr; 28333| | 28334| 24| size_t n = len; 28335| 160| while (n >= 1) { ------------------ | Branch (28335:10): [True: 136, False: 24] ------------------ 28336| 136| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28337| 136| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 28338| 136| wuffs_base__color_swap_u32_argb_abgr( 28339| 136| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 28340| 136| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 28341| | 28342| 136| s += 1 * 4; 28343| 136| d += 1 * 8; 28344| 136| n -= 1; 28345| 136| } 28346| 24| return len; 28347| 24|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src_over: 28356| 23| size_t src_len) { 28357| 23| size_t dst_len8 = dst_len / 8; 28358| 23| size_t src_len4 = src_len / 4; 28359| 23| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28359:16): [True: 7, False: 16] ------------------ 28360| 23| uint8_t* d = dst_ptr; 28361| 23| const uint8_t* s = src_ptr; 28362| | 28363| 23| size_t n = len; 28364| 196| while (n >= 1) { ------------------ | Branch (28364:10): [True: 173, False: 23] ------------------ 28365| 173| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28366| 173| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28367| 173| wuffs_base__color_swap_u32_argb_abgr( 28368| 173| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 28369| 173| wuffs_base__poke_u64le__no_bounds_check( 28370| 173| d + (0 * 8), 28371| 173| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 28372| | 28373| 173| s += 1 * 4; 28374| 173| d += 1 * 8; 28375| 173| n -= 1; 28376| 173| } 28377| 23| return len; 28378| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__max_of_4: 32935| 6.77k| uint32_t d) { 32936| 6.77k| return wuffs_base__u32__max( // 32937| 6.77k| wuffs_base__u32__max(a, b), // 32938| 6.77k| wuffs_base__u32__max(c, d)); 32939| 6.77k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__width: 5379| 2.19k|wuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) { 5380| 2.19k| return c ? c->private_impl.width : 0; ------------------ | Branch (5380:10): [True: 2.19k, False: 0] ------------------ 5381| 2.19k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__min_of_5: 32946| 4.38k| uint32_t e) { 32947| 4.38k| return wuffs_base__u32__min( // 32948| 4.38k| wuffs_base__u32__min( // 32949| 4.38k| wuffs_base__u32__min(a, b), // 32950| 4.38k| wuffs_base__u32__min(c, d)), // 32951| 4.38k| e); 32952| 4.38k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__height: 5384| 2.19k|wuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) { 5385| 2.19k| return c ? c->private_impl.height : 0; ------------------ | Branch (5385:10): [True: 2.19k, False: 0] ------------------ 5386| 2.19k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_flattened_length: 34251| 7.01k| uint32_t inv_v) { 34252| 7.01k| uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1u)) / inv_h; 34253| 7.01k| uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1u)) / inv_v; 34254| 7.01k| if (scaled_height <= 0u) { ------------------ | Branch (34254:7): [True: 0, False: 7.01k] ------------------ 34255| 0| return 0u; 34256| 0| } 34257| 7.01k| return ((scaled_height - 1u) * stride) + scaled_width; 34258| 7.01k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgb__convert_3_general: 33134| 9.02k| const uint8_t* up2) { 33135| 273k| for (; x < x_end; x++) { ------------------ | Branch (33135:10): [True: 264k, False: 9.02k] ------------------ 33136| 264k| uint32_t color = 0xFF000000u | // 33137| 264k| (((uint32_t)(*up0++)) << 16u) | // 33138| 264k| (((uint32_t)(*up1++)) << 8u) | // 33139| 264k| (((uint32_t)(*up2++)) << 0u); 33140| 264k| wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color); 33141| 264k| } 33142| 9.02k|} pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_avx2: 289| 963|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| 963|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) 295| | // GCC defines these macros but MSVC does not. 296| | // - bit_AVX2 = (1 << 5) 297| 963| 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| 963| const unsigned int avx2_ecx1 = 0x00900002; 303| | 304| | // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). 305| 963|#if defined(__GNUC__) 306| 963| unsigned int eax7 = 0; 307| 963| unsigned int ebx7 = 0; 308| 963| unsigned int ecx7 = 0; 309| 963| unsigned int edx7 = 0; 310| 963| if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) && ------------------ | Branch (310:7): [True: 963, False: 0] ------------------ 311| 963| ((ebx7 & avx2_ebx7) == avx2_ebx7)) { ------------------ | Branch (311:7): [True: 963, False: 0] ------------------ 312| 963| unsigned int eax1 = 0; 313| 963| unsigned int ebx1 = 0; 314| 963| unsigned int ecx1 = 0; 315| 963| unsigned int edx1 = 0; 316| 963| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && ------------------ | Branch (316:9): [True: 963, False: 0] ------------------ 317| 963| ((ecx1 & avx2_ecx1) == avx2_ecx1)) { ------------------ | Branch (317:9): [True: 963, False: 0] ------------------ 318| 963| return true; 319| 963| } 320| 963| } 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| 963|#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) && 337| | // defined(__AVX2__) 338| 963|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx: 33169| 4.64k| const uint8_t* up2) { 33170| 4.64k| size_t dst_stride = dst->private_impl.planes[0].stride; 33171| 4.64k| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 33172| 4.64k| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 33173| | 33174| 66.8k| for (; x < x_end; x++) { ------------------ | Branch (33174:10): [True: 62.2k, False: 4.64k] ------------------ 33175| 62.2k| uint32_t color = // 33176| 62.2k| wuffs_base__color_ycc_bt601fr__as__color_u32( // 33177| 62.2k| *up0++, *up1++, *up2++); 33178| 62.2k| wuffs_base__poke_u32le__no_bounds_check(dst_iter, color); 33179| 62.2k| dst_iter += 4u; 33180| 62.2k| } 33181| 4.64k|} pixel_swizzler_fuzzer.c:wuffs_base__color_ycc_bt601fr__as__color_u32: 4691| 284k| uint8_t cr) { 4692| | // Work in 16.16 fixed point arithmetic (so that 'one half' is (1 << 15)) and 4693| | // bias the chroma values by 0x80. 4694| 284k| uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15); 4695| 284k| uint32_t cb32 = (((uint32_t)cb) - 0x80); 4696| 284k| uint32_t cr32 = (((uint32_t)cr) - 0x80); 4697| | 4698| | // The formulae: 4699| | // 4700| | // R = Y + 1.40200 * Cr 4701| | // G = Y - 0.34414 * Cb - 0.71414 * Cr 4702| | // B = Y + 1.77200 * Cb 4703| | // 4704| | // When scaled by 1<<16: 4705| | // 4706| | // 0.34414 becomes 0x0581A = 22554. 4707| | // 0.71414 becomes 0x0B6D2 = 46802. 4708| | // 1.40200 becomes 0x166E9 = 91881. 4709| | // 1.77200 becomes 0x1C5A2 = 116130. 4710| | // 4711| | // Since we're working in 16.16 fixed point arithmetic, masking by 0x00FF0000 4712| | // (possibly followed by a shift) gives the relevant 8 bits per channel. 4713| | // 4714| | // However, we need to saturate for overflow (above 0x00FFFFFF, but not so 4715| | // high that the MSB Most Significant Bit is set) or for underflow (below 4716| | // 0x00000000 as int32_t, which means that the MSB is set as uint32_t). In 4717| | // both cases, some of the high 8 bits (bits 24 ..= 31) will be set. 4718| | // 4719| | // "((uint32_t)(((int32_t)x) >> 31))" just replicates x's MSB across all 32 4720| | // bits. Prepending that with "~" inverts those bits. Thus, "~(etc)" is 4721| | // either 0xFFFFFFFF (for overflow) or 0x00000000 (for underflow). 4722| 284k| uint32_t rr32 = yy32 + (0x166E9 * cr32); 4723| 284k| uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32); 4724| 284k| uint32_t bb32 = yy32 + (0x1C5A2 * cb32); 4725| 284k| if (rr32 >> 24) { ------------------ | Branch (4725:7): [True: 94.3k, False: 190k] ------------------ 4726| 94.3k| rr32 = ~((uint32_t)(((int32_t)rr32) >> 31)); 4727| 94.3k| } 4728| 284k| if (gg32 >> 24) { ------------------ | Branch (4728:7): [True: 73.9k, False: 210k] ------------------ 4729| 73.9k| gg32 = ~((uint32_t)(((int32_t)gg32) >> 31)); 4730| 73.9k| } 4731| 284k| if (bb32 >> 24) { ------------------ | Branch (4731:7): [True: 119k, False: 165k] ------------------ 4732| 119k| bb32 = ~((uint32_t)(((int32_t)bb32) >> 31)); 4733| 119k| } 4734| 284k| return 0xFF000000 | // 4735| 284k| ((0x00FF0000 & rr32) >> 0) | // 4736| 284k| ((0x00FF0000 & gg32) >> 8) | // 4737| 284k| ((0x00FF0000 & bb32) >> 16); 4738| 284k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx: 33191| 4.22k| const uint8_t* up2) { 33192| 4.22k| size_t dst_stride = dst->private_impl.planes[0].stride; 33193| 4.22k| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 33194| 4.22k| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 33195| | 33196| 63.1k| for (; x < x_end; x++) { ------------------ | Branch (33196:10): [True: 58.8k, False: 4.22k] ------------------ 33197| 58.8k| uint32_t color = // 33198| 58.8k| wuffs_base__color_ycc_bt601fr__as__color_u32_abgr( // 33199| 58.8k| *up0++, *up1++, *up2++); 33200| 58.8k| wuffs_base__poke_u32le__no_bounds_check(dst_iter, color); 33201| 58.8k| dst_iter += 4u; 33202| 58.8k| } 33203| 4.22k|} pixel_swizzler_fuzzer.c:wuffs_base__color_ycc_bt601fr__as__color_u32_abgr: 4746| 58.8k| uint8_t cr) { 4747| 58.8k| uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15); 4748| 58.8k| uint32_t cb32 = (((uint32_t)cb) - 0x80); 4749| 58.8k| uint32_t cr32 = (((uint32_t)cr) - 0x80); 4750| 58.8k| uint32_t rr32 = yy32 + (0x166E9 * cr32); 4751| 58.8k| uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32); 4752| 58.8k| uint32_t bb32 = yy32 + (0x1C5A2 * cb32); 4753| 58.8k| if (rr32 >> 24) { ------------------ | Branch (4753:7): [True: 17.7k, False: 41.1k] ------------------ 4754| 17.7k| rr32 = ~((uint32_t)(((int32_t)rr32) >> 31)); 4755| 17.7k| } 4756| 58.8k| if (gg32 >> 24) { ------------------ | Branch (4756:7): [True: 15.5k, False: 43.2k] ------------------ 4757| 15.5k| gg32 = ~((uint32_t)(((int32_t)gg32) >> 31)); 4758| 15.5k| } 4759| 58.8k| if (bb32 >> 24) { ------------------ | Branch (4759:7): [True: 31.4k, False: 27.3k] ------------------ 4760| 31.4k| bb32 = ~((uint32_t)(((int32_t)bb32) >> 31)); 4761| 31.4k| } 4762| 58.8k| return 0xFF000000 | // 4763| 58.8k| ((0x00FF0000 & bb32) >> 0) | // 4764| 58.8k| ((0x00FF0000 & gg32) >> 8) | // 4765| 58.8k| ((0x00FF0000 & rr32) >> 16); 4766| 58.8k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general: 33152| 10.9k| const uint8_t* up2) { 33153| 233k| for (; x < x_end; x++) { ------------------ | Branch (33153:10): [True: 222k, False: 10.9k] ------------------ 33154| 222k| uint32_t color = // 33155| 222k| wuffs_base__color_ycc_bt601fr__as__color_u32( // 33156| 222k| *up0++, *up1++, *up2++); 33157| 222k| wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color); 33158| 222k| } 33159| 10.9k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__box_filter: 34092| 1.24k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 34093| 1.24k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = 34094| 1.24k| (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; 34095| 1.24k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = 34096| 1.24k| (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u]; 34097| 1.24k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 = 34098| 1.24k| (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; 34099| | 34100| 1.24k| uint32_t y; 34101| 22.8k| for (y = y_min_incl; y < y_max_excl; y++) { ------------------ | Branch (34101:24): [True: 21.6k, False: 1.24k] ------------------ 34102| 21.6k| const uint8_t* src0_major = 34103| 21.6k| src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0); 34104| 21.6k| const uint8_t* src1_major = 34105| 21.6k| src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1); 34106| 21.6k| const uint8_t* src2_major = 34107| 21.6k| src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2); 34108| | 34109| 21.6k| uint32_t x = x_min_incl; 34110| 43.2k| while (x < x_max_excl) { ------------------ | Branch (34110:12): [True: 21.6k, False: 21.6k] ------------------ 34111| 21.6k| uint32_t end = x + 672u; 34112| 21.6k| if (end > x_max_excl) { ------------------ | Branch (34112:11): [True: 21.6k, False: 0] ------------------ 34113| 21.6k| end = x_max_excl; 34114| 21.6k| } 34115| | 34116| 21.6k| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 34117| 21.6k| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 34118| 21.6k| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 34119| | 34120| 21.6k| const uint8_t* up0 = (*upfunc0)( // 34121| 21.6k| scratch_buffer_2k_ptr + (0u * 672u), // 34122| 21.6k| src0_major + ((x - x_min_incl) / inv_h0), // 34123| 21.6k| src0_major + ((x - x_min_incl) / inv_h0), // 34124| 21.6k| src_len0, // 34125| 21.6k| 0u, false, false); 34126| | 34127| 21.6k| const uint8_t* up1 = (*upfunc1)( // 34128| 21.6k| scratch_buffer_2k_ptr + (1u * 672u), // 34129| 21.6k| src1_major + ((x - x_min_incl) / inv_h1), // 34130| 21.6k| src1_major + ((x - x_min_incl) / inv_h1), // 34131| 21.6k| src_len1, // 34132| 21.6k| 0u, false, false); 34133| | 34134| 21.6k| const uint8_t* up2 = (*upfunc2)( // 34135| 21.6k| scratch_buffer_2k_ptr + (2u * 672u), // 34136| 21.6k| src2_major + ((x - x_min_incl) / inv_h2), // 34137| 21.6k| src2_major + ((x - x_min_incl) / inv_h2), // 34138| 21.6k| src_len2, // 34139| 21.6k| 0u, false, false); 34140| | 34141| 21.6k| (*conv3func)(dst, x, end, y, up0, up1, up2); 34142| 21.6k| x = end; 34143| 21.6k| } 34144| 21.6k| } 34145| 1.24k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box: 33309| 51.4k| bool last_column_ignored) { 33310| 51.4k| return src_ptr_major; 33311| 51.4k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box: 33321| 5.07k| bool last_column_ignored) { 33322| 5.07k| uint8_t* dp = dst_ptr; 33323| 5.07k| const uint8_t* sp = src_ptr_major; 33324| 56.3k| while (src_len--) { ------------------ | Branch (33324:10): [True: 51.2k, False: 5.07k] ------------------ 33325| 51.2k| uint8_t sv = *sp++; 33326| 51.2k| *dp++ = sv; 33327| 51.2k| *dp++ = sv; 33328| 51.2k| } 33329| 5.07k| return dst_ptr; 33330| 5.07k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box: 33340| 10.5k| bool last_column_ignored) { 33341| 10.5k| uint8_t* dp = dst_ptr; 33342| 10.5k| const uint8_t* sp = src_ptr_major; 33343| 100k| while (src_len--) { ------------------ | Branch (33343:10): [True: 89.4k, False: 10.5k] ------------------ 33344| 89.4k| uint8_t sv = *sp++; 33345| 89.4k| *dp++ = sv; 33346| 89.4k| *dp++ = sv; 33347| 89.4k| *dp++ = sv; 33348| 89.4k| } 33349| 10.5k| return dst_ptr; 33350| 10.5k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box: 33360| 9.26k| bool last_column_ignored) { 33361| 9.26k| uint8_t* dp = dst_ptr; 33362| 9.26k| const uint8_t* sp = src_ptr_major; 33363| 76.7k| while (src_len--) { ------------------ | Branch (33363:10): [True: 67.4k, False: 9.26k] ------------------ 33364| 67.4k| uint8_t sv = *sp++; 33365| 67.4k| *dp++ = sv; 33366| 67.4k| *dp++ = sv; 33367| 67.4k| *dp++ = sv; 33368| 67.4k| *dp++ = sv; 33369| 67.4k| } 33370| 9.26k| return dst_ptr; 33371| 9.26k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_has_triangle_upsampler: 33575| 2.34k| uint32_t inv_v) { 33576| 2.34k| if (inv_h == 1u) { ------------------ | Branch (33576:7): [True: 1.08k, False: 1.26k] ------------------ 33577| 1.08k| return inv_v == 2u; 33578| 1.26k| } else if (inv_h == 2u) { ------------------ | Branch (33578:14): [True: 266, False: 1.00k] ------------------ 33579| 266| return (inv_v == 1u) || (inv_v == 2u); ------------------ | Branch (33579:12): [True: 148, False: 118] | Branch (33579:29): [True: 70, False: 48] ------------------ 33580| 266| } 33581| 1.00k| return false; 33582| 2.34k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter: 33955| 373| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 33956| 373| if ((x_min_incl != 0) || (y_min_incl != 0)) { ------------------ | Branch (33956:7): [True: 0, False: 373] | Branch (33956:28): [True: 0, False: 373] ------------------ 33957| 0| return; 33958| 0| } 33959| | 33960| 373| wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = 33961| 373| (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; 33962| 373| wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = 33963| 373| (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u]; 33964| 373| wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 = 33965| 373| (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; 33966| | 33967| | // First row. 33968| 373| uint32_t h1v2_bias = 1u; 33969| 373| wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( 33970| 373| dst, x_max_excl, 0u, // 33971| 373| src_ptr0, src_ptr1, src_ptr2, // 33972| 373| stride0, stride1, stride2, // 33973| 373| inv_h0, inv_h1, inv_h2, // 33974| 373| inv_v0, inv_v1, inv_v2, // 33975| 373| half_width_for_2to1, // 33976| 373| h1v2_bias, // 33977| 373| scratch_buffer_2k_ptr, // 33978| 373| upfunc0, upfunc1, upfunc2, conv3func); 33979| 373| h1v2_bias = 2u; 33980| | 33981| | // Middle rows. 33982| 373| bool last_row = y_max_excl == 2u * half_height_for_2to1; 33983| 373| uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl; ------------------ | Branch (33983:32): [True: 240, False: 133] ------------------ 33984| 373| uint32_t y; 33985| 8.02k| for (y = 1u; y < middle_y_max_excl; y++) { ------------------ | Branch (33985:16): [True: 7.65k, False: 373] ------------------ 33986| 7.65k| const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); 33987| 7.65k| const uint8_t* src0_minor = 33988| 7.65k| (inv_v0 != 2u) ------------------ | Branch (33988:9): [True: 4.67k, False: 2.98k] ------------------ 33989| 7.65k| ? src0_major 33990| 7.65k| : ((y & 1u) ? (src0_major + stride0) : (src0_major - stride0)); ------------------ | Branch (33990:16): [True: 1.49k, False: 1.49k] ------------------ 33991| 7.65k| const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); 33992| 7.65k| const uint8_t* src1_minor = 33993| 7.65k| (inv_v1 != 2u) ------------------ | Branch (33993:9): [True: 3.36k, False: 4.29k] ------------------ 33994| 7.65k| ? src1_major 33995| 7.65k| : ((y & 1u) ? (src1_major + stride1) : (src1_major - stride1)); ------------------ | Branch (33995:16): [True: 2.14k, False: 2.14k] ------------------ 33996| 7.65k| const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); 33997| 7.65k| const uint8_t* src2_minor = 33998| 7.65k| (inv_v2 != 2u) ------------------ | Branch (33998:9): [True: 5.86k, False: 1.79k] ------------------ 33999| 7.65k| ? src2_major 34000| 7.65k| : ((y & 1u) ? (src2_major + stride2) : (src2_major - stride2)); ------------------ | Branch (34000:16): [True: 898, False: 898] ------------------ 34001| 7.65k| uint32_t total_src_len0 = 0u; 34002| 7.65k| uint32_t total_src_len1 = 0u; 34003| 7.65k| uint32_t total_src_len2 = 0u; 34004| | 34005| 7.65k| uint32_t x = 0u; 34006| 15.3k| while (x < x_max_excl) { ------------------ | Branch (34006:12): [True: 7.65k, False: 7.65k] ------------------ 34007| 7.65k| bool first_column = x == 0u; 34008| 7.65k| uint32_t end = x + 672u; 34009| 7.65k| if (end > x_max_excl) { ------------------ | Branch (34009:11): [True: 7.65k, False: 0] ------------------ 34010| 7.65k| end = x_max_excl; 34011| 7.65k| } 34012| | 34013| 7.65k| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 34014| 7.65k| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 34015| 7.65k| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 34016| 7.65k| total_src_len0 += src_len0; 34017| 7.65k| total_src_len1 += src_len1; 34018| 7.65k| total_src_len2 += src_len2; 34019| | 34020| 7.65k| const uint8_t* up0 = (*upfunc0)( // 34021| 7.65k| scratch_buffer_2k_ptr + (0u * 672u), // 34022| 7.65k| src0_major + (x / inv_h0), // 34023| 7.65k| src0_minor + (x / inv_h0), // 34024| 7.65k| src_len0, // 34025| 7.65k| h1v2_bias, // 34026| 7.65k| first_column, // 34027| 7.65k| (total_src_len0 >= half_width_for_2to1)); 34028| | 34029| 7.65k| const uint8_t* up1 = (*upfunc1)( // 34030| 7.65k| scratch_buffer_2k_ptr + (1u * 672u), // 34031| 7.65k| src1_major + (x / inv_h1), // 34032| 7.65k| src1_minor + (x / inv_h1), // 34033| 7.65k| src_len1, // 34034| 7.65k| h1v2_bias, // 34035| 7.65k| first_column, // 34036| 7.65k| (total_src_len1 >= half_width_for_2to1)); 34037| | 34038| 7.65k| const uint8_t* up2 = (*upfunc2)( // 34039| 7.65k| scratch_buffer_2k_ptr + (2u * 672u), // 34040| 7.65k| src2_major + (x / inv_h2), // 34041| 7.65k| src2_minor + (x / inv_h2), // 34042| 7.65k| src_len2, // 34043| 7.65k| h1v2_bias, // 34044| 7.65k| first_column, // 34045| 7.65k| (total_src_len2 >= half_width_for_2to1)); 34046| | 34047| 7.65k| (*conv3func)(dst, x, end, y, up0, up1, up2); 34048| 7.65k| x = end; 34049| 7.65k| } 34050| | 34051| 7.65k| h1v2_bias ^= 3u; 34052| 7.65k| } 34053| | 34054| | // Last row. 34055| 373| if (middle_y_max_excl != y_max_excl) { ------------------ | Branch (34055:7): [True: 240, False: 133] ------------------ 34056| 240| wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( 34057| 240| dst, x_max_excl, middle_y_max_excl, // 34058| 240| src_ptr0, src_ptr1, src_ptr2, // 34059| 240| stride0, stride1, stride2, // 34060| 240| inv_h0, inv_h1, inv_h2, // 34061| 240| inv_v0, inv_v1, inv_v2, // 34062| 240| half_width_for_2to1, // 34063| 240| h1v2_bias, // 34064| 240| scratch_buffer_2k_ptr, // 34065| 240| upfunc0, upfunc1, upfunc2, conv3func); 34066| 240| } 34067| 373|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row: 33874| 613| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 33875| 613| const uint8_t* src0 = src_ptr0 + ((y / inv_v0) * (size_t)stride0); 33876| 613| const uint8_t* src1 = src_ptr1 + ((y / inv_v1) * (size_t)stride1); 33877| 613| const uint8_t* src2 = src_ptr2 + ((y / inv_v2) * (size_t)stride2); 33878| 613| uint32_t total_src_len0 = 0u; 33879| 613| uint32_t total_src_len1 = 0u; 33880| 613| uint32_t total_src_len2 = 0u; 33881| | 33882| 613| uint32_t x = 0u; 33883| 1.22k| while (x < width) { ------------------ | Branch (33883:10): [True: 613, False: 613] ------------------ 33884| 613| bool first_column = x == 0u; 33885| 613| uint32_t end = x + 672u; 33886| 613| if (end > width) { ------------------ | Branch (33886:9): [True: 613, False: 0] ------------------ 33887| 613| end = width; 33888| 613| } 33889| | 33890| 613| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 33891| 613| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 33892| 613| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 33893| 613| total_src_len0 += src_len0; 33894| 613| total_src_len1 += src_len1; 33895| 613| total_src_len2 += src_len2; 33896| | 33897| 613| const uint8_t* src_ptr_x0 = src0 + (x / inv_h0); 33898| 613| const uint8_t* up0 = (*upfunc0)( // 33899| 613| scratch_buffer_2k_ptr + (0u * 672u), // 33900| 613| src_ptr_x0, // 33901| 613| src_ptr_x0, // 33902| 613| src_len0, // 33903| 613| h1v2_bias, // 33904| 613| first_column, // 33905| 613| (total_src_len0 >= half_width_for_2to1)); 33906| | 33907| 613| const uint8_t* src_ptr_x1 = src1 + (x / inv_h1); 33908| 613| const uint8_t* up1 = (*upfunc1)( // 33909| 613| scratch_buffer_2k_ptr + (1u * 672u), // 33910| 613| src_ptr_x1, // 33911| 613| src_ptr_x1, // 33912| 613| src_len1, // 33913| 613| h1v2_bias, // 33914| 613| first_column, // 33915| 613| (total_src_len1 >= half_width_for_2to1)); 33916| | 33917| 613| const uint8_t* src_ptr_x2 = src2 + (x / inv_h2); 33918| 613| const uint8_t* up2 = (*upfunc2)( // 33919| 613| scratch_buffer_2k_ptr + (2u * 672u), // 33920| 613| src_ptr_x2, // 33921| 613| src_ptr_x2, // 33922| 613| src_len2, // 33923| 613| h1v2_bias, // 33924| 613| first_column, // 33925| 613| (total_src_len2 >= half_width_for_2to1)); 33926| | 33927| 613| (*conv3func)(dst, x, end, y, up0, up1, up2); 33928| 613| x = end; 33929| 613| } 33930| 613|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle: 33381| 5.60k| bool last_column_ignored) { 33382| 5.60k| uint8_t* dp = dst_ptr; 33383| 5.60k| const uint8_t* sp_major = src_ptr_major; 33384| 5.60k| const uint8_t* sp_minor = src_ptr_minor; 33385| 167k| while (src_len--) { ------------------ | Branch (33385:10): [True: 162k, False: 5.60k] ------------------ 33386| 162k| *dp++ = (uint8_t)(((3u * ((uint32_t)(*sp_major++))) + // 33387| 162k| (1u * ((uint32_t)(*sp_minor++))) + // 33388| 162k| h1v2_bias) >> 33389| 162k| 2u); 33390| 162k| } 33391| 5.60k| return dst_ptr; 33392| 5.60k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle: 33402| 5.12k| bool last_column) { 33403| 5.12k| uint8_t* dp = dst_ptr; 33404| 5.12k| const uint8_t* sp = src_ptr_major; 33405| | 33406| 5.12k| if (first_column) { ------------------ | Branch (33406:7): [True: 5.12k, False: 0] ------------------ 33407| 5.12k| src_len--; 33408| 5.12k| if ((src_len <= 0u) && last_column) { ------------------ | Branch (33408:9): [True: 189, False: 4.94k] | Branch (33408:28): [True: 189, False: 0] ------------------ 33409| 189| uint8_t sv = *sp++; 33410| 189| *dp++ = sv; 33411| 189| *dp++ = sv; 33412| 189| return dst_ptr; 33413| 189| } 33414| 4.94k| uint32_t svp1 = sp[+1]; 33415| 4.94k| uint8_t sv = *sp++; 33416| 4.94k| *dp++ = sv; 33417| 4.94k| *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svp1 + 2u) >> 2u); 33418| 4.94k| if (src_len <= 0u) { ------------------ | Branch (33418:9): [True: 0, False: 4.94k] ------------------ 33419| 0| return dst_ptr; 33420| 0| } 33421| 4.94k| } 33422| | 33423| 4.94k| if (last_column) { ------------------ | Branch (33423:7): [True: 4.94k, False: 0] ------------------ 33424| 4.94k| src_len--; 33425| 4.94k| } 33426| | 33427| 50.1k| for (; src_len > 0u; src_len--) { ------------------ | Branch (33427:10): [True: 45.1k, False: 4.94k] ------------------ 33428| 45.1k| uint32_t svm1 = sp[-1]; 33429| 45.1k| uint32_t svp1 = sp[+1]; 33430| 45.1k| uint32_t sv3 = 3u * (uint32_t)(*sp++); 33431| 45.1k| *dp++ = (uint8_t)((sv3 + svm1 + 1u) >> 2u); 33432| 45.1k| *dp++ = (uint8_t)((sv3 + svp1 + 2u) >> 2u); 33433| 45.1k| } 33434| | 33435| 4.94k| if (last_column) { ------------------ | Branch (33435:7): [True: 4.94k, False: 0] ------------------ 33436| 4.94k| uint32_t svm1 = sp[-1]; 33437| 4.94k| uint8_t sv = *sp++; 33438| 4.94k| *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svm1 + 1u) >> 2u); 33439| 4.94k| *dp++ = sv; 33440| 4.94k| } 33441| | 33442| 4.94k| return dst_ptr; 33443| 5.12k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2: 32907| 2.64k| bool last_column) { 32908| 2.64k| return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2( 32909| 2.64k| dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored, 32910| 2.64k| first_column, last_column, 7); 32911| 2.64k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2: 35152| 2.64k| uint8_t odd_column_rounding) { 35153| 2.64k| uint8_t* dp = dst_ptr; 35154| 2.64k| const uint8_t* sp_major = src_ptr_major; 35155| 2.64k| const uint8_t* sp_minor = src_ptr_minor; 35156| 2.64k| const uint8_t oc = odd_column_rounding; 35157| | 35158| 2.64k| if (first_column) { ------------------ | Branch (35158:7): [True: 2.64k, False: 0] ------------------ 35159| 2.64k| src_len--; 35160| 2.64k| if ((src_len <= 0u) && last_column) { ------------------ | Branch (35160:9): [True: 196, False: 2.44k] | Branch (35160:28): [True: 196, False: 0] ------------------ 35161| 196| uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + // 35162| 196| (4u * ((uint32_t)(*sp_minor++))); 35163| 196| *dp++ = (uint8_t)((sv + 8u) >> 4u); 35164| 196| *dp++ = (uint8_t)((sv + oc) >> 4u); 35165| 196| return dst_ptr; 35166| 196| } 35167| | 35168| 2.44k| uint32_t sv_major_m1 = sp_major[-0]; // Clamp offset to zero. 35169| 2.44k| uint32_t sv_minor_m1 = sp_minor[-0]; // Clamp offset to zero. 35170| 2.44k| uint32_t sv_major_p1 = sp_major[+1]; 35171| 2.44k| uint32_t sv_minor_p1 = sp_minor[+1]; 35172| | 35173| 2.44k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 35174| 2.44k| (3u * ((uint32_t)(*sp_minor++))); 35175| 2.44k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 35176| 2.44k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u); 35177| 2.44k| if (src_len <= 0u) { ------------------ | Branch (35177:9): [True: 0, False: 2.44k] ------------------ 35178| 0| return dst_ptr; 35179| 0| } 35180| 2.44k| } 35181| | 35182| 2.44k| if (last_column) { ------------------ | Branch (35182:7): [True: 2.44k, False: 0] ------------------ 35183| 2.44k| src_len--; 35184| 2.44k| } 35185| | 35186| 2.44k| if (src_len < 32) { ------------------ | Branch (35186:7): [True: 2.44k, False: 0] ------------------ 35187| | // This fallback is the same as the non-SIMD-capable code path. 35188| 31.8k| for (; src_len > 0u; src_len--) { ------------------ | Branch (35188:12): [True: 29.4k, False: 2.44k] ------------------ 35189| 29.4k| uint32_t sv_major_m1 = sp_major[-1]; 35190| 29.4k| uint32_t sv_minor_m1 = sp_minor[-1]; 35191| 29.4k| uint32_t sv_major_p1 = sp_major[+1]; 35192| 29.4k| uint32_t sv_minor_p1 = sp_minor[+1]; 35193| | 35194| 29.4k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 35195| 29.4k| (3u * ((uint32_t)(*sp_minor++))); 35196| 29.4k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 35197| 29.4k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u); 35198| 29.4k| } 35199| | 35200| 2.44k| } else { 35201| 0| while (src_len > 0u) { ------------------ | Branch (35201:12): [True: 0, False: 0] ------------------ 35202| | // Load 1+32+1 samples (six u8x32 vectors) from the major (jxx) and minor 35203| | // (nxx) rows. 35204| | // 35205| | // major_p0 = [j00 j01 j02 j03 .. j28 j29 j30 j31] // p0 = "plus 0" 35206| | // minor_p0 = [n00 n01 n02 n03 .. n28 n29 n30 n31] // p0 = "plus 0" 35207| | // major_m1 = [jm1 j00 j01 j02 .. j27 j28 j29 j30] // m1 = "minus 1" 35208| | // minor_m1 = [nm1 n00 n01 n02 .. n27 n28 n29 n30] // m1 = "minus 1" 35209| | // major_p1 = [j01 j02 j03 j04 .. j29 j30 j31 j32] // p1 = "plus 1" 35210| | // minor_p1 = [n01 n02 n03 n04 .. n29 n30 n31 n32] // p1 = "plus 1" 35211| 0| __m256i major_p0 = 35212| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major + 0)); 35213| 0| __m256i minor_p0 = 35214| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor + 0)); 35215| 0| __m256i major_m1 = 35216| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major - 1)); 35217| 0| __m256i minor_m1 = 35218| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor - 1)); 35219| 0| __m256i major_p1 = 35220| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major + 1)); 35221| 0| __m256i minor_p1 = 35222| 0| _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor + 1)); 35223| | 35224| | // Unpack, staying with u8x32 vectors. 35225| | // 35226| | // step1_p0_lo = [j00 n00 j01 n01 .. j07 n07 j16 n16 j17 n17 .. j23 n23] 35227| | // step1_p0_hi = [j08 n08 j09 n09 .. j15 n15 j24 n24 j25 n25 .. j31 n31] 35228| | // step1_m1_lo = [jm1 nm1 j00 n00 .. j06 n06 j15 n15 j16 n16 .. j22 n22] 35229| | // step1_m1_hi = [j07 n07 j08 n08 .. j14 n14 j23 n23 j24 n24 .. j30 n30] 35230| | // step1_p1_lo = [j01 n01 j02 n02 .. j08 n08 j17 n17 j18 n18 .. j24 n24] 35231| | // step1_p1_hi = [j09 n09 j10 n10 .. j16 n16 j25 n25 j26 n26 .. j32 n32] 35232| 0| __m256i step1_p0_lo = _mm256_unpacklo_epi8(major_p0, minor_p0); 35233| 0| __m256i step1_p0_hi = _mm256_unpackhi_epi8(major_p0, minor_p0); 35234| 0| __m256i step1_m1_lo = _mm256_unpacklo_epi8(major_m1, minor_m1); 35235| 0| __m256i step1_m1_hi = _mm256_unpackhi_epi8(major_m1, minor_m1); 35236| 0| __m256i step1_p1_lo = _mm256_unpacklo_epi8(major_p1, minor_p1); 35237| 0| __m256i step1_p1_hi = _mm256_unpackhi_epi8(major_p1, minor_p1); 35238| | 35239| | // Multiply-add to get u16x16 vectors. 35240| | // 35241| | // step2_p0_lo = [9*j00+3*n00 9*j01+3*n01 .. 9*j23+3*n23] 35242| | // step2_p0_hi = [9*j08+3*n08 9*j09+3*n09 .. 9*j31+3*n31] 35243| | // step2_m1_lo = [3*jm1+1*nm1 3*j00+1*n00 .. 3*j22+1*n22] 35244| | // step2_m1_hi = [3*j07+1*n07 3*j08+1*n08 .. 3*j30+1*n30] 35245| | // step2_p1_lo = [3*j01+1*n01 3*j02+1*n02 .. 3*j24+1*n24] 35246| | // step2_p1_hi = [3*j09+1*n09 3*j10+1*n10 .. 3*j32+1*n32] 35247| 0| const __m256i k0309 = _mm256_set1_epi16(0x0309); 35248| 0| const __m256i k0103 = _mm256_set1_epi16(0x0103); 35249| 0| __m256i step2_p0_lo = _mm256_maddubs_epi16(step1_p0_lo, k0309); 35250| 0| __m256i step2_p0_hi = _mm256_maddubs_epi16(step1_p0_hi, k0309); 35251| 0| __m256i step2_m1_lo = _mm256_maddubs_epi16(step1_m1_lo, k0103); 35252| 0| __m256i step2_m1_hi = _mm256_maddubs_epi16(step1_m1_hi, k0103); 35253| 0| __m256i step2_p1_lo = _mm256_maddubs_epi16(step1_p1_lo, k0103); 35254| 0| __m256i step2_p1_hi = _mm256_maddubs_epi16(step1_p1_hi, k0103); 35255| | 35256| | // Compute the weighted sums of (p0, m1) and (p0, p1). For example: 35257| | // 35258| | // step3_m1_lo[00] = ((9*j00) + (3*n00) + (3*jm1) + (1*nm1)) as u16 35259| | // step3_p1_hi[15] = ((9*j31) + (3*n31) + (3*j32) + (1*n32)) as u16 35260| 0| __m256i step3_m1_lo = _mm256_add_epi16(step2_p0_lo, step2_m1_lo); 35261| 0| __m256i step3_m1_hi = _mm256_add_epi16(step2_p0_hi, step2_m1_hi); 35262| 0| __m256i step3_p1_lo = _mm256_add_epi16(step2_p0_lo, step2_p1_lo); 35263| 0| __m256i step3_p1_hi = _mm256_add_epi16(step2_p0_hi, step2_p1_hi); 35264| | 35265| | // Bias by 8 (on the left) or 7 (on the right) and then divide by 16 35266| | // (which is 9+3+3+1) to get a weighted average. On the left (m1), shift 35267| | // the u16 right value by 4. On the right (p1), shift right by 4 and then 35268| | // shift left by 8 so that, when still in the u16x16 little-endian 35269| | // interpretation, we have: 35270| | // - m1_element = (etcetera + 8) >> 4 35271| | // - p1_element = ((etcetera + oc) >> 4) << 8 35272| | // 35273| | // step4_m1_lo = [0x00?? 0x00?? ... 0x00?? 0x00??] 35274| | // step4_p1_lo = [0x??00 0x??00 ... 0x??00 0x??00] 35275| | // step4_m1_hi = [0x00?? 0x00?? ... 0x00?? 0x00??] 35276| | // step4_p1_hi = [0x??00 0x??00 ... 0x??00 0x??00] 35277| 0| __m256i step4_m1_lo = _mm256_srli_epi16( 35278| 0| _mm256_add_epi16(step3_m1_lo, _mm256_set1_epi16(8)), 4); 35279| 0| __m256i step4_p1_lo = _mm256_slli_epi16( 35280| 0| _mm256_srli_epi16( 35281| 0| _mm256_add_epi16(step3_p1_lo, _mm256_set1_epi16(oc)), 4), 35282| 0| 8); 35283| 0| __m256i step4_m1_hi = _mm256_srli_epi16( 35284| 0| _mm256_add_epi16(step3_m1_hi, _mm256_set1_epi16(8)), 4); 35285| 0| __m256i step4_p1_hi = _mm256_slli_epi16( 35286| 0| _mm256_srli_epi16( 35287| 0| _mm256_add_epi16(step3_p1_hi, _mm256_set1_epi16(oc)), 4), 35288| 0| 8); 35289| | 35290| | // Bitwise-or two "0x00"-rich u16x16 vectors to get a u8x32 vector. Do 35291| | // that twice. Once for the low columns and once for the high columns. 35292| | // 35293| | // In terms of jxx (major row) or nxx (minor row) source samples: 35294| | // - low columns means ( 0 .. 8; 16 .. 24). 35295| | // - high columns means ( 8 .. 16; 24 .. 32). 35296| | // 35297| | // In terms of dxx destination samples (there are twice as many): 35298| | // - low columns means ( 0 .. 16; 32 .. 48). 35299| | // - high columns means (16 .. 32; 48 .. 64). 35300| | // 35301| | // step5_lo = [d00 d01 .. d14 d15 d32 d33 .. d46 d47] 35302| | // step5_hi = [d16 d17 .. d30 d31 d48 d49 .. d62 d63] 35303| | // 35304| | // The d00, d02 ... d62 even elements come from (p0, m1) weighted sums. 35305| | // The d01, d03 ... d63 odd elements come from (p0, p1) weighted sums. 35306| 0| __m256i step5_lo = _mm256_or_si256(step4_m1_lo, step4_p1_lo); 35307| 0| __m256i step5_hi = _mm256_or_si256(step4_m1_hi, step4_p1_hi); 35308| | 35309| | // Permute and store. 35310| | // 35311| | // step6_00_31 = [d00 d01 .. d14 d15 d16 d17 .. d30 d31] 35312| | // step6_32_63 = [d32 d33 .. d46 d47 d48 d49 .. d62 d63] 35313| 0| __m256i step6_00_31 = _mm256_permute2x128_si256(step5_lo, step5_hi, 0x20); 35314| 0| __m256i step6_32_63 = _mm256_permute2x128_si256(step5_lo, step5_hi, 0x31); 35315| 0| _mm256_storeu_si256((__m256i*)(void*)(dp + 0x00), step6_00_31); 35316| 0| _mm256_storeu_si256((__m256i*)(void*)(dp + 0x20), step6_32_63); 35317| | 35318| | // Advance by up to 32 source samples (64 destination samples). The first 35319| | // iteration might be smaller than 32 so that all of the remaining steps 35320| | // are exactly 32. 35321| 0| size_t n = 32u - (31u & (0u - src_len)); 35322| 0| dp += 2u * n; 35323| 0| sp_major += n; 35324| 0| sp_minor += n; 35325| 0| src_len -= n; 35326| 0| } 35327| 0| } 35328| | 35329| 2.44k| if (last_column) { ------------------ | Branch (35329:7): [True: 2.44k, False: 0] ------------------ 35330| 2.44k| uint32_t sv_major_m1 = sp_major[-1]; 35331| 2.44k| uint32_t sv_minor_m1 = sp_minor[-1]; 35332| 2.44k| uint32_t sv_major_p1 = sp_major[+0]; // Clamp offset to zero. 35333| 2.44k| uint32_t sv_minor_p1 = sp_minor[+0]; // Clamp offset to zero. 35334| | 35335| 2.44k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 35336| 2.44k| (3u * ((uint32_t)(*sp_minor++))); 35337| 2.44k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 35338| 2.44k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u); 35339| 2.44k| } 35340| | 35341| 2.44k| return dst_ptr; 35342| 2.64k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx_x86_avx2: 34727| 5.11k| const uint8_t* up2) { 34728| 5.11k| if ((x + 32u) > x_end) { ------------------ | Branch (34728:7): [True: 4.64k, False: 468] ------------------ 34729| 4.64k| wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx( // 34730| 4.64k| dst, x, x_end, y, up0, up1, up2); 34731| 4.64k| return; 34732| 4.64k| } 34733| | 34734| 468| size_t dst_stride = dst->private_impl.planes[0].stride; 34735| 468| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 34736| 468| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 34737| | 34738| | // u0001 = u16x16 [0x0001 .. 0x0001] 34739| | // u00FF = u16x16 [0x00FF .. 0x00FF] 34740| | // uFF80 = u16x16 [0xFF80 .. 0xFF80] 34741| | // uFFFF = u16x16 [0xFFFF .. 0xFFFF] 34742| 468| const __m256i u0001 = _mm256_set1_epi16(+0x0001); 34743| 468| const __m256i u00FF = _mm256_set1_epi16(+0x00FF); 34744| 468| const __m256i uFF80 = _mm256_set1_epi16(-0x0080); 34745| 468| const __m256i uFFFF = _mm256_set1_epi16(-0x0001); 34746| | 34747| | // p8000_p0000 = u16x16 [0x8000 0x0000 .. 0x8000 0x0000] 34748| 468| const __m256i p8000_p0000 = _mm256_set_epi16( // 34749| 468| +0x0000, -0x8000, +0x0000, -0x8000, // 34750| 468| +0x0000, -0x8000, +0x0000, -0x8000, // 34751| 468| +0x0000, -0x8000, +0x0000, -0x8000, // 34752| 468| +0x0000, -0x8000, +0x0000, -0x8000); 34753| | 34754| | // Per wuffs_base__color_ycc_bt601fr__as__color_u32, the formulae: 34755| | // 34756| | // R = Y + 1.40200 * Cr 34757| | // G = Y - 0.34414 * Cb - 0.71414 * Cr 34758| | // B = Y + 1.77200 * Cb 34759| | // 34760| | // When scaled by 1<<16: 34761| | // 34762| | // 0.34414 becomes 0x0581A = 22554. 34763| | // 0.71414 becomes 0x0B6D2 = 46802. 34764| | // 1.40200 becomes 0x166E9 = 91881. 34765| | // 1.77200 becomes 0x1C5A2 = 116130. 34766| | // 34767| | // Separate the integer and fractional parts, since we work with signed 34768| | // 16-bit SIMD lanes. The fractional parts range from -0.5 .. +0.5 (as 34769| | // floating-point) which is from -0x8000 .. +0x8000 (as fixed-point). 34770| | // 34771| | // -0x3A5E = -0x20000 + 0x1C5A2 The B:Cb factor. 34772| | // +0x66E9 = -0x10000 + 0x166E9 The R:Cr factor. 34773| | // -0x581A = +0x00000 - 0x0581A The G:Cb factor. 34774| | // +0x492E = +0x10000 - 0x0B6D2 The G:Cr factor. 34775| 468| const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E); 34776| 468| const __m256i p66E9 = _mm256_set1_epi16(+0x66E9); 34777| 468| const __m256i m581A_p492E = _mm256_set_epi16( // 34778| 468| +0x492E, -0x581A, +0x492E, -0x581A, // 34779| 468| +0x492E, -0x581A, +0x492E, -0x581A, // 34780| 468| +0x492E, -0x581A, +0x492E, -0x581A, // 34781| 468| +0x492E, -0x581A, +0x492E, -0x581A); 34782| | 34783| 1.28k| while (x < x_end) { ------------------ | Branch (34783:10): [True: 815, False: 468] ------------------ 34784| | // Load chroma values in even and odd columns (the high 8 bits of each 34785| | // u16x16 element are zero) and then subtract 0x0080. 34786| | // 34787| | // cb_all = u8x32 [cb.00 cb.01 cb.02 cb.03 .. cb.1C cb.1D cb.1E cb.1F] 34788| | // cb_eve = i16x16 [cb.00-0x80 cb.02-0x80 .. cb.1C-0x80 cb.1E-0x80 ] 34789| | // cb_odd = i16x16 [cb.01-0x80 cb.03-0x80 .. cb.1D-0x80 cb.1F-0x80 ] 34790| | // 34791| | // Ditto for the cr_xxx Chroma-Red values. 34792| 815| __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1); 34793| 815| __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2); 34794| 815| __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF)); 34795| 815| __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF)); 34796| 815| __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8)); 34797| 815| __m256i cr_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cr_all, 8)); 34798| | 34799| | // ---- 34800| | 34801| | // Calculate: 34802| | // 34803| | // B-Y = (+1.77200 * Cb) as floating-point 34804| | // R-Y = (+1.40200 * Cr) as floating-point 34805| | // 34806| | // B-Y = ((0x2_0000 - 0x3A5E) * Cb) as fixed-point 34807| | // R-Y = ((0x1_0000 + 0x66E9) * Cr) as fixed-point 34808| | // 34809| | // B-Y = ((-0x3A5E * Cb) + ("2.0" * Cb)) 34810| | // R-Y = ((+0x66E9 * Cr) + ("1.0" * Cr)) 34811| | 34812| | // Multiply by m3A5E or p66E9, taking the high 16 bits. There's also a 34813| | // doubling (add x to itself), adding-of-1 and halving (shift right by 1). 34814| | // That makes multiply-and-take-high round to nearest (instead of down). 34815| 815| __m256i tmp_by_eve = _mm256_srai_epi16( 34816| 815| _mm256_add_epi16( 34817| 815| _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001), 34818| 815| 1); 34819| 815| __m256i tmp_by_odd = _mm256_srai_epi16( 34820| 815| _mm256_add_epi16( 34821| 815| _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001), 34822| 815| 1); 34823| 815| __m256i tmp_ry_eve = _mm256_srai_epi16( 34824| 815| _mm256_add_epi16( 34825| 815| _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001), 34826| 815| 1); 34827| 815| __m256i tmp_ry_odd = _mm256_srai_epi16( 34828| 815| _mm256_add_epi16( 34829| 815| _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001), 34830| 815| 1); 34831| | 34832| | // Add (2 * Cb) and (1 * Cr). 34833| 815| __m256i by_eve = 34834| 815| _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve)); 34835| 815| __m256i by_odd = 34836| 815| _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd)); 34837| 815| __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve); 34838| 815| __m256i ry_odd = _mm256_add_epi16(tmp_ry_odd, cr_odd); 34839| | 34840| | // ---- 34841| | 34842| | // Calculate: 34843| | // 34844| | // G-Y = (-0.34414 * Cb) + 34845| | // (-0.71414 * Cr) as floating-point 34846| | // 34847| | // G-Y = ((+0x0_0000 - 0x581A) * Cb) + 34848| | // ((-0x1_0000 + 0x492E) * Cr) as fixed-point 34849| | // 34850| | // G-Y = (-0x581A * Cb) + 34851| | // (+0x492E * Cr) - ("1.0" * Cr) 34852| | 34853| | // Multiply-add to get ((-0x581A * Cb) + (+0x492E * Cr)). 34854| 815| __m256i tmp0_gy_eve_lo = _mm256_madd_epi16( // 34855| 815| _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E); 34856| 815| __m256i tmp0_gy_eve_hi = _mm256_madd_epi16( // 34857| 815| _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E); 34858| 815| __m256i tmp0_gy_odd_lo = _mm256_madd_epi16( // 34859| 815| _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E); 34860| 815| __m256i tmp0_gy_odd_hi = _mm256_madd_epi16( // 34861| 815| _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E); 34862| | 34863| | // Divide the i32x8 vectors by (1 << 16), rounding to nearest. 34864| 815| __m256i tmp1_gy_eve_lo = 34865| 815| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16); 34866| 815| __m256i tmp1_gy_eve_hi = 34867| 815| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16); 34868| 815| __m256i tmp1_gy_odd_lo = 34869| 815| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16); 34870| 815| __m256i tmp1_gy_odd_hi = 34871| 815| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_hi, p8000_p0000), 16); 34872| | 34873| | // Pack the ((-0x581A * Cb) + (+0x492E * Cr)) as i16x16 and subtract Cr. 34874| 815| __m256i gy_eve = _mm256_sub_epi16( 34875| 815| _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve); 34876| 815| __m256i gy_odd = _mm256_sub_epi16( 34877| 815| _mm256_packs_epi32(tmp1_gy_odd_lo, tmp1_gy_odd_hi), cr_odd); 34878| | 34879| | // ---- 34880| | 34881| | // Add Y to (B-Y), (G-Y) and (R-Y) to produce B, G and R. 34882| | // 34883| | // For the resultant packed_x_xxx vectors, only elements 0 ..= 7 and 16 ..= 34884| | // 23 of the 32-element vectors matter (since we'll unpacklo but not 34885| | // unpackhi them). Let … denote 8 ignored consecutive u8 values and let % 34886| | // denote 0xFF. We'll end this section with: 34887| | // 34888| | // packed_b_eve = u8x32 [b00 b02 .. b0C b0E … b10 b12 .. b1C b1E …] 34889| | // packed_b_odd = u8x32 [b01 b03 .. b0D b0F … b11 b13 .. b1D b1F …] 34890| | // packed_g_eve = u8x32 [g00 g02 .. g0C g0E … g10 g12 .. g1C g1E …] 34891| | // packed_g_odd = u8x32 [g01 g03 .. g0D g0F … g11 g13 .. g1D g1F …] 34892| | // packed_r_eve = u8x32 [r00 r02 .. r0C r0E … r10 r12 .. r1C r1E …] 34893| | // packed_r_odd = u8x32 [r01 r03 .. r0D r0F … r11 r13 .. r1D r1F …] 34894| | // uFFFF = u8x32 [ % % .. % % … % % .. % % …] 34895| | 34896| 815| __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0); 34897| 815| __m256i yy_eve = _mm256_and_si256(yy_all, u00FF); 34898| 815| __m256i yy_odd = _mm256_srli_epi16(yy_all, 8); 34899| | 34900| 815| __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve); 34901| 815| __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd); 34902| 815| __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve); 34903| 815| __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd); 34904| | 34905| 815| __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve); 34906| 815| __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd); 34907| 815| __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve); 34908| 815| __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd); 34909| | 34910| 815| __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve); 34911| 815| __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd); 34912| 815| __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve); 34913| 815| __m256i packed_r_odd = _mm256_packus_epi16(loose_r_odd, loose_r_odd); 34914| | 34915| | // ---- 34916| | 34917| | // Mix those values (unpacking in 8, 16 and then 32 bit units) to get the 34918| | // desired BGRX/RGBX order. 34919| | // 34920| | // From here onwards, all of our __m256i registers are u8x32. 34921| | 34922| | // mix00 = [b00 g00 b02 g02 .. b0E g0E b10 g10 .. b1C g1C b1E g1E] 34923| | // mix01 = [b01 g01 b03 g03 .. b0F g0F b11 g11 .. b1D g1D b1F g1F] 34924| | // mix02 = [r00 % r02 % .. r0E % r10 % .. r1C % r1E %] 34925| | // mix03 = [r01 % r03 % .. r0F % r11 % .. r1D % r1F %] 34926| | // 34927| | // See also § below. 34928| 815| __m256i mix00 = _mm256_unpacklo_epi8(packed_b_eve, packed_g_eve); 34929| 815| __m256i mix01 = _mm256_unpacklo_epi8(packed_b_odd, packed_g_odd); 34930| 815| __m256i mix02 = _mm256_unpacklo_epi8(packed_r_eve, uFFFF); 34931| 815| __m256i mix03 = _mm256_unpacklo_epi8(packed_r_odd, uFFFF); 34932| | 34933| | // mix10 = [b00 g00 r00 % b02 g02 r02 % b04 g04 r04 % b06 g06 r06 % 34934| | // b10 g10 r10 % b12 g12 r12 % b14 g14 r14 % b16 g16 r16 %] 34935| | // mix11 = [b01 g01 r01 % b03 g03 r03 % b05 g05 r05 % b07 g07 r07 % 34936| | // b11 g11 r11 % b13 g13 r13 % b15 g15 r15 % b17 g17 r17 %] 34937| | // mix12 = [b08 g08 r08 % b0A g0A r0A % b0C g0C r0C % b0E g0E r0E % 34938| | // b18 g18 r18 % b1A g1A r1A % b1C g1C r1C % b1E g1E r1E %] 34939| | // mix13 = [b09 g09 r09 % b0B g0B r0B % b0D g0D r0D % b0F g0F r0F % 34940| | // b19 g19 r19 % b1B g1B r1B % b1D g1D r1D % b1F g1F r1F %] 34941| 815| __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02); 34942| 815| __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03); 34943| 815| __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02); 34944| 815| __m256i mix13 = _mm256_unpackhi_epi16(mix01, mix03); 34945| | 34946| | // mix20 = [b00 g00 r00 % b01 g01 r01 % b02 g02 r02 % b03 g03 r03 % 34947| | // b10 g10 r10 % b11 g11 r11 % b12 g12 r12 % b13 g13 r13 %] 34948| | // mix21 = [b04 g04 r04 % b05 g05 r05 % b06 g06 r06 % b07 g07 r07 % 34949| | // b14 g14 r14 % b15 g15 r15 % b16 g16 r16 % b17 g17 r17 %] 34950| | // mix22 = [b08 g08 r08 % b09 g09 r09 % b0A g0A r0A % b0B g0B r0B % 34951| | // b18 g18 r18 % b19 g19 r19 % b1A g1A r1A % b1B g1B r1B %] 34952| | // mix23 = [b0C g0C r0C % b0D g0D r0D % b0E g0E r0E % b0F g0F r0F % 34953| | // b1C g1C r1C % b1D g1D r1D % b1E g1E r1E % b1F g1F r1F %] 34954| 815| __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11); 34955| 815| __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11); 34956| 815| __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13); 34957| 815| __m256i mix23 = _mm256_unpackhi_epi32(mix12, mix13); 34958| | 34959| | // mix30 = [b00 g00 r00 % b01 g01 r01 % b02 g02 r02 % b03 g03 r03 % 34960| | // b04 g04 r04 % b05 g05 r05 % b06 g06 r06 % b07 g07 r07 %] 34961| | // mix31 = [b08 g08 r08 % b09 g09 r09 % b0A g0A r0A % b0B g0B r0B % 34962| | // b0C g0C r0C % b0D g0D r0D % b0E g0E r0E % b0F g0F r0F %] 34963| | // mix32 = [b10 g10 r10 % b11 g11 r11 % b12 g12 r12 % b13 g13 r13 % 34964| | // b14 g14 r14 % b15 g15 r15 % b16 g16 r16 % b17 g17 r17 %] 34965| | // mix33 = [b18 g18 r18 % b19 g19 r19 % b1A g1A r1A % b1B g1B r1B % 34966| | // b1C g1C r1C % b1D g1D r1D % b1E g1E r1E % b1F g1F r1F %] 34967| 815| __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20); 34968| 815| __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20); 34969| 815| __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31); 34970| 815| __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31); 34971| | 34972| | // Write out four u8x32 SIMD registers (128 bytes, 32 BGRX/RGBX pixels). 34973| 815| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30); 34974| 815| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31); 34975| 815| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32); 34976| 815| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x60), mix33); 34977| | 34978| | // Advance by up to 32 pixels. The first iteration might be smaller than 32 34979| | // so that all of the remaining steps are exactly 32. 34980| 815| uint32_t n = 32u - (31u & (x - x_end)); 34981| 815| dst_iter += 4u * n; 34982| 815| up0 += n; 34983| 815| up1 += n; 34984| 815| up2 += n; 34985| 815| x += n; 34986| 815| } 34987| 468|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx_x86_avx2: 35000| 4.78k| const uint8_t* up2) { 35001| 4.78k| if ((x + 32u) > x_end) { ------------------ | Branch (35001:7): [True: 4.22k, False: 563] ------------------ 35002| 4.22k| wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx( // 35003| 4.22k| dst, x, x_end, y, up0, up1, up2); 35004| 4.22k| return; 35005| 4.22k| } 35006| | 35007| 563| size_t dst_stride = dst->private_impl.planes[0].stride; 35008| 563| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 35009| 563| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 35010| | 35011| 563| const __m256i u0001 = _mm256_set1_epi16(+0x0001); 35012| 563| const __m256i u00FF = _mm256_set1_epi16(+0x00FF); 35013| 563| const __m256i uFF80 = _mm256_set1_epi16(-0x0080); 35014| 563| const __m256i uFFFF = _mm256_set1_epi16(-0x0001); 35015| | 35016| 563| const __m256i p8000_p0000 = _mm256_set_epi16( // 35017| 563| +0x0000, -0x8000, +0x0000, -0x8000, // 35018| 563| +0x0000, -0x8000, +0x0000, -0x8000, // 35019| 563| +0x0000, -0x8000, +0x0000, -0x8000, // 35020| 563| +0x0000, -0x8000, +0x0000, -0x8000); 35021| | 35022| 563| const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E); 35023| 563| const __m256i p66E9 = _mm256_set1_epi16(+0x66E9); 35024| 563| const __m256i m581A_p492E = _mm256_set_epi16( // 35025| 563| +0x492E, -0x581A, +0x492E, -0x581A, // 35026| 563| +0x492E, -0x581A, +0x492E, -0x581A, // 35027| 563| +0x492E, -0x581A, +0x492E, -0x581A, // 35028| 563| +0x492E, -0x581A, +0x492E, -0x581A); 35029| | 35030| 1.57k| while (x < x_end) { ------------------ | Branch (35030:10): [True: 1.01k, False: 563] ------------------ 35031| 1.01k| __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1); 35032| 1.01k| __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2); 35033| 1.01k| __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF)); 35034| 1.01k| __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF)); 35035| 1.01k| __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8)); 35036| 1.01k| __m256i cr_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cr_all, 8)); 35037| | 35038| 1.01k| __m256i tmp_by_eve = _mm256_srai_epi16( 35039| 1.01k| _mm256_add_epi16( 35040| 1.01k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001), 35041| 1.01k| 1); 35042| 1.01k| __m256i tmp_by_odd = _mm256_srai_epi16( 35043| 1.01k| _mm256_add_epi16( 35044| 1.01k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001), 35045| 1.01k| 1); 35046| 1.01k| __m256i tmp_ry_eve = _mm256_srai_epi16( 35047| 1.01k| _mm256_add_epi16( 35048| 1.01k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001), 35049| 1.01k| 1); 35050| 1.01k| __m256i tmp_ry_odd = _mm256_srai_epi16( 35051| 1.01k| _mm256_add_epi16( 35052| 1.01k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001), 35053| 1.01k| 1); 35054| | 35055| 1.01k| __m256i by_eve = 35056| 1.01k| _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve)); 35057| 1.01k| __m256i by_odd = 35058| 1.01k| _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd)); 35059| 1.01k| __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve); 35060| 1.01k| __m256i ry_odd = _mm256_add_epi16(tmp_ry_odd, cr_odd); 35061| | 35062| 1.01k| __m256i tmp0_gy_eve_lo = _mm256_madd_epi16( // 35063| 1.01k| _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E); 35064| 1.01k| __m256i tmp0_gy_eve_hi = _mm256_madd_epi16( // 35065| 1.01k| _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E); 35066| 1.01k| __m256i tmp0_gy_odd_lo = _mm256_madd_epi16( // 35067| 1.01k| _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E); 35068| 1.01k| __m256i tmp0_gy_odd_hi = _mm256_madd_epi16( // 35069| 1.01k| _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E); 35070| | 35071| 1.01k| __m256i tmp1_gy_eve_lo = 35072| 1.01k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16); 35073| 1.01k| __m256i tmp1_gy_eve_hi = 35074| 1.01k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16); 35075| 1.01k| __m256i tmp1_gy_odd_lo = 35076| 1.01k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16); 35077| 1.01k| __m256i tmp1_gy_odd_hi = 35078| 1.01k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_hi, p8000_p0000), 16); 35079| | 35080| 1.01k| __m256i gy_eve = _mm256_sub_epi16( 35081| 1.01k| _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve); 35082| 1.01k| __m256i gy_odd = _mm256_sub_epi16( 35083| 1.01k| _mm256_packs_epi32(tmp1_gy_odd_lo, tmp1_gy_odd_hi), cr_odd); 35084| | 35085| 1.01k| __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0); 35086| 1.01k| __m256i yy_eve = _mm256_and_si256(yy_all, u00FF); 35087| 1.01k| __m256i yy_odd = _mm256_srli_epi16(yy_all, 8); 35088| | 35089| 1.01k| __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve); 35090| 1.01k| __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd); 35091| 1.01k| __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve); 35092| 1.01k| __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd); 35093| | 35094| 1.01k| __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve); 35095| 1.01k| __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd); 35096| 1.01k| __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve); 35097| 1.01k| __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd); 35098| | 35099| 1.01k| __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve); 35100| 1.01k| __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd); 35101| 1.01k| __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve); 35102| 1.01k| __m256i packed_r_odd = _mm256_packus_epi16(loose_r_odd, loose_r_odd); 35103| | 35104| | // § Note the swapped B and R channels. 35105| 1.01k| __m256i mix00 = _mm256_unpacklo_epi8(packed_r_eve, packed_g_eve); 35106| 1.01k| __m256i mix01 = _mm256_unpacklo_epi8(packed_r_odd, packed_g_odd); 35107| 1.01k| __m256i mix02 = _mm256_unpacklo_epi8(packed_b_eve, uFFFF); 35108| 1.01k| __m256i mix03 = _mm256_unpacklo_epi8(packed_b_odd, uFFFF); 35109| | 35110| 1.01k| __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02); 35111| 1.01k| __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03); 35112| 1.01k| __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02); 35113| 1.01k| __m256i mix13 = _mm256_unpackhi_epi16(mix01, mix03); 35114| | 35115| 1.01k| __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11); 35116| 1.01k| __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11); 35117| 1.01k| __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13); 35118| 1.01k| __m256i mix23 = _mm256_unpackhi_epi32(mix12, mix13); 35119| | 35120| 1.01k| __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20); 35121| 1.01k| __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20); 35122| 1.01k| __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31); 35123| 1.01k| __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31); 35124| | 35125| 1.01k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30); 35126| 1.01k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31); 35127| 1.01k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32); 35128| 1.01k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x60), mix33); 35129| | 35130| 1.01k| uint32_t n = 32u - (31u & (x - x_end)); 35131| 1.01k| dst_iter += 4u * n; 35132| 1.01k| up0 += n; 35133| 1.01k| up1 += n; 35134| 1.01k| up2 += n; 35135| 1.01k| x += n; 35136| 1.01k| } 35137| 563|} pixel_swizzler_fuzzer.c:wuffs_base__ptr_u8__reader: 3456| 3.38k|wuffs_base__ptr_u8__reader(uint8_t* ptr, size_t len, bool closed) { 3457| 3.38k| wuffs_base__io_buffer ret; 3458| 3.38k| ret.data.ptr = ptr; 3459| 3.38k| ret.data.len = len; 3460| 3.38k| ret.meta.wi = len; 3461| 3.38k| ret.meta.ri = 0; 3462| 3.38k| ret.meta.pos = 0; 3463| 3.38k| ret.meta.closed = closed; 3464| 3.38k| return ret; 3465| 3.38k|} pixel_swizzler_fuzzer.c:wuffs_base__make_pixel_format: 4928| 10.1k|wuffs_base__make_pixel_format(uint32_t repr) { 4929| 10.1k| wuffs_base__pixel_format f; 4930| 10.1k| f.repr = repr; 4931| 10.1k| return f; 4932| 10.1k|} pixel_swizzler_fuzzer.c:wuffs_base__status__message: 674| 2.03k|wuffs_base__status__message(const wuffs_base__status* z) { 675| 2.03k| if (z->repr) { ------------------ | Branch (675:7): [True: 2.03k, False: 0] ------------------ 676| 2.03k| if ((*z->repr == '$') || (*z->repr == '#') || (*z->repr == '@')) { ------------------ | Branch (676:9): [True: 0, False: 2.03k] | Branch (676:30): [True: 2.03k, False: 0] | Branch (676:51): [True: 0, False: 0] ------------------ 677| 2.03k| return z->repr + 1; 678| 2.03k| } 679| 2.03k| } 680| 0| return z->repr; 681| 2.03k|} pixel_swizzler_fuzzer.c:wuffs_base__u32__max: 1062| 40.6k|wuffs_base__u32__max(uint32_t x, uint32_t y) { 1063| 40.6k| return x > y ? x : y; ------------------ | Branch (1063:10): [True: 16.1k, False: 24.4k] ------------------ 1064| 40.6k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__set: 5307| 3.38k| uint32_t height) { 5308| 3.38k| if (!c) { ------------------ | Branch (5308:7): [True: 0, False: 3.38k] ------------------ 5309| 0| return; 5310| 0| } 5311| 3.38k| if (pixfmt_repr) { ------------------ | Branch (5311:7): [True: 3.38k, False: 0] ------------------ 5312| 3.38k| do { 5313| |#if SIZE_MAX < 0xFFFFFFFFFFFFFFFFull 5314| | uint64_t wh = ((uint64_t)width) * ((uint64_t)height); 5315| | // TODO: handle things other than 1 byte per pixel. 5316| | if (wh > ((uint64_t)SIZE_MAX)) { 5317| | break; 5318| | } 5319| |#endif 5320| 3.38k| c->private_impl.pixfmt.repr = pixfmt_repr; 5321| 3.38k| c->private_impl.pixsub.repr = pixsub_repr; 5322| 3.38k| c->private_impl.width = width; 5323| 3.38k| c->private_impl.height = height; 5324| 3.38k| return; 5325| 3.38k| } while (0); ------------------ | Branch (5325:14): [Folded, False: 0] ------------------ 5326| 3.38k| } 5327| | 5328| 0| c->private_impl.pixfmt.repr = 0; 5329| 0| c->private_impl.pixsub.repr = 0; 5330| 0| c->private_impl.width = 0; 5331| 0| c->private_impl.height = 0; 5332| 0|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__pixbuf_len: 5392| 3.38k|wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { 5393| 3.38k| if (!c) { ------------------ | Branch (5393:7): [True: 0, False: 3.38k] ------------------ 5394| 0| return 0; 5395| 0| } 5396| 3.38k| if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) { ------------------ | Branch (5396:7): [True: 0, False: 3.38k] ------------------ 5397| | // TODO: support planar pixel formats, concious of pixel subsampling. 5398| 0| return 0; 5399| 0| } 5400| 3.38k| uint32_t bits_per_pixel = 5401| 3.38k| wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt); 5402| 3.38k| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { ------------------ | Branch (5402:7): [True: 0, False: 3.38k] | Branch (5402:32): [True: 0, False: 3.38k] ------------------ 5403| | // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? 5404| 0| return 0; 5405| 0| } 5406| 3.38k| uint64_t bytes_per_pixel = bits_per_pixel / 8; 5407| | 5408| 3.38k| uint64_t n = 5409| 3.38k| ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); 5410| 3.38k| if (n > (UINT64_MAX / bytes_per_pixel)) { ------------------ | Branch (5410:7): [True: 0, False: 3.38k] ------------------ 5411| 0| return 0; 5412| 0| } 5413| 3.38k| n *= bytes_per_pixel; 5414| | 5415| 3.38k| if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) { ------------------ | Branch (5415:7): [True: 118, False: 3.26k] ------------------ 5416| 118| if (n > ------------------ | Branch (5416:9): [True: 0, False: 118] ------------------ 5417| 118| (UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) { ------------------ | | 4900| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5418| 0| return 0; 5419| 0| } 5420| 118| n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5421| 118| } 5422| | 5423| 3.38k| return n; 5424| 3.38k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__set_from_slice: 5978| 3.38k| wuffs_base__slice_u8 pixbuf_memory) { 5979| 3.38k| if (!pb) { ------------------ | Branch (5979:7): [True: 0, False: 3.38k] ------------------ 5980| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 5981| 0| } 5982| 3.38k| memset(pb, 0, sizeof(*pb)); 5983| 3.38k| if (!pixcfg) { ------------------ | Branch (5983:7): [True: 0, False: 3.38k] ------------------ 5984| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 5985| 0| } 5986| 3.38k| if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { ------------------ | Branch (5986:7): [True: 0, False: 3.38k] ------------------ 5987| | // TODO: support planar pixel formats, concious of pixel subsampling. 5988| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 5989| 0| } 5990| 3.38k| uint32_t bits_per_pixel = 5991| 3.38k| wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); 5992| 3.38k| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { ------------------ | Branch (5992:7): [True: 0, False: 3.38k] | Branch (5992:32): [True: 0, False: 3.38k] ------------------ 5993| | // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? 5994| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 5995| 0| } 5996| 3.38k| uint64_t bytes_per_pixel = bits_per_pixel / 8; 5997| | 5998| 3.38k| uint8_t* ptr = pixbuf_memory.ptr; 5999| 3.38k| uint64_t len = pixbuf_memory.len; 6000| 3.38k| if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) { ------------------ | Branch (6000:7): [True: 118, False: 3.26k] ------------------ 6001| | // Split a WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH byte 6002| | // chunk (1024 bytes = 256 palette entries × 4 bytes per entry) from the 6003| | // start of pixbuf_memory. We split from the start, not the end, so that 6004| | // the both chunks' pointers have the same alignment as the original 6005| | // pointer, up to an alignment of 1024. 6006| 118| if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ | Branch (6006:9): [True: 0, False: 118] ------------------ 6007| 0| return wuffs_base__make_status( 6008| 0| wuffs_base__error__bad_argument_length_too_short); 6009| 0| } 6010| 118| wuffs_base__table_u8* tab = 6011| 118| &pb->private_impl 6012| 118| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; ------------------ | | 4897| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3 ------------------ 6013| 118| tab->ptr = ptr; 6014| 118| tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6015| 118| tab->height = 1; 6016| 118| tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6017| 118| ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6018| 118| len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 118|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6019| 118| } 6020| | 6021| 3.38k| uint64_t wh = ((uint64_t)pixcfg->private_impl.width) * 6022| 3.38k| ((uint64_t)pixcfg->private_impl.height); 6023| 3.38k| size_t width = (size_t)(pixcfg->private_impl.width); 6024| 3.38k| if ((wh > (UINT64_MAX / bytes_per_pixel)) || ------------------ | Branch (6024:7): [True: 0, False: 3.38k] ------------------ 6025| 3.38k| (width > (SIZE_MAX / bytes_per_pixel))) { ------------------ | Branch (6025:7): [True: 0, False: 3.38k] ------------------ 6026| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 6027| 0| } 6028| 3.38k| wh *= bytes_per_pixel; 6029| 3.38k| width = ((size_t)(width * bytes_per_pixel)); 6030| 3.38k| if (wh > len) { ------------------ | Branch (6030:7): [True: 0, False: 3.38k] ------------------ 6031| 0| return wuffs_base__make_status( 6032| 0| wuffs_base__error__bad_argument_length_too_short); 6033| 0| } 6034| | 6035| 3.38k| pb->pixcfg = *pixcfg; 6036| 3.38k| wuffs_base__table_u8* tab = &pb->private_impl.planes[0]; 6037| 3.38k| tab->ptr = ptr; 6038| 3.38k| tab->width = width; 6039| 3.38k| tab->height = pixcfg->private_impl.height; 6040| 3.38k| tab->stride = width; 6041| | return wuffs_base__make_status(NULL); 6042| 3.38k|} pixel_swizzler_fuzzer.c:wuffs_base__empty_slice_u8: 1785| 3.38k|wuffs_base__empty_slice_u8(void) { 1786| 3.38k| wuffs_base__slice_u8 ret; 1787| | ret.ptr = NULL; 1788| 3.38k| ret.len = 0; 1789| 3.38k| return ret; 1790| 3.38k|}