LLVMFuzzerTestOneInput: 118| 3.39k|LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 119| 3.39k| llvmFuzzerTestOneInput(data, size); 120| 3.39k| return 0; 121| 3.39k|} pixel_swizzler_fuzzer.c:llvmFuzzerTestOneInput: 84| 3.39k|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.39k| size_t s2 = size / 2; 87| 3.39k| uint32_t hash0 = jenkins_hash_u32(data, s2); 88| 3.39k| uint32_t hash1 = jenkins_hash_u32(data + s2, size - s2); 89| 3.39k| uint64_t hash = (((uint64_t)hash0) << 32) | ((uint64_t)hash1); 90| | 91| | // The ! means that closed will be true for (size == 0). 92| 3.39k| const bool closed = !(1 & popcount32(hash0)); 93| | 94| 3.39k| wuffs_base__io_buffer src = 95| 3.39k| wuffs_base__ptr_u8__reader((uint8_t*)data, size, closed); 96| | 97| 3.39k| const char* msg = fuzz(&src, hash); 98| 3.39k| if (msg) { ------------------ | Branch (98:7): [True: 1.96k, False: 1.42k] ------------------ 99| 1.96k| if (strnlen(msg, 2047) >= 2047) { ------------------ | Branch (99:9): [True: 0, False: 1.96k] ------------------ 100| 0| msg = "fuzzlib: internal error: error message is too long"; 101| 0| } 102| 1.96k| if (closed && strstr(msg, "base: short read")) { ------------------ | Branch (102:9): [True: 1.01k, False: 957] | Branch (102:19): [True: 0, False: 1.01k] ------------------ 103| 0| fprintf(stderr, "short read on a closed io_reader\n"); 104| 0| intentional_segfault(); 105| 1.96k| } else if (strstr(msg, "internal error:")) { ------------------ | Branch (105:16): [True: 0, False: 1.96k] ------------------ 106| | fprintf(stderr, "internal errors shouldn't occur: \"%s\"\n", msg); 107| 0| intentional_segfault(); 108| 0| } 109| 1.96k| } 110| 3.39k| return msg; 111| 3.39k|} pixel_swizzler_fuzzer.c:jenkins_hash_u32: 53| 6.79k|jenkins_hash_u32(const uint8_t* data, size_t size) { 54| 6.79k| uint32_t hash = 0; 55| 6.79k| size_t i = 0; 56| 25.4M| while (i != size) { ------------------ | Branch (56:10): [True: 25.4M, False: 6.79k] ------------------ 57| 25.4M| hash += data[i++]; 58| 25.4M| hash += hash << 10; 59| 25.4M| hash ^= hash >> 6; 60| 25.4M| } 61| 6.79k| hash += hash << 3; 62| 6.79k| hash ^= hash >> 11; 63| 6.79k| hash += hash << 15; 64| 6.79k| return hash; 65| 6.79k|} pixel_swizzler_fuzzer.c:popcount32: 27| 3.39k|popcount32(uint32_t x) { 28| 3.39k| static const uint8_t table[256] = { 29| 3.39k| 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, // 30| 3.39k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 31| 3.39k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 32| 3.39k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 33| 3.39k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 34| 3.39k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 35| 3.39k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 36| 3.39k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 37| 3.39k| 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 38| 3.39k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 39| 3.39k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 40| 3.39k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 41| 3.39k| 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, // 42| 3.39k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 43| 3.39k| 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, // 44| 3.39k| 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, // 45| 3.39k| }; 46| 3.39k| return table[0xFF & (x >> 0)] + table[0xFF & (x >> 8)] + 47| 3.39k| table[0xFF & (x >> 16)] + table[0xFF & (x >> 24)]; 48| 3.39k|} 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.39k|fuzz_swizzle_interleaved_from_slice(wuffs_base__io_buffer* src, uint64_t hash) { 127| 3.39k| uint8_t dst_palette_array[1024]; 128| 3.39k| uint8_t src_palette_array[1024]; 129| 3.39k| if ((src->meta.wi - src->meta.ri) >= 2048) { ------------------ | Branch (129:7): [True: 232, False: 3.16k] ------------------ 130| 232| memcpy(dst_palette_array, src->data.ptr + src->meta.ri, 1024); 131| 232| src->meta.ri += 1024; 132| 232| memcpy(src_palette_array, src->data.ptr + src->meta.ri, 1024); 133| 232| src->meta.ri += 1024; 134| 3.16k| } else { 135| 3.24M| 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.39k| wuffs_base__slice_u8 dst_palette = 141| 3.39k| wuffs_base__make_slice_u8(&dst_palette_array[0], 1024); 142| 3.39k| wuffs_base__slice_u8 src_palette = 143| 3.39k| wuffs_base__make_slice_u8(&src_palette_array[0], 1024); 144| | 145| 3.39k| size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]); 146| 3.39k| wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( 147| 3.39k| pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); 148| 3.39k| wuffs_base__pixel_format src_pixfmt = wuffs_base__make_pixel_format( 149| 3.39k| pixfmts[(0xFF & (hash >> 8)) % num_pixfmts]); 150| | 151| 3.39k| size_t num_blends = sizeof(blends) / sizeof(blends[0]); 152| 3.39k| wuffs_base__pixel_blend blend = blends[(0xFF & (hash >> 16)) % num_blends]; 153| | 154| 3.39k| size_t dst_len = 0xFF & (hash >> 24); 155| 3.39k| size_t src_len = 0xFF & (hash >> 32); 156| | 157| 3.39k| wuffs_base__pixel_swizzler swizzler; 158| 3.39k| wuffs_base__status status = wuffs_base__pixel_swizzler__prepare( 159| 3.39k| &swizzler, dst_pixfmt, dst_palette, src_pixfmt, src_palette, blend); 160| 3.39k| if (status.repr) { ------------------ | Branch (160:7): [True: 282, False: 3.11k] ------------------ 161| 282| return wuffs_base__status__message(&status); 162| 282| } 163| | 164| 3.11k| static size_t alloc_size = 0; 165| 3.11k| if (alloc_size == 0) { ------------------ | Branch (165:7): [True: 1, False: 3.11k] ------------------ 166| 1| alloc_size = round_up_to_pagesize(0x100); 167| 1| } 168| | 169| 3.11k| static uint8_t* dst_alloc = NULL; 170| 3.11k| if (!dst_alloc) { ------------------ | Branch (170:7): [True: 1, False: 3.11k] ------------------ 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.11k| static uint8_t* src_alloc = NULL; 178| 3.11k| if (!src_alloc) { ------------------ | Branch (178:7): [True: 1, False: 3.11k] ------------------ 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.11k| wuffs_base__slice_u8 dst_slice = 188| 3.11k| wuffs_base__make_slice_u8(dst_alloc + alloc_size - dst_len, dst_len); 189| 3.11k| wuffs_base__slice_u8 src_slice = 190| 3.11k| wuffs_base__make_slice_u8(src_alloc + alloc_size - src_len, src_len); 191| | 192| | // Fill in dst_slice and src_slice. 193| 3.11k| if ((src->meta.wi - src->meta.ri) >= (dst_len + src_len)) { ------------------ | Branch (193:7): [True: 569, False: 2.54k] ------------------ 194| 569| memcpy(dst_slice.ptr, src->data.ptr + src->meta.ri, dst_len); 195| 569| src->meta.ri += dst_len; 196| 569| memcpy(src_slice.ptr, src->data.ptr + src->meta.ri, src_len); 197| 569| src->meta.ri += src_len; 198| 2.54k| } else { 199| 319k| for (size_t i = 0; i < dst_len; i++) { ------------------ | Branch (199:24): [True: 317k, False: 2.54k] ------------------ 200| 317k| dst_slice.ptr[i] = (uint8_t)i; 201| 317k| } 202| 222k| for (size_t i = 0; i < src_len; i++) { ------------------ | Branch (202:24): [True: 220k, False: 2.54k] ------------------ 203| 220k| src_slice.ptr[i] = (uint8_t)i; 204| 220k| } 205| 2.54k| } 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.11k| wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice( 216| 3.11k| &swizzler, dst_slice, dst_palette, src_slice); 217| | 218| | return NULL; 219| 3.11k|} fuzz_swizzle_ycck: 222| 3.39k|fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) { 223| 3.39k| uint8_t dst_palette_array[1024] = {0}; 224| 3.39k| wuffs_base__slice_u8 dst_palette = 225| 3.39k| wuffs_base__make_slice_u8(&dst_palette_array[0], 1024); 226| | 227| 3.39k| size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]); 228| 3.39k| wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( 229| 3.39k| pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); 230| | 231| 3.39k| uint32_t x_min_incl = (63 & (hash >> 8)) + 1; 232| 3.39k| uint32_t x_max_excl = (63 & (hash >> 14)) + 1; 233| 3.39k| uint32_t y_min_incl = (63 & (hash >> 20)) + 1; 234| 3.39k| uint32_t y_max_excl = (63 & (hash >> 26)) + 1; 235| | 236| 3.39k| uint32_t width_in_mcus = (3 & (hash >> 32)) + 1; 237| 3.39k| uint32_t height_in_mcus = (3 & (hash >> 34)) + 1; 238| | 239| 3.39k| uint32_t allow_hv3 = 1 & (hash >> 36); 240| 3.39k| uint8_t ycc_model = (1 & (hash >> 37)) ? 0x80 : 0x00; ------------------ | Branch (240:23): [True: 1.06k, False: 2.33k] ------------------ 241| 3.39k| uint8_t ycc_upsampling = 1 & (hash >> 38); 242| 3.39k| bool use_4th_component = 1 & (hash >> 39); 243| | 244| 3.39k| if (ycc_upsampling) { ------------------ | Branch (244:7): [True: 1.29k, False: 2.10k] ------------------ 245| 1.29k| x_min_incl = 0; 246| 1.29k| y_min_incl = 0; 247| 2.10k| } else { 248| 2.10k| if (x_min_incl > x_max_excl) { ------------------ | Branch (248:9): [True: 1.07k, False: 1.02k] ------------------ 249| 1.07k| uint32_t a = x_min_incl; 250| 1.07k| x_min_incl = x_max_excl; 251| 1.07k| x_max_excl = a; 252| 1.07k| } 253| 2.10k| if (y_min_incl > y_max_excl) { ------------------ | Branch (253:9): [True: 1.22k, False: 876] ------------------ 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.10k| } 259| | 260| 3.39k| uint32_t possible_hv_values[2][4] = { 261| 3.39k| {1, 1, 2, 4}, 262| 3.39k| {1, 1, 3, 3}, 263| 3.39k| }; 264| 3.39k| uint32_t h0 = possible_hv_values[allow_hv3][3 & (hash >> 28)]; 265| 3.39k| uint32_t h1 = possible_hv_values[allow_hv3][3 & (hash >> 30)]; 266| 3.39k| uint32_t h2 = possible_hv_values[allow_hv3][3 & (hash >> 32)]; 267| 3.39k| uint32_t h3 = 268| 3.39k| use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 34)] : 0; ------------------ | Branch (268:7): [True: 786, False: 2.61k] ------------------ 269| 3.39k| uint32_t v0 = possible_hv_values[allow_hv3][3 & (hash >> 36)]; 270| 3.39k| uint32_t v1 = possible_hv_values[allow_hv3][3 & (hash >> 38)]; 271| 3.39k| uint32_t v2 = possible_hv_values[allow_hv3][3 & (hash >> 40)]; 272| 3.39k| uint32_t v3 = 273| 3.39k| use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 42)] : 0; ------------------ | Branch (273:7): [True: 786, False: 2.61k] ------------------ 274| | 275| 3.39k| uint32_t width0 = 8 * width_in_mcus * h0; 276| 3.39k| uint32_t width1 = 8 * width_in_mcus * h1; 277| 3.39k| uint32_t width2 = 8 * width_in_mcus * h2; 278| 3.39k| uint32_t width3 = 8 * width_in_mcus * h3; 279| 3.39k| uint32_t height0 = 8 * height_in_mcus * v0; 280| 3.39k| uint32_t height1 = 8 * height_in_mcus * v1; 281| 3.39k| uint32_t height2 = 8 * height_in_mcus * v2; 282| 3.39k| uint32_t height3 = 8 * height_in_mcus * v3; 283| | 284| 3.39k| uint32_t hmax = wuffs_base__u32__max( 285| 3.39k| h0, wuffs_base__u32__max(h1, wuffs_base__u32__max(h2, h3))); 286| 3.39k| uint32_t vmax = wuffs_base__u32__max( 287| 3.39k| v0, wuffs_base__u32__max(v1, wuffs_base__u32__max(v2, v3))); 288| 3.39k| x_max_excl = x_min_incl + wuffs_base__u32__min(x_max_excl - x_min_incl, 289| 3.39k| 8 * width_in_mcus * hmax); 290| 3.39k| y_max_excl = y_min_incl + wuffs_base__u32__min(y_max_excl - y_min_incl, 291| 3.39k| 8 * height_in_mcus * vmax); 292| | 293| 3.39k| static size_t dst_alloc_size = 0; 294| 3.39k| if (dst_alloc_size == 0) { ------------------ | Branch (294:7): [True: 1, False: 3.39k] ------------------ 295| 1| dst_alloc_size = round_up_to_pagesize(8 * 64 * 64); 296| 1| } 297| | 298| 3.39k| static uint8_t* dst_alloc = NULL; 299| 3.39k| if (!dst_alloc) { ------------------ | Branch (299:7): [True: 1, False: 3.39k] ------------------ 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.39k| wuffs_base__pixel_buffer dst_pixbuf; 307| 3.39k| wuffs_base__pixel_config dst_pixcfg; 308| 3.39k| wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, x_max_excl, 309| 3.39k| y_max_excl); 310| 3.39k| uint64_t dst_pixbuf_len = wuffs_base__pixel_config__pixbuf_len(&dst_pixcfg); 311| 3.39k| if (dst_pixbuf_len > dst_alloc_size) { ------------------ | Branch (311:7): [True: 0, False: 3.39k] ------------------ 312| 0| return "fuzz: internal error: dst_alloc_size is too small"; 313| 3.39k| } else { 314| 3.39k| wuffs_base__status status = wuffs_base__pixel_buffer__set_from_slice( 315| 3.39k| &dst_pixbuf, &dst_pixcfg, 316| 3.39k| wuffs_base__make_slice_u8(dst_alloc + dst_alloc_size - dst_pixbuf_len, 317| 3.39k| dst_pixbuf_len)); 318| 3.39k| if (status.repr) { ------------------ | Branch (318:9): [True: 0, False: 3.39k] ------------------ 319| 0| return "fuzz: internal error: wuffs_base__pixel_buffer__set_from_slice " 320| 0| "failed"; 321| 0| } 322| 3.39k| } 323| | 324| 3.39k| static size_t src_alloc_size = 0; 325| 3.39k| if (src_alloc_size == 0) { ------------------ | Branch (325:7): [True: 1, False: 3.39k] ------------------ 326| 1| src_alloc_size = round_up_to_pagesize(8 * 4 * 4 * 8 * 4 * 4); 327| 1| } 328| | 329| 3.39k| static uint8_t* src_alloc0 = NULL; 330| 3.39k| static uint8_t* src_alloc1 = NULL; 331| 3.39k| static uint8_t* src_alloc2 = NULL; 332| 3.39k| static uint8_t* src_alloc3 = NULL; 333| 3.39k| if (!src_alloc0) { ------------------ | Branch (333:7): [True: 1, False: 3.39k] ------------------ 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.39k| if (!src_alloc1) { ------------------ | Branch (339:7): [True: 1, False: 3.39k] ------------------ 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.39k| if (!src_alloc2) { ------------------ | Branch (345:7): [True: 1, False: 3.39k] ------------------ 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.39k| if (!src_alloc3) { ------------------ | Branch (351:7): [True: 1, False: 3.39k] ------------------ 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.39k| uint32_t src_len0 = width0 * height0; 359| 3.39k| uint32_t src_len1 = width1 * height1; 360| 3.39k| uint32_t src_len2 = width2 * height2; 361| 3.39k| uint32_t src_len3 = width3 * height3; 362| 3.39k| if ((src_len0 > src_alloc_size) || // ------------------ | Branch (362:7): [True: 0, False: 3.39k] ------------------ 363| 3.39k| (src_len1 > src_alloc_size) || // ------------------ | Branch (363:7): [True: 0, False: 3.39k] ------------------ 364| 3.39k| (src_len2 > src_alloc_size) || // ------------------ | Branch (364:7): [True: 0, False: 3.39k] ------------------ 365| 3.39k| (src_len3 > src_alloc_size)) { ------------------ | Branch (365:7): [True: 0, False: 3.39k] ------------------ 366| 0| return "fuzz: internal error: src_alloc_size is too small"; 367| 0| } 368| | 369| 3.39k| uint8_t s0 = 0x90; 370| 3.39k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (370:7): [True: 3.08k, False: 310] ------------------ 371| 3.08k| s0 = src->data.ptr[src->meta.ri++]; 372| 3.08k| } 373| 3.39k| uint8_t s1 = 0x91; 374| 3.39k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (374:7): [True: 2.79k, False: 598] ------------------ 375| 2.79k| s1 = src->data.ptr[src->meta.ri++]; 376| 2.79k| } 377| 3.39k| uint8_t s2 = 0x92; 378| 3.39k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (378:7): [True: 1.71k, False: 1.68k] ------------------ 379| 1.71k| s2 = src->data.ptr[src->meta.ri++]; 380| 1.71k| } 381| 3.39k| uint8_t s3 = 0x93; 382| 3.39k| if (src->meta.ri < src->meta.wi) { ------------------ | Branch (382:7): [True: 391, False: 3.00k] ------------------ 383| 391| s3 = src->data.ptr[src->meta.ri++]; 384| 391| } 385| | 386| 3.39k| wuffs_base__slice_u8 src0 = wuffs_base__make_slice_u8( 387| 3.39k| src_alloc0 + src_alloc_size - src_len0, src_len0); 388| 3.39k| memset(src0.ptr, s0, src0.len); 389| 3.39k| wuffs_base__slice_u8 src1 = wuffs_base__make_slice_u8( 390| 3.39k| src_alloc1 + src_alloc_size - src_len1, src_len1); 391| 3.39k| memset(src1.ptr, s1, src1.len); 392| 3.39k| wuffs_base__slice_u8 src2 = wuffs_base__make_slice_u8( 393| 3.39k| src_alloc2 + src_alloc_size - src_len2, src_len2); 394| 3.39k| memset(src2.ptr, s2, src2.len); 395| 3.39k| wuffs_base__slice_u8 src3 = wuffs_base__empty_slice_u8(); 396| 3.39k| if (use_4th_component) { ------------------ | Branch (396:7): [True: 786, False: 2.61k] ------------------ 397| 786| wuffs_base__slice_u8 src3 = wuffs_base__make_slice_u8( 398| 786| src_alloc3 + src_alloc_size - src_len3, src_len3); 399| 786| memset(src3.ptr, s3, src3.len); 400| 786| } 401| | 402| 3.39k| wuffs_base__pixel_swizzler swizzler = {0}; 403| 3.39k| uint8_t scratch_buffer[2048]; 404| 3.39k| wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck( 405| 3.39k| &swizzler, &dst_pixbuf, dst_palette, // 406| 3.39k| x_min_incl, x_max_excl, // 407| 3.39k| y_min_incl, y_max_excl, // 408| 3.39k| src0, src1, src2, src3, // 409| 3.39k| width0, width1, width2, width3, // 410| 3.39k| height0, height1, height2, height3, // 411| 3.39k| width0, width1, width2, width3, // 412| 3.39k| h0, h1, h2, h3, // 413| 3.39k| v0, v1, v2, v3, // 414| 3.39k| ycc_model, // 415| 3.39k| ycc_upsampling, // 416| 3.39k| wuffs_base__make_slice_u8(scratch_buffer, sizeof(scratch_buffer))); 417| 3.39k| if (status.repr) { ------------------ | Branch (417:7): [True: 1.73k, False: 1.66k] ------------------ 418| 1.73k| return wuffs_base__status__message(&status); 419| 1.73k| } 420| 1.66k| return NULL; 421| 3.39k|} fuzz: 424| 3.39k|fuzz(wuffs_base__io_buffer* src, uint64_t hash) { 425| 3.39k| const char* s0 = fuzz_swizzle_interleaved_from_slice(src, hash); 426| 3.39k| const char* s1 = fuzz_swizzle_ycck(src, hash); 427| 3.39k| if (s0 && strstr(s0, "internal error:")) { ------------------ | Branch (427:7): [True: 282, False: 3.11k] | Branch (427:13): [True: 0, False: 282] ------------------ 428| 0| return s0; 429| 0| } 430| 3.39k| if (s1 && strstr(s1, "internal error:")) { ------------------ | Branch (430:7): [True: 1.73k, False: 1.66k] | Branch (430:13): [True: 0, False: 1.73k] ------------------ 431| 0| return s1; 432| 0| } 433| 3.39k| return s0 ? s0 : s1; ------------------ | Branch (433:10): [True: 282, False: 3.11k] ------------------ 434| 3.39k|} wuffs_base__pixel_buffer__set_color_u32_argb_premul_at: 24596| 497k| wuffs_base__color_u32_argb_premul color) { 24597| 497k| if (!pb) { ------------------ | Branch (24597:7): [True: 0, False: 497k] ------------------ 24598| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 24599| 0| } 24600| 497k| if ((x >= pb->pixcfg.private_impl.width) || ------------------ | Branch (24600:7): [True: 0, False: 497k] ------------------ 24601| 497k| (y >= pb->pixcfg.private_impl.height)) { ------------------ | Branch (24601:7): [True: 0, False: 497k] ------------------ 24602| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 24603| 0| } 24604| | 24605| 497k| if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (24605:7): [True: 0, False: 497k] ------------------ 24606| | // TODO: support planar formats. 24607| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 24608| 0| } 24609| | 24610| 497k| size_t stride = pb->private_impl.planes[0].stride; 24611| 497k| uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)); 24612| | 24613| 497k| switch (pb->pixcfg.private_impl.pixfmt.repr) { 24614| 18.6k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 18.6k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (24614:5): [True: 18.6k, False: 478k] ------------------ 24615| 28.9k| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 28.9k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (24615:5): [True: 10.3k, False: 486k] ------------------ 24616| 28.9k| wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color); 24617| 28.9k| break; 24618| | 24619| | // Common formats above. Rarer formats below. 24620| | 24621| 56.2k| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 56.2k|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (24621:5): [True: 56.2k, False: 440k] ------------------ 24622| 56.2k| wuffs_base__poke_u8__no_bounds_check( 24623| 56.2k| row + ((size_t)x), 24624| 56.2k| wuffs_base__color_u32_argb_premul__as__color_u8_gray(color)); 24625| 56.2k| break; 24626| 17.7k| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 17.7k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (24626:5): [True: 17.7k, False: 479k] ------------------ 24627| 17.7k| wuffs_base__poke_u16le__no_bounds_check( 24628| 17.7k| row + (2 * ((size_t)x)), 24629| 17.7k| wuffs_base__color_u32_argb_premul__as__color_u16_gray(color)); 24630| 17.7k| break; 24631| 9.01k| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 9.01k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (24631:5): [True: 9.01k, False: 488k] ------------------ 24632| 9.01k| wuffs_base__poke_u16be__no_bounds_check( 24633| 9.01k| row + (2 * ((size_t)x)), 24634| 9.01k| wuffs_base__color_u32_argb_premul__as__color_u16_gray(color)); 24635| 9.01k| break; 24636| 27.2k| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4946| 27.2k|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (24636:5): [True: 27.2k, False: 469k] ------------------ 24637| 27.2k| wuffs_base__poke_u16le__no_bounds_check( 24638| 27.2k| row + (2 * ((size_t)x)), 24639| 27.2k| wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul( 24640| 27.2k| color)); 24641| 27.2k| break; 24642| | 24643| 37.0k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 37.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (24643:5): [True: 37.0k, False: 460k] ------------------ 24644| 37.0k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4959| 37.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (24644:5): [True: 0, False: 497k] ------------------ 24645| 54.7k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4960| 54.7k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (24645:5): [True: 17.7k, False: 479k] ------------------ 24646| 54.7k| wuffs_base__poke_u8__no_bounds_check( 24647| 54.7k| row + ((size_t)x), wuffs_base__pixel_palette__closest_element( 24648| 54.7k| wuffs_base__pixel_buffer__palette(pb), 24649| 54.7k| pb->pixcfg.private_impl.pixfmt, color)); 24650| 54.7k| break; 24651| | 24652| 56.6k| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 56.6k|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (24652:5): [True: 56.6k, False: 440k] ------------------ 24653| 56.6k| wuffs_base__poke_u16le__no_bounds_check( 24654| 56.6k| row + (2 * ((size_t)x)), 24655| 56.6k| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color)); 24656| 56.6k| break; 24657| 66.7k| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 66.7k|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (24657:5): [True: 66.7k, False: 430k] ------------------ 24658| 66.7k| wuffs_base__poke_u24le__no_bounds_check(row + (3 * ((size_t)x)), color); 24659| 66.7k| break; 24660| 17.4k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 17.4k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (24660:5): [True: 17.4k, False: 479k] ------------------ 24661| 17.4k| wuffs_base__poke_u32le__no_bounds_check( 24662| 17.4k| row + (4 * ((size_t)x)), 24663| 17.4k| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 24664| 17.4k| color)); 24665| 17.4k| break; 24666| 76.7k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 76.7k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (24666:5): [True: 76.7k, False: 420k] ------------------ 24667| 76.7k| wuffs_base__poke_u64le__no_bounds_check( 24668| 76.7k| row + (8 * ((size_t)x)), 24669| 76.7k| wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul( 24670| 76.7k| color)); 24671| 76.7k| 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: 497k] ------------------ 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: 497k] ------------------ 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| 48.0k| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 48.0k|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (24681:5): [True: 48.0k, False: 449k] ------------------ 24682| 48.0k| wuffs_base__poke_u24le__no_bounds_check( 24683| 48.0k| row + (3 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color)); 24684| 48.0k| break; 24685| 20.2k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 20.2k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (24685:5): [True: 20.2k, False: 476k] ------------------ 24686| 20.2k| wuffs_base__poke_u32le__no_bounds_check( 24687| 20.2k| row + (4 * ((size_t)x)), 24688| 20.2k| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 24689| 20.2k| wuffs_base__color_swap_u32_argb_abgr(color))); 24690| 20.2k| break; 24691| 17.4k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 17.4k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (24691:5): [True: 17.4k, False: 479k] ------------------ 24692| 17.4k| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 17.4k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (24692:5): [True: 0, False: 497k] ------------------ 24693| 17.4k| wuffs_base__poke_u32le__no_bounds_check( 24694| 17.4k| row + (4 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color)); 24695| 17.4k| break; 24696| | 24697| 0| default: ------------------ | Branch (24697:5): [True: 0, False: 497k] ------------------ 24698| | // TODO: support more formats. 24699| 0| return wuffs_base__make_status(wuffs_base__error__unsupported_option); 24700| 497k| } 24701| | 24702| 497k| return wuffs_base__make_status(NULL); 24703| 497k|} wuffs_base__pixel_palette__closest_element: 25365| 54.7k| wuffs_base__color_u32_argb_premul c) { 25366| 54.7k| size_t n = palette_slice.len / 4; 25367| 54.7k| if (n > (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 54.7k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ | Branch (25367:7): [True: 0, False: 54.7k] ------------------ 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| 54.7k| size_t best_index = 0; 25371| 54.7k| uint64_t best_score = 0xFFFFFFFFFFFFFFFF; 25372| | 25373| | // Work in 16-bit color. 25374| 54.7k| uint32_t ca = 0x101 * (0xFF & (c >> 24)); 25375| 54.7k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 25376| 54.7k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 25377| 54.7k| uint32_t cb = 0x101 * (0xFF & (c >> 0)); 25378| | 25379| 54.7k| switch (palette_format.repr) { ------------------ | Branch (25379:11): [True: 54.7k, False: 0] ------------------ 25380| 37.0k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 37.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (25380:5): [True: 37.0k, False: 17.7k] ------------------ 25381| 37.0k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4959| 37.0k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (25381:5): [True: 0, False: 54.7k] ------------------ 25382| 54.7k| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: { ------------------ | | 4960| 54.7k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (25382:5): [True: 17.7k, False: 37.0k] ------------------ 25383| 54.7k| bool nonpremul = palette_format.repr == 25384| 54.7k| WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL; ------------------ | | 4958| 54.7k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ 25385| | 25386| 54.7k| size_t i; 25387| 14.0M| for (i = 0; i < n; i++) { ------------------ | Branch (25387:19): [True: 14.0M, False: 54.7k] ------------------ 25388| | // Work in 16-bit color. 25389| 14.0M| uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0])); 25390| 14.0M| uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1])); 25391| 14.0M| uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2])); 25392| 14.0M| uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3])); 25393| | 25394| | // Convert to premultiplied alpha. 25395| 14.0M| if (nonpremul && (pa != 0xFFFF)) { ------------------ | Branch (25395:13): [True: 9.47M, False: 4.54M] | Branch (25395:26): [True: 4.49M, False: 4.97M] ------------------ 25396| 4.49M| pb = (pb * pa) / 0xFFFF; 25397| 4.49M| pg = (pg * pa) / 0xFFFF; 25398| 4.49M| pr = (pr * pa) / 0xFFFF; 25399| 4.49M| } 25400| | 25401| | // These deltas are conceptually int32_t (signed) but after squaring, 25402| | // it's equivalent to work in uint32_t (unsigned). 25403| 14.0M| pb -= cb; 25404| 14.0M| pg -= cg; 25405| 14.0M| pr -= cr; 25406| 14.0M| pa -= ca; 25407| 14.0M| uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) + 25408| 14.0M| ((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa)); 25409| 14.0M| if (best_score > score) { ------------------ | Branch (25409:13): [True: 120k, False: 13.8M] ------------------ 25410| 120k| best_score = score; 25411| 120k| best_index = i; 25412| 120k| } 25413| 14.0M| } 25414| 54.7k| break; 25415| 37.0k| } 25416| 54.7k| } 25417| | 25418| 54.7k| return (uint8_t)best_index; 25419| 54.7k|} wuffs_base__pixel_swizzler__prepare: 32599| 3.39k| wuffs_base__pixel_blend blend) { 32600| 3.39k| if (!p) { ------------------ | Branch (32600:7): [True: 0, False: 3.39k] ------------------ 32601| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 32602| 0| } 32603| 3.39k| p->private_impl.func = NULL; 32604| 3.39k| p->private_impl.transparent_black_func = NULL; 32605| 3.39k| p->private_impl.dst_pixfmt_bytes_per_pixel = 0; 32606| 3.39k| 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.39k| wuffs_base__pixel_swizzler__func func = NULL; 32661| 3.39k| wuffs_base__pixel_swizzler__transparent_black_func transparent_black_func = 32662| 3.39k| NULL; 32663| | 32664| 3.39k| uint32_t dst_pixfmt_bits_per_pixel = 32665| 3.39k| wuffs_base__pixel_format__bits_per_pixel(&dst_pixfmt); 32666| 3.39k| if ((dst_pixfmt_bits_per_pixel == 0) || ------------------ | Branch (32666:7): [True: 0, False: 3.39k] ------------------ 32667| 3.39k| ((dst_pixfmt_bits_per_pixel & 7) != 0)) { ------------------ | Branch (32667:7): [True: 0, False: 3.39k] ------------------ 32668| 0| return wuffs_base__make_status( 32669| 0| wuffs_base__error__unsupported_pixel_swizzler_option); 32670| 0| } 32671| | 32672| 3.39k| uint32_t src_pixfmt_bits_per_pixel = 32673| 3.39k| wuffs_base__pixel_format__bits_per_pixel(&src_pixfmt); 32674| 3.39k| if ((src_pixfmt_bits_per_pixel == 0) || ------------------ | Branch (32674:7): [True: 0, False: 3.39k] ------------------ 32675| 3.39k| ((src_pixfmt_bits_per_pixel & 7) != 0)) { ------------------ | Branch (32675:7): [True: 0, False: 3.39k] ------------------ 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.39k| switch (blend) { ------------------ | Branch (32682:11): [True: 3.39k, False: 0] ------------------ 32683| 1.51k| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1.51k|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32683:5): [True: 1.51k, False: 1.88k] ------------------ 32684| 1.51k| transparent_black_func = 32685| 1.51k| wuffs_private_impl__swizzle_transparent_black_src; 32686| 1.51k| break; 32687| | 32688| 1.88k| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 1.88k|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32688:5): [True: 1.88k, False: 1.51k] ------------------ 32689| 1.88k| transparent_black_func = 32690| 1.88k| wuffs_private_impl__swizzle_transparent_black_src_over; 32691| 1.88k| break; 32692| 3.39k| } 32693| | 32694| 3.39k| switch (src_pixfmt.repr) { ------------------ | Branch (32694:11): [True: 3.39k, False: 0] ------------------ 32695| 143| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 143|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32695:5): [True: 143, False: 3.25k] ------------------ 32696| 143| func = wuffs_private_impl__pixel_swizzler__prepare__y( 32697| 143| p, dst_pixfmt, dst_palette, src_palette, blend); 32698| 143| break; 32699| | 32700| 121| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 121|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (32700:5): [True: 121, False: 3.27k] ------------------ 32701| 121| func = wuffs_private_impl__pixel_swizzler__prepare__y_16be( 32702| 121| p, dst_pixfmt, dst_palette, src_palette, blend); 32703| 121| break; 32704| | 32705| 139| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 139|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (32705:5): [True: 139, False: 3.25k] ------------------ 32706| 139| func = wuffs_private_impl__pixel_swizzler__prepare__y_16le( 32707| 139| p, dst_pixfmt, dst_palette, src_palette, blend); 32708| 139| break; 32709| | 32710| 283| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4946| 283|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (32710:5): [True: 283, False: 3.11k] ------------------ 32711| 283| func = wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul( 32712| 283| p, dst_pixfmt, dst_palette, src_palette, blend); 32713| 283| break; 32714| | 32715| 230| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 230|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (32715:5): [True: 230, False: 3.16k] ------------------ 32716| 230| func = 32717| 230| wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul( 32718| 230| p, dst_pixfmt, dst_palette, src_palette, blend); 32719| 230| break; 32720| | 32721| 340| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4960| 340|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (32721:5): [True: 340, False: 3.05k] ------------------ 32722| 340| func = wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary( 32723| 340| p, dst_pixfmt, dst_palette, src_palette, blend); 32724| 340| break; 32725| | 32726| 121| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 121|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32726:5): [True: 121, False: 3.27k] ------------------ 32727| 121| func = wuffs_private_impl__pixel_swizzler__prepare__bgr_565( 32728| 121| p, dst_pixfmt, dst_palette, src_palette, blend); 32729| 121| break; 32730| | 32731| 129| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 129|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32731:5): [True: 129, False: 3.26k] ------------------ 32732| 129| func = wuffs_private_impl__pixel_swizzler__prepare__bgr( 32733| 129| p, dst_pixfmt, dst_palette, src_palette, blend); 32734| 129| break; 32735| | 32736| 230| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 230|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32736:5): [True: 230, False: 3.16k] ------------------ 32737| 230| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul( 32738| 230| p, dst_pixfmt, dst_palette, src_palette, blend); 32739| 230| break; 32740| | 32741| 299| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 299|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32741:5): [True: 299, False: 3.09k] ------------------ 32742| 299| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le( 32743| 299| p, dst_pixfmt, dst_palette, src_palette, blend); 32744| 299| break; 32745| | 32746| 267| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 267|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32746:5): [True: 267, False: 3.12k] ------------------ 32747| 267| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul( 32748| 267| p, dst_pixfmt, dst_palette, src_palette, blend); 32749| 267| break; 32750| | 32751| 394| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 394|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (32751:5): [True: 394, False: 3.00k] ------------------ 32752| 394| func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le( 32753| 394| p, dst_pixfmt, dst_palette, src_palette, blend); 32754| 394| 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.39k] ------------------ 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| 134| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 134|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32761:5): [True: 134, False: 3.26k] ------------------ 32762| 134| func = wuffs_private_impl__pixel_swizzler__prepare__bgrx( 32763| 134| p, dst_pixfmt, dst_palette, src_palette, blend); 32764| 134| break; 32765| | 32766| 111| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 111|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32766:5): [True: 111, False: 3.28k] ------------------ 32767| 111| func = wuffs_private_impl__pixel_swizzler__prepare__rgb( 32768| 111| p, dst_pixfmt, dst_palette, src_palette, blend); 32769| 111| 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.17k] ------------------ 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| 238| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 238|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32776:5): [True: 238, False: 3.15k] ------------------ 32777| 238| func = wuffs_private_impl__pixel_swizzler__prepare__rgba_premul( 32778| 238| p, dst_pixfmt, dst_palette, src_palette, blend); 32779| 238| break; 32780| 3.39k| } 32781| | 32782| 3.39k| p->private_impl.func = func; 32783| 3.39k| p->private_impl.transparent_black_func = transparent_black_func; 32784| 3.39k| p->private_impl.dst_pixfmt_bytes_per_pixel = dst_pixfmt_bits_per_pixel / 8; 32785| 3.39k| p->private_impl.src_pixfmt_bytes_per_pixel = src_pixfmt_bits_per_pixel / 8; 32786| 3.39k| return wuffs_base__make_status( 32787| 3.39k| func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_option); ------------------ | Branch (32787:7): [True: 3.11k, False: 282] ------------------ 32788| 3.39k|} wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice: 32837| 3.11k| wuffs_base__slice_u8 src) { 32838| 3.11k| if (p && p->private_impl.func) { ------------------ | Branch (32838:7): [True: 3.11k, False: 0] | Branch (32838:12): [True: 3.11k, False: 0] ------------------ 32839| 3.11k| return (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr, 32840| 3.11k| dst_palette.len, src.ptr, src.len); 32841| 3.11k| } 32842| 0| return 0; 32843| 3.11k|} wuffs_base__pixel_swizzler__swizzle_ycck: 34295| 3.39k| wuffs_base__slice_u8 scratch_buffer_2k) { 34296| 3.39k| if (!p) { ------------------ | Branch (34296:7): [True: 0, False: 3.39k] ------------------ 34297| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 34298| 3.39k| } else if (!dst || // ------------------ | Branch (34298:14): [True: 0, False: 3.39k] ------------------ 34299| 3.39k| (x_min_incl > x_max_excl) || // ------------------ | Branch (34299:14): [True: 0, False: 3.39k] ------------------ 34300| 3.39k| (x_max_excl > 0xFFFFu) || // ------------------ | Branch (34300:14): [True: 0, False: 3.39k] ------------------ 34301| 3.39k| (y_min_incl > y_max_excl) || // ------------------ | Branch (34301:14): [True: 0, False: 3.39k] ------------------ 34302| 3.39k| (y_max_excl > 0xFFFFu) || // ------------------ | Branch (34302:14): [True: 0, False: 3.39k] ------------------ 34303| 3.39k| (4u <= ((unsigned int)h0 - 1u)) || // ------------------ | Branch (34303:14): [True: 0, False: 3.39k] ------------------ 34304| 3.39k| (4u <= ((unsigned int)h1 - 1u)) || // ------------------ | Branch (34304:14): [True: 0, False: 3.39k] ------------------ 34305| 3.39k| (4u <= ((unsigned int)h2 - 1u)) || // ------------------ | Branch (34305:14): [True: 0, False: 3.39k] ------------------ 34306| 3.39k| (4u <= ((unsigned int)v0 - 1u)) || // ------------------ | Branch (34306:14): [True: 0, False: 3.39k] ------------------ 34307| 3.39k| (4u <= ((unsigned int)v1 - 1u)) || // ------------------ | Branch (34307:14): [True: 0, False: 3.39k] ------------------ 34308| 3.39k| (4u <= ((unsigned int)v2 - 1u)) || // ------------------ | Branch (34308:14): [True: 0, False: 3.39k] ------------------ 34309| 3.39k| ((ycc_upsampling != 0) && ((x_min_incl | y_min_incl) > 0u)) || ------------------ | Branch (34309:15): [True: 1.29k, False: 2.10k] | Branch (34309:40): [True: 0, False: 1.29k] ------------------ 34310| 3.39k| (scratch_buffer_2k.len < 2048u)) { ------------------ | Branch (34310:14): [True: 0, False: 3.39k] ------------------ 34311| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34312| 0| } 34313| 3.39k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (34313:7): [True: 786, False: 2.61k] | Branch (34313:21): [True: 0, False: 2.61k] ------------------ 34314| 786| if ((4u <= ((unsigned int)h3 - 1u)) || // ------------------ | Branch (34314:9): [True: 0, False: 786] ------------------ 34315| 786| (4u <= ((unsigned int)v3 - 1u))) { ------------------ | Branch (34315:9): [True: 0, False: 786] ------------------ 34316| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34317| 0| } 34318| 786| } 34319| | 34320| 3.39k| uint32_t max_incl_h = wuffs_private_impl__u32__max_of_4(h0, h1, h2, h3); 34321| 3.39k| 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.39k| uint32_t inv_h0 = max_incl_h / h0; 34328| 3.39k| uint32_t inv_h1 = max_incl_h / h1; 34329| 3.39k| uint32_t inv_h2 = max_incl_h / h2; 34330| 3.39k| uint32_t inv_h3 = h3 ? (max_incl_h / h3) : 0u; ------------------ | Branch (34330:21): [True: 786, False: 2.61k] ------------------ 34331| 3.39k| uint32_t inv_v0 = max_incl_v / v0; 34332| 3.39k| uint32_t inv_v1 = max_incl_v / v1; 34333| 3.39k| uint32_t inv_v2 = max_incl_v / v2; 34334| 3.39k| uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; ------------------ | Branch (34334:21): [True: 786, False: 2.61k] ------------------ 34335| | 34336| 3.39k| if (x_min_incl != 0) { ------------------ | Branch (34336:7): [True: 2.10k, False: 1.29k] ------------------ 34337| 2.10k| if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) || ------------------ | Branch (34337:9): [True: 422, False: 1.67k] | Branch (34337:34): [True: 223, False: 1.45k] ------------------ 34338| 1.45k| (x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) { ------------------ | Branch (34338:9): [True: 129, False: 1.32k] | Branch (34338:35): [True: 178, False: 1.14k] | Branch (34338:45): [True: 14, False: 164] ------------------ 34339| 788| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34340| 788| } 34341| 2.10k| } 34342| 2.60k| if (y_min_incl != 0) { ------------------ | Branch (34342:7): [True: 1.31k, False: 1.29k] ------------------ 34343| 1.31k| if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) || ------------------ | Branch (34343:9): [True: 264, False: 1.04k] | Branch (34343:34): [True: 101, False: 948] ------------------ 34344| 948| (y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) { ------------------ | Branch (34344:9): [True: 25, False: 923] | Branch (34344:35): [True: 82, False: 841] | Branch (34344:45): [True: 11, False: 71] ------------------ 34345| 401| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34346| 401| } 34347| 1.31k| } 34348| | 34349| 2.20k| uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u; 34350| 2.20k| if (inv_h0 == 2) { ------------------ | Branch (34350:7): [True: 316, False: 1.89k] ------------------ 34351| 316| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0); 34352| 316| } 34353| 2.20k| if (inv_h1 == 2) { ------------------ | Branch (34353:7): [True: 300, False: 1.90k] ------------------ 34354| 300| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1); 34355| 300| } 34356| 2.20k| if (inv_h2 == 2) { ------------------ | Branch (34356:7): [True: 317, False: 1.89k] ------------------ 34357| 317| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2); 34358| 317| } 34359| 2.20k| if (inv_h3 == 2) { ------------------ | Branch (34359:7): [True: 60, False: 2.14k] ------------------ 34360| 60| half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3); 34361| 60| } 34362| | 34363| 2.20k| uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u; 34364| 2.20k| if (inv_v0 == 2) { ------------------ | Branch (34364:7): [True: 336, False: 1.87k] ------------------ 34365| 336| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0); 34366| 336| } 34367| 2.20k| if (inv_v1 == 2) { ------------------ | Branch (34367:7): [True: 326, False: 1.88k] ------------------ 34368| 326| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1); 34369| 326| } 34370| 2.20k| if (inv_v2 == 2) { ------------------ | Branch (34370:7): [True: 200, False: 2.00k] ------------------ 34371| 200| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2); 34372| 200| } 34373| 2.20k| if (inv_v3 == 2) { ------------------ | Branch (34373:7): [True: 71, False: 2.13k] ------------------ 34374| 71| half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3); 34375| 71| } 34376| | 34377| 2.20k| x_max_excl = wuffs_base__u32__min( // 34378| 2.20k| wuffs_base__pixel_config__width(&dst->pixcfg), // 34379| 2.20k| x_min_incl + wuffs_private_impl__u32__min_of_5( // 34380| 2.20k| x_max_excl - x_min_incl, // 34381| 2.20k| width0 * inv_h0, // 34382| 2.20k| width1 * inv_h1, // 34383| 2.20k| width2 * inv_h2, // 34384| 2.20k| inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF)); ------------------ | Branch (34384:24): [True: 529, False: 1.67k] ------------------ 34385| 2.20k| y_max_excl = wuffs_base__u32__min( // 34386| 2.20k| wuffs_base__pixel_config__height(&dst->pixcfg), // 34387| 2.20k| y_min_incl + wuffs_private_impl__u32__min_of_5( // 34388| 2.20k| y_max_excl - y_min_incl, // 34389| 2.20k| height0 * inv_v0, // 34390| 2.20k| height1 * inv_v1, // 34391| 2.20k| height2 * inv_v2, // 34392| 2.20k| inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF)); ------------------ | Branch (34392:24): [True: 529, False: 1.67k] ------------------ 34393| | 34394| 2.20k| if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) { ------------------ | Branch (34394:7): [True: 12, False: 2.19k] | Branch (34394:37): [True: 14, False: 2.18k] ------------------ 34395| 26| return wuffs_base__make_status(NULL); 34396| 26| } 34397| 2.18k| uint32_t width = x_max_excl - x_min_incl; 34398| 2.18k| uint32_t height = y_max_excl - y_min_incl; 34399| | 34400| 2.18k| if (((h0 * inv_h0) != max_incl_h) || // ------------------ | Branch (34400:7): [True: 0, False: 2.18k] ------------------ 34401| 2.18k| ((h1 * inv_h1) != max_incl_h) || // ------------------ | Branch (34401:7): [True: 0, False: 2.18k] ------------------ 34402| 2.18k| ((h2 * inv_h2) != max_incl_h) || // ------------------ | Branch (34402:7): [True: 0, False: 2.18k] ------------------ 34403| 2.18k| ((v0 * inv_v0) != max_incl_v) || // ------------------ | Branch (34403:7): [True: 0, False: 2.18k] ------------------ 34404| 2.18k| ((v1 * inv_v1) != max_incl_v) || // ------------------ | Branch (34404:7): [True: 0, False: 2.18k] ------------------ 34405| 2.18k| ((v2 * inv_v2) != max_incl_v) || // ------------------ | Branch (34405:7): [True: 0, False: 2.18k] ------------------ 34406| 2.18k| (src0.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34406:7): [True: 0, False: 2.18k] ------------------ 34407| 2.18k| width, height, stride0, inv_h0, inv_v0)) || 34408| 2.18k| (src1.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34408:7): [True: 0, False: 2.18k] ------------------ 34409| 2.18k| width, height, stride1, inv_h1, inv_v1)) || 34410| 2.18k| (src2.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34410:7): [True: 0, False: 2.18k] ------------------ 34411| 2.18k| width, height, stride2, inv_h2, inv_v2))) { 34412| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34413| 0| } 34414| 2.18k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (34414:7): [True: 528, False: 1.65k] | Branch (34414:21): [True: 0, False: 1.65k] ------------------ 34415| 528| if (((h3 * inv_h3) != max_incl_h) || // ------------------ | Branch (34415:9): [True: 0, False: 528] ------------------ 34416| 528| ((v3 * inv_v3) != max_incl_v) || // ------------------ | Branch (34416:9): [True: 0, False: 528] ------------------ 34417| 528| (src3.len < wuffs_private_impl__swizzle_flattened_length( ------------------ | Branch (34417:9): [True: 528, False: 0] ------------------ 34418| 528| width, height, stride3, inv_h3, inv_v3))) { 34419| 528| return wuffs_base__make_status(wuffs_base__error__bad_argument); 34420| 528| } 34421| 528| } 34422| | 34423| 1.65k| if (wuffs_base__pixel_format__is_planar(&dst->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (34423:7): [True: 0, False: 1.65k] ------------------ 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.65k| switch (dst->pixcfg.private_impl.pixfmt.repr) { 34479| 144| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 144|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (34479:5): [True: 144, False: 1.50k] ------------------ 34480| 179| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 179|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (34480:5): [True: 35, False: 1.61k] ------------------ 34481| 209| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 209|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (34481:5): [True: 30, False: 1.62k] ------------------ 34482| 269| case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: ------------------ | | 4946| 269|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000088 ------------------ | Branch (34482:5): [True: 60, False: 1.59k] ------------------ 34483| 337| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 337|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (34483:5): [True: 68, False: 1.58k] ------------------ 34484| 337| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: ------------------ | | 4959| 337|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 ------------------ | Branch (34484:5): [True: 0, False: 1.65k] ------------------ 34485| 377| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: ------------------ | | 4960| 377|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 ------------------ | Branch (34485:5): [True: 40, False: 1.61k] ------------------ 34486| 508| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 508|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (34486:5): [True: 131, False: 1.52k] ------------------ 34487| 626| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 626|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (34487:5): [True: 118, False: 1.53k] ------------------ 34488| 785| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 785|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (34488:5): [True: 159, False: 1.49k] ------------------ 34489| 1.00k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 1.00k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (34489:5): [True: 218, False: 1.43k] ------------------ 34490| 1.11k| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 1.11k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (34490:5): [True: 114, False: 1.53k] ------------------ 34491| 1.20k| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 1.20k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (34491:5): [True: 83, False: 1.57k] ------------------ 34492| 1.30k| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 1.30k|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (34492:5): [True: 101, False: 1.55k] ------------------ 34493| 1.48k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 1.48k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (34493:5): [True: 186, False: 1.46k] ------------------ 34494| 1.63k| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 1.63k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (34494:5): [True: 147, False: 1.50k] ------------------ 34495| 1.63k| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 1.63k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (34495:5): [True: 0, False: 1.65k] ------------------ 34496| 1.63k| break; 34497| | 34498| 19| default: ------------------ | Branch (34498:5): [True: 19, False: 1.63k] ------------------ 34499| | // TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's 34500| | // TODO. 34501| 19| return wuffs_base__make_status( 34502| 19| wuffs_base__error__unsupported_pixel_swizzler_option); 34503| 1.65k| } 34504| 1.63k|#endif // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) 34505| | 34506| | // ---- 34507| | 34508| 1.63k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; 34509| | 34510| 1.63k| if (ycc_model >= WUFFS_BASE__YCC_MODEL__RGB) { ------------------ | | 5257| 1.63k|#define WUFFS_BASE__YCC_MODEL__RGB 0x40 ------------------ | Branch (34510:7): [True: 359, False: 1.27k] ------------------ 34511| 359| conv3func = &wuffs_private_impl__swizzle_rgb__convert_3_general; 34512| | 34513| 1.27k| } else if (ycc_model >= WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) { ------------------ | | 5254| 1.27k|#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE 0x04 ------------------ | Branch (34513:14): [True: 0, False: 1.27k] ------------------ 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.27k| } else { 34531| 1.27k| switch (dst->pixcfg.private_impl.pixfmt.repr) { 34532| 134| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 134|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (34532:7): [True: 134, False: 1.14k] ------------------ 34533| 227| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 227|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (34533:7): [True: 93, False: 1.18k] ------------------ 34534| 297| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 297|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (34534:7): [True: 70, False: 1.20k] ------------------ 34535| 297|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 34536| 297| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (34536:13): [True: 297, False: 0] ------------------ 34537| 297| conv3func = 34538| 297| &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx_x86_avx2; 34539| 297| break; 34540| 297| } 34541| 0|#endif 34542| 0| conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx; 34543| 0| break; 34544| 162| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 162|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (34544:7): [True: 162, False: 1.11k] ------------------ 34545| 284| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 284|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (34545:7): [True: 122, False: 1.15k] ------------------ 34546| 284| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 284|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (34546:7): [True: 0, False: 1.27k] ------------------ 34547| 284|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) 34548| 284| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (34548:13): [True: 284, False: 0] ------------------ 34549| 284| conv3func = 34550| 284| &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx_x86_avx2; 34551| 284| break; 34552| 284| } 34553| 0|#endif 34554| 0| conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx; 34555| 0| break; 34556| 694| default: ------------------ | Branch (34556:7): [True: 694, False: 581] ------------------ 34557| 694| conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general; 34558| 694| break; 34559| 1.27k| } 34560| 1.27k| } 34561| | 34562| 1.63k| void (*func3)(wuffs_base__pixel_buffer * dst, // 34563| 1.63k| uint32_t x_min_incl, // 34564| 1.63k| uint32_t x_max_excl, // 34565| 1.63k| uint32_t y_min_incl, // 34566| 1.63k| uint32_t y_max_excl, // 34567| 1.63k| const uint8_t* src_ptr0, // 34568| 1.63k| const uint8_t* src_ptr1, // 34569| 1.63k| const uint8_t* src_ptr2, // 34570| 1.63k| uint32_t stride0, // 34571| 1.63k| uint32_t stride1, // 34572| 1.63k| uint32_t stride2, // 34573| 1.63k| uint32_t inv_h0, // 34574| 1.63k| uint32_t inv_h1, // 34575| 1.63k| uint32_t inv_h2, // 34576| 1.63k| uint32_t inv_v0, // 34577| 1.63k| uint32_t inv_v1, // 34578| 1.63k| uint32_t inv_v2, // 34579| 1.63k| uint32_t half_width_for_2to1, // 34580| 1.63k| uint32_t half_height_for_2to1, // 34581| 1.63k| uint8_t* scratch_buffer_2k_ptr, // 34582| 1.63k| wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], 34583| 1.63k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) = 34584| 1.63k| &wuffs_private_impl__swizzle_ycc__general__box_filter; 34585| | 34586| 1.63k| void (*func4)(wuffs_base__pixel_buffer * dst, // 34587| 1.63k| uint32_t x_min_incl, // 34588| 1.63k| uint32_t x_max_excl, // 34589| 1.63k| uint32_t y_min_incl, // 34590| 1.63k| uint32_t y_max_excl, // 34591| 1.63k| const uint8_t* src_ptr0, // 34592| 1.63k| const uint8_t* src_ptr1, // 34593| 1.63k| const uint8_t* src_ptr2, // 34594| 1.63k| const uint8_t* src_ptr3, // 34595| 1.63k| uint32_t stride0, // 34596| 1.63k| uint32_t stride1, // 34597| 1.63k| uint32_t stride2, // 34598| 1.63k| uint32_t stride3, // 34599| 1.63k| uint32_t inv_h0, // 34600| 1.63k| uint32_t inv_h1, // 34601| 1.63k| uint32_t inv_h2, // 34602| 1.63k| uint32_t inv_h3, // 34603| 1.63k| uint32_t inv_v0, // 34604| 1.63k| uint32_t inv_v1, // 34605| 1.63k| uint32_t inv_v2, // 34606| 1.63k| uint32_t inv_v3, // 34607| 1.63k| uint32_t half_width_for_2to1, // 34608| 1.63k| uint32_t half_height_for_2to1, // 34609| 1.63k| uint8_t* scratch_buffer_2k_ptr, // 34610| 1.63k| wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], 34611| 1.63k| wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) = 34612| 1.63k| &wuffs_private_impl__swizzle_ycck__general__box_filter; 34613| | 34614| 1.63k| wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4]; 34615| 1.63k| memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs, 34616| 1.63k| sizeof upfuncs); 34617| | 34618| 1.63k| if ((ycc_upsampling != 0) && ------------------ | Branch (34618:7): [True: 831, False: 803] ------------------ 34619| 831| (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) || ------------------ | Branch (34619:8): [True: 220, False: 611] ------------------ 34620| 611| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) || ------------------ | Branch (34620:8): [True: 83, False: 528] ------------------ 34621| 528| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) || ------------------ | Branch (34621:8): [True: 67, False: 461] ------------------ 34622| 461| wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h3, inv_v3))) { ------------------ | Branch (34622:8): [True: 0, False: 461] ------------------ 34623| 370| func3 = &wuffs_private_impl__swizzle_ycc__general__triangle_filter; 34624| 370| func4 = &wuffs_private_impl__swizzle_ycck__general__triangle_filter; 34625| | 34626| 370| upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle; 34627| 370| upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle; 34628| 370| upfuncs[1][1] = 34629| 370| (ycc_upsampling == 1) ------------------ | Branch (34629:9): [True: 370, False: 0] ------------------ 34630| 370| ? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg 34631| 370| : wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp; 34632| | 34633| 370|#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| 370| if (wuffs_base__cpu_arch__have_x86_avx2()) { ------------------ | Branch (34647:9): [True: 370, False: 0] ------------------ 34648| 370| upfuncs[1][1] = 34649| 370| (ycc_upsampling == 1) ------------------ | Branch (34649:11): [True: 370, False: 0] ------------------ 34650| 370| ? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2 34651| 370| : wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp_x86_avx2; 34652| 370| } 34653| 370|#endif 34654| 370|#endif 34655| 370| } 34656| | 34657| 1.63k| if ((h3 != 0u) || (v3 != 0u)) { ------------------ | Branch (34657:7): [True: 0, False: 1.63k] | Branch (34657:21): [True: 0, False: 1.63k] ------------------ 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.63k| } else { 34701| 1.63k| (*func3)( // 34702| 1.63k| dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // 34703| 1.63k| src0.ptr, src1.ptr, src2.ptr, // 34704| 1.63k| stride0, stride1, stride2, // 34705| 1.63k| inv_h0, inv_h1, inv_h2, // 34706| 1.63k| inv_v0, inv_v1, inv_v2, // 34707| 1.63k| half_width_for_2to1, half_height_for_2to1, // 34708| 1.63k| scratch_buffer_2k.ptr, &upfuncs, conv3func); 34709| 1.63k| } 34710| | 34711| 1.63k| return wuffs_base__make_status(NULL); 34712| 1.63k|} pixel_swizzler_fuzzer.c:wuffs_base__make_status: 624| 507k|wuffs_base__make_status(const char* repr) { 625| 507k| wuffs_base__status z; 626| 507k| z.repr = repr; 627| 507k| return z; 628| 507k|} pixel_swizzler_fuzzer.c:wuffs_base__u32__min: 1057| 30.7k|wuffs_base__u32__min(uint32_t x, uint32_t y) { 1058| 30.7k| return x < y ? x : y; ------------------ | Branch (1058:10): [True: 16.4k, False: 14.3k] ------------------ 1059| 30.7k|} pixel_swizzler_fuzzer.c:wuffs_base__make_slice_u8: 1721| 88.9k|wuffs_base__make_slice_u8(uint8_t* ptr, size_t len) { 1722| 88.9k| wuffs_base__slice_u8 ret; 1723| 88.9k| ret.ptr = ptr; 1724| 88.9k| ret.len = len; 1725| 88.9k| return ret; 1726| 88.9k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u32le__no_bounds_check: 1441| 60.1k|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.1k| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | 1448| 60.1k| ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); 1449| 60.1k|#endif 1450| 60.1k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u24le__no_bounds_check: 1423| 993|wuffs_base__peek_u24le__no_bounds_check(const uint8_t* p) { 1424| 993| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | 1425| 993| ((uint32_t)(p[2]) << 16); 1426| 993|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u16le__no_bounds_check: 1406| 9.48k|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| 9.48k| return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); 1413| 9.48k|#endif 1414| 9.48k|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u24be__no_bounds_check: 1417| 452|wuffs_base__peek_u24be__no_bounds_check(const uint8_t* p) { 1418| 452| return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) | 1419| 452| ((uint32_t)(p[2]) << 0); 1420| 452|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u16be__no_bounds_check: 1395| 53|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| 53| return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); 1402| 53|#endif 1403| 53|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_planar: 5031| 505k|wuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) { 5032| 505k| return ((f->repr >> 16) & 0x03) != 0; 5033| 505k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul: 4485| 16.4k| 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| 16.4k| uint32_t a = 0xFF & (argb_nonpremul >> 24); 4496| 16.4k| uint32_t a16 = a * (0x101 * 0x101); 4497| | 4498| 16.4k| uint32_t r = 0xFF & (argb_nonpremul >> 16); 4499| 16.4k| r = ((r * a16) / 0xFFFF) >> 8; 4500| 16.4k| uint32_t g = 0xFF & (argb_nonpremul >> 8); 4501| 16.4k| g = ((g * a16) / 0xFFFF) >> 8; 4502| 16.4k| uint32_t b = 0xFF & (argb_nonpremul >> 0); 4503| 16.4k| b = ((b * a16) / 0xFFFF) >> 8; 4504| | 4505| 16.4k| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4506| 16.4k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul: 4417| 2.96k|wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(uint16_t rgb_565) { 4418| 2.96k| uint32_t b5 = 0x1F & (rgb_565 >> 0); 4419| 2.96k| uint32_t b = (b5 << 3) | (b5 >> 2); 4420| 2.96k| uint32_t g6 = 0x3F & (rgb_565 >> 5); 4421| 2.96k| uint32_t g = (g6 << 2) | (g6 >> 4); 4422| 2.96k| uint32_t r5 = 0x1F & (rgb_565 >> 11); 4423| 2.96k| uint32_t r = (r5 << 3) | (r5 >> 2); 4424| 2.96k| return 0xFF000000 | (r << 16) | (g << 8) | (b << 0); 4425| 2.96k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul: 4535| 626| uint64_t argb_nonpremul) { 4536| 626| uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); 4537| | 4538| 626| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); 4539| 626| r16 = (r16 * a16) / 0xFFFF; 4540| 626| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); 4541| 626| g16 = (g16 * a16) / 0xFFFF; 4542| 626| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); 4543| 626| b16 = (b16 * a16) / 0xFFFF; 4544| | 4545| 626| return ((a16 >> 8) << 24) | ((r16 >> 8) << 16) | ((g16 >> 8) << 8) | 4546| 626| ((b16 >> 8) << 0); 4547| 626|} pixel_swizzler_fuzzer.c:wuffs_base__peek_u64le__no_bounds_check: 1511| 6.04k|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| 6.04k| return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | 1518| 6.04k| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | 1519| 6.04k| ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | 1520| 6.04k| ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56); 1521| 6.04k|#endif 1522| 6.04k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64__as__color_u32: 4660| 2.46k|wuffs_base__color_u64__as__color_u32(uint64_t c) { 4661| 2.46k| uint32_t a = ((uint32_t)(0xFF & (c >> 56))); 4662| 2.46k| uint32_t r = ((uint32_t)(0xFF & (c >> 40))); 4663| 2.46k| uint32_t g = ((uint32_t)(0xFF & (c >> 24))); 4664| 2.46k| uint32_t b = ((uint32_t)(0xFF & (c >> 8))); 4665| 2.46k| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4666| 2.46k|} pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u32_argb_abgr: 4829| 94.4k|wuffs_base__color_swap_u32_argb_abgr(uint32_t u) { 4830| 94.4k| uint32_t o = u & 0xFF00FF00ul; 4831| 94.4k| uint32_t r = u & 0x00FF0000ul; 4832| 94.4k| uint32_t b = u & 0x000000FFul; 4833| 94.4k| return o | (r >> 16) | (b << 16); 4834| 94.4k|} 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| 110k|wuffs_base__poke_u8__no_bounds_check(uint8_t* p, uint8_t x) { 1533| 110k| p[0] = x; 1534| 110k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u8_gray: 4429| 75.3k| wuffs_base__color_u32_argb_premul c) { 4430| | // Work in 16-bit color. 4431| 75.3k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 4432| 75.3k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 4433| 75.3k| 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| 75.3k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4442| 75.3k| return (uint8_t)(weighted_average >> 24); 4443| 75.3k|} 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| 26.7k| wuffs_base__color_u32_argb_premul c) { 4468| | // Work in 16-bit color. 4469| 26.7k| uint32_t cr = 0x101 * (0xFF & (c >> 16)); 4470| 26.7k| uint32_t cg = 0x101 * (0xFF & (c >> 8)); 4471| 26.7k| 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| 26.7k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4478| 26.7k| return (uint16_t)(weighted_average >> 16); 4479| 26.7k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u16be__no_bounds_check: 1537| 9.01k|wuffs_base__poke_u16be__no_bounds_check(uint8_t* p, uint16_t x) { 1538| 9.01k| p[0] = (uint8_t)(x >> 8); 1539| 9.01k| p[1] = (uint8_t)(x >> 0); 1540| 9.01k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul: 4447| 27.2k| wuffs_base__color_u32_argb_premul c) { 4448| 27.2k| uint32_t a = 0xFF & (c >> 24); 4449| 27.2k| if (a == 0) { ------------------ | Branch (4449:7): [True: 0, False: 27.2k] ------------------ 4450| 0| return 0; 4451| 0| } 4452| 27.2k| uint32_t a16 = a * 0x101; 4453| | 4454| 27.2k| uint32_t cr = 0xFF & (c >> 16); 4455| 27.2k| cr = (cr * (0x101 * 0xFFFF)) / a16; 4456| 27.2k| uint32_t cg = 0xFF & (c >> 8); 4457| 27.2k| cg = (cg * (0x101 * 0xFFFF)) / a16; 4458| 27.2k| uint32_t cb = 0xFF & (c >> 0); 4459| 27.2k| cb = (cb * (0x101 * 0xFFFF)) / a16; 4460| | 4461| 27.2k| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; 4462| 27.2k| return (uint16_t)((a16 & 0xFF00) | (weighted_average >> 24)); 4463| 27.2k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__palette: 6048| 54.7k|wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) { 6049| 54.7k| if (pb && ------------------ | Branch (6049:7): [True: 54.7k, False: 0] ------------------ 6050| 54.7k| wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) { ------------------ | Branch (6050:7): [True: 54.7k, False: 0] ------------------ 6051| 54.7k| wuffs_base__table_u8* tab = 6052| 54.7k| &pb->private_impl 6053| 54.7k| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; ------------------ | | 4897| 54.7k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3 ------------------ 6054| 54.7k| if ((tab->width == ------------------ | Branch (6054:9): [True: 54.7k, False: 0] ------------------ 6055| 54.7k| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) && ------------------ | | 4900| 54.7k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6056| 54.7k| (tab->height == 1)) { ------------------ | Branch (6056:9): [True: 54.7k, False: 0] ------------------ 6057| 54.7k| return wuffs_base__make_slice_u8( 6058| 54.7k| tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH); ------------------ | | 4900| 54.7k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6059| 54.7k| } 6060| 54.7k| } 6061| 0| return wuffs_base__empty_slice_u8(); 6062| 54.7k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_indexed: 5021| 61.5k|wuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) { 5022| 61.5k| return ((f->repr >> 18) & 0x01) != 0; 5023| 61.5k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565: 4409| 59.2k| wuffs_base__color_u32_argb_premul c) { 4410| 59.2k| uint32_t r5 = 0xF800 & (c >> 8); 4411| 59.2k| uint32_t g6 = 0x07E0 & (c >> 5); 4412| 59.2k| uint32_t b5 = 0x001F & (c >> 3); 4413| 59.2k| return (uint16_t)(r5 | g6 | b5); 4414| 59.2k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u24le__no_bounds_check: 1563| 120k|wuffs_base__poke_u24le__no_bounds_check(uint8_t* p, uint32_t x) { 1564| 120k| p[0] = (uint8_t)(x >> 0); 1565| 120k| p[1] = (uint8_t)(x >> 8); 1566| 120k| p[2] = (uint8_t)(x >> 16); 1567| 120k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul: 4512| 38.9k| wuffs_base__color_u32_argb_premul c) { 4513| 38.9k| uint32_t a = 0xFF & (c >> 24); 4514| 38.9k| if (a == 0xFF) { ------------------ | Branch (4514:7): [True: 37.8k, False: 1.03k] ------------------ 4515| 37.8k| return c; 4516| 37.8k| } else if (a == 0) { ------------------ | Branch (4516:14): [True: 203, False: 827] ------------------ 4517| 203| return 0; 4518| 203| } 4519| 827| uint32_t a16 = a * 0x101; 4520| | 4521| 827| uint32_t r = 0xFF & (c >> 16); 4522| 827| r = ((r * (0x101 * 0xFFFF)) / a16) >> 8; 4523| 827| uint32_t g = 0xFF & (c >> 8); 4524| 827| g = ((g * (0x101 * 0xFFFF)) / a16) >> 8; 4525| 827| uint32_t b = 0xFF & (c >> 0); 4526| 827| b = ((b * (0x101 * 0xFFFF)) / a16) >> 8; 4527| | 4528| 827| return (a << 24) | (r << 16) | (g << 8) | (b << 0); 4529| 38.9k|} pixel_swizzler_fuzzer.c:wuffs_base__poke_u64le__no_bounds_check: 1665| 80.1k|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| 80.1k| p[0] = (uint8_t)(x >> 0); 1673| 80.1k| p[1] = (uint8_t)(x >> 8); 1674| 80.1k| p[2] = (uint8_t)(x >> 16); 1675| 80.1k| p[3] = (uint8_t)(x >> 24); 1676| 80.1k| p[4] = (uint8_t)(x >> 32); 1677| 80.1k| p[5] = (uint8_t)(x >> 40); 1678| 80.1k| p[6] = (uint8_t)(x >> 48); 1679| 80.1k| p[7] = (uint8_t)(x >> 56); 1680| 80.1k|#endif 1681| 80.1k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul: 4553| 76.7k| wuffs_base__color_u32_argb_premul c) { 4554| 76.7k| uint32_t a = 0xFF & (c >> 24); 4555| 76.7k| if (a == 0xFF) { ------------------ | Branch (4555:7): [True: 76.7k, False: 0] ------------------ 4556| 76.7k| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); 4557| 76.7k| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); 4558| 76.7k| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); 4559| 76.7k| return 0xFFFF000000000000u | (r16 << 32) | (g16 << 16) | (b16 << 0); 4560| 76.7k| } 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| 76.7k|} pixel_swizzler_fuzzer.c:wuffs_base__color_u32__as__color_u64: 4651| 3.43k|wuffs_base__color_u32__as__color_u64(uint32_t c) { 4652| 3.43k| uint64_t a16 = 0x101 * (0xFF & (c >> 24)); 4653| 3.43k| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); 4654| 3.43k| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); 4655| 3.43k| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); 4656| 3.43k| return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); 4657| 3.43k|} 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| 143| wuffs_base__pixel_blend blend) { 31167| 143| switch (dst_pixfmt.repr) { ------------------ | Branch (31167:11): [True: 130, False: 13] ------------------ 31168| 19| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 19|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31168:5): [True: 19, False: 124] ------------------ 31169| 19| return wuffs_private_impl__swizzle_copy_1_1; 31170| | 31171| 16| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31171:5): [True: 16, False: 127] ------------------ 31172| 16| 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: 130] ------------------ 31175| 23| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 23|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31175:5): [True: 10, False: 133] ------------------ 31176| 23| 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: 136] ------------------ 31179| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31179:5): [True: 5, False: 138] ------------------ 31180| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31180:5): [True: 0, False: 143] ------------------ 31181| 25| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31181:5): [True: 13, False: 130] ------------------ 31182| 37| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 37|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31182:5): [True: 12, False: 131] ------------------ 31183| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31183:5): [True: 10, False: 133] ------------------ 31184| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31184:5): [True: 0, False: 143] ------------------ 31185| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31185:5): [True: 0, False: 143] ------------------ 31186| 47|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31187| 47| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31187:11): [True: 47, False: 0] ------------------ 31188| 47| return wuffs_private_impl__swizzle_xxxx__y__x86_sse42; 31189| 47| } 31190| 0|#endif 31191| 0| return wuffs_private_impl__swizzle_xxxx__y; 31192| | 31193| 23| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 23|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31193:5): [True: 23, False: 120] ------------------ 31194| 25| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31194:5): [True: 2, False: 141] ------------------ 31195| 25| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 25|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31195:5): [True: 0, False: 143] ------------------ 31196| 25| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4975| 25|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (31196:5): [True: 0, False: 143] ------------------ 31197| 25| return wuffs_private_impl__swizzle_xxxxxxxx__y; 31198| 143| } 31199| 13| return NULL; 31200| 143|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_1_1: 25929| 33| size_t src_len) { 25930| 33| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (25930:16): [True: 15, False: 18] ------------------ 25931| 33| if (len > 0) { ------------------ | Branch (25931:7): [True: 11, False: 22] ------------------ 25932| 11| memmove(dst_ptr, src_ptr, len); 25933| 11| } 25934| 33| return len; 25935| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y: 26627| 16| size_t src_len) { 26628| 16| size_t dst_len2 = dst_len / 2; 26629| 16| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26629:16): [True: 7, False: 9] ------------------ 26630| 16| uint8_t* d = dst_ptr; 26631| 16| const uint8_t* s = src_ptr; 26632| 16| size_t n = len; 26633| | 26634| | // TODO: unroll. 26635| | 26636| 678| while (n >= 1) { ------------------ | Branch (26636:10): [True: 662, False: 16] ------------------ 26637| 662| uint32_t y5 = (uint32_t)(s[0] >> 3); 26638| 662| uint32_t y6 = (uint32_t)(s[0] >> 2); 26639| 662| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 26640| 662| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26641| | 26642| 662| s += 1 * 1; 26643| 662| d += 1 * 2; 26644| 662| n -= 1; 26645| 662| } 26646| | 26647| 16| return len; 26648| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y: 29807| 23| size_t src_len) { 29808| 23| size_t dst_len3 = dst_len / 3; 29809| 23| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29809:16): [True: 14, False: 9] ------------------ 29810| 23| uint8_t* d = dst_ptr; 29811| 23| const uint8_t* s = src_ptr; 29812| 23| size_t n = len; 29813| | 29814| | // TODO: unroll. 29815| | 29816| 402| while (n >= 1) { ------------------ | Branch (29816:10): [True: 379, False: 23] ------------------ 29817| 379| uint8_t s0 = s[0]; 29818| 379| d[0] = s0; 29819| 379| d[1] = s0; 29820| 379| d[2] = s0; 29821| | 29822| 379| s += 1 * 1; 29823| 379| d += 1 * 3; 29824| 379| n -= 1; 29825| 379| } 29826| | 29827| 23| return len; 29828| 23|} pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_sse42: 375| 159|wuffs_base__cpu_arch__have_x86_sse42(void) { 376| |#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) 377| | return true; 378| |#else 379| 159|#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| 159| const unsigned int sse42_ecx1 = 0x00900002; 385| | 386| | // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). 387| 159|#if defined(__GNUC__) 388| 159| unsigned int eax1 = 0; 389| 159| unsigned int ebx1 = 0; 390| 159| unsigned int ecx1 = 0; 391| 159| unsigned int edx1 = 0; 392| 159| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && ------------------ | Branch (392:7): [True: 159, False: 0] ------------------ 393| 159| ((ecx1 & sse42_ecx1) == sse42_ecx1)) { ------------------ | Branch (393:7): [True: 159, False: 0] ------------------ 394| 159| return true; 395| 159| } 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| 159|#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) 408| 159|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y__x86_sse42: 30077| 47| size_t src_len) { 30078| 47| size_t dst_len4 = dst_len / 4; 30079| 47| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (30079:16): [True: 30, False: 17] ------------------ 30080| 47| uint8_t* d = dst_ptr; 30081| 47| const uint8_t* s = src_ptr; 30082| 47| size_t n = len; 30083| | 30084| 47| __m128i shuffle = _mm_set_epi8(+0x03, +0x03, +0x03, +0x03, // 30085| 47| +0x02, +0x02, +0x02, +0x02, // 30086| 47| +0x01, +0x01, +0x01, +0x01, // 30087| 47| +0x00, +0x00, +0x00, +0x00); 30088| 47| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 30089| 47| -0x01, +0x00, +0x00, +0x00, // 30090| 47| -0x01, +0x00, +0x00, +0x00, // 30091| 47| -0x01, +0x00, +0x00, +0x00); 30092| | 30093| 197| while (n >= 4) { ------------------ | Branch (30093:10): [True: 150, False: 47] ------------------ 30094| 150| __m128i x; 30095| 150| x = _mm_cvtsi32_si128((int)(wuffs_base__peek_u32le__no_bounds_check(s))); 30096| 150| x = _mm_shuffle_epi8(x, shuffle); 30097| 150| x = _mm_or_si128(x, or_ff); 30098| 150| _mm_storeu_si128((__m128i*)(void*)d, x); 30099| | 30100| 150| s += 4 * 1; 30101| 150| d += 4 * 4; 30102| 150| n -= 4; 30103| 150| } 30104| | 30105| 91| while (n >= 1) { ------------------ | Branch (30105:10): [True: 44, False: 47] ------------------ 30106| 44| wuffs_base__poke_u32le__no_bounds_check( 30107| 44| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); 30108| | 30109| 44| s += 1 * 1; 30110| 44| d += 1 * 4; 30111| 44| n -= 1; 30112| 44| } 30113| | 30114| 47| return len; 30115| 47|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y: 30269| 25| size_t src_len) { 30270| 25| size_t dst_len8 = dst_len / 8; 30271| 25| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (30271:16): [True: 18, False: 7] ------------------ 30272| 25| uint8_t* d = dst_ptr; 30273| 25| const uint8_t* s = src_ptr; 30274| 25| size_t n = len; 30275| | 30276| 290| while (n >= 1) { ------------------ | Branch (30276:10): [True: 265, False: 25] ------------------ 30277| 265| wuffs_base__poke_u64le__no_bounds_check( 30278| 265| d + (0 * 8), 0xFFFF000000000000 | (0x010101010101 * (uint64_t)s[0])); 30279| | 30280| 265| s += 1 * 1; 30281| 265| d += 1 * 8; 30282| 265| n -= 1; 30283| 265| } 30284| | 30285| 25| return len; 30286| 25|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16be: 31208| 121| wuffs_base__pixel_blend blend) { 31209| 121| switch (dst_pixfmt.repr) { ------------------ | Branch (31209:11): [True: 109, 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: 100] ------------------ 31211| 21| return wuffs_private_impl__swizzle_y__y_16be; 31212| | 31213| 3| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 3|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (31213:5): [True: 3, False: 118] ------------------ 31214| 3| return wuffs_private_impl__swizzle_y_16le__y_16be; 31215| | 31216| 2| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 2|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (31216:5): [True: 2, False: 119] ------------------ 31217| 2| return wuffs_private_impl__swizzle_copy_2_2; 31218| | 31219| 20| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31219:5): [True: 20, False: 101] ------------------ 31220| 20| return wuffs_private_impl__swizzle_bgr_565__y_16be; 31221| | 31222| 4| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31222:5): [True: 4, False: 117] ------------------ 31223| 15| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 15|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31223:5): [True: 11, False: 110] ------------------ 31224| 15| return wuffs_private_impl__swizzle_xxx__y_16be; 31225| | 31226| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31226:5): [True: 4, False: 117] ------------------ 31227| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31227:5): [True: 9, False: 112] ------------------ 31228| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31228:5): [True: 0, False: 121] ------------------ 31229| 24| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 24|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31229:5): [True: 11, False: 110] ------------------ 31230| 34| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 34|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31230:5): [True: 10, False: 111] ------------------ 31231| 38| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 38|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31231:5): [True: 4, False: 117] ------------------ 31232| 38| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 38|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31232:5): [True: 0, False: 121] ------------------ 31233| 38| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 38|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31233:5): [True: 0, False: 121] ------------------ 31234| 38| return wuffs_private_impl__swizzle_xxxx__y_16be; 31235| | 31236| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31236:5): [True: 6, False: 115] ------------------ 31237| 10| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31237:5): [True: 4, False: 117] ------------------ 31238| 10| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 10|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31238:5): [True: 0, False: 121] ------------------ 31239| 10| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4975| 10|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (31239:5): [True: 0, False: 121] ------------------ 31240| 10| return wuffs_private_impl__swizzle_xxxxxxxx__y_16be; 31241| 121| } 31242| 12| return NULL; 31243| 121|} 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: 4, False: 17] ------------------ 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.06k| while (n >= 1) { ------------------ | Branch (30872:10): [True: 1.04k, False: 21] ------------------ 30873| 1.04k| d[0] = s[0]; 30874| | 30875| 1.04k| s += 1 * 2; 30876| 1.04k| d += 1 * 1; 30877| 1.04k| n -= 1; 30878| 1.04k| } 30879| | 30880| 21| return len; 30881| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y_16le__y_16be: 31071| 23| size_t src_len) { 31072| 23| size_t dst_len2 = dst_len / 2; 31073| 23| size_t src_len2 = src_len / 2; 31074| 23| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (31074:16): [True: 6, False: 17] ------------------ 31075| 23| uint8_t* d = dst_ptr; 31076| 23| const uint8_t* s = src_ptr; 31077| 23| size_t n = len; 31078| | 31079| 857| while (n >= 1) { ------------------ | Branch (31079:10): [True: 834, False: 23] ------------------ 31080| 834| uint8_t s0 = s[0]; 31081| 834| uint8_t s1 = s[1]; 31082| 834| d[0] = s1; 31083| 834| d[1] = s0; 31084| | 31085| 834| s += 1 * 2; 31086| 834| d += 1 * 2; 31087| 834| n -= 1; 31088| 834| } 31089| | 31090| 23| return len; 31091| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_2_2: 25943| 17| size_t src_len) { 25944| 17| size_t dst_len2 = dst_len / 2; 25945| 17| size_t src_len2 = src_len / 2; 25946| 17| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (25946:16): [True: 3, False: 14] ------------------ 25947| 17| if (len > 0) { ------------------ | Branch (25947:7): [True: 13, False: 4] ------------------ 25948| 13| memmove(dst_ptr, src_ptr, len * 2); 25949| 13| } 25950| 17| return len; 25951| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16be: 26656| 20| size_t src_len) { 26657| 20| size_t dst_len2 = dst_len / 2; 26658| 20| size_t src_len2 = src_len / 2; 26659| 20| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26659:16): [True: 5, False: 15] ------------------ 26660| 20| uint8_t* d = dst_ptr; 26661| 20| const uint8_t* s = src_ptr; 26662| 20| size_t n = len; 26663| | 26664| | // TODO: unroll. 26665| | 26666| 864| while (n >= 1) { ------------------ | Branch (26666:10): [True: 844, False: 20] ------------------ 26667| 844| uint32_t y5 = (uint32_t)(s[0] >> 3); 26668| 844| uint32_t y6 = (uint32_t)(s[0] >> 2); 26669| 844| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 26670| 844| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26671| | 26672| 844| s += 1 * 2; 26673| 844| d += 1 * 2; 26674| 844| n -= 1; 26675| 844| } 26676| | 26677| 20| return len; 26678| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16be: 29836| 15| size_t src_len) { 29837| 15| size_t dst_len3 = dst_len / 3; 29838| 15| size_t src_len2 = src_len / 2; 29839| 15| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29839:16): [True: 5, False: 10] ------------------ 29840| 15| uint8_t* d = dst_ptr; 29841| 15| const uint8_t* s = src_ptr; 29842| 15| size_t n = len; 29843| | 29844| | // TODO: unroll. 29845| | 29846| 383| while (n >= 1) { ------------------ | Branch (29846:10): [True: 368, False: 15] ------------------ 29847| 368| uint8_t s0 = s[0]; 29848| 368| d[0] = s0; 29849| 368| d[1] = s0; 29850| 368| d[2] = s0; 29851| | 29852| 368| s += 1 * 2; 29853| 368| d += 1 * 3; 29854| 368| n -= 1; 29855| 368| } 29856| | 29857| 15| return len; 29858| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y_16be: 30150| 38| size_t src_len) { 30151| 38| size_t dst_len4 = dst_len / 4; 30152| 38| size_t src_len2 = src_len / 2; 30153| 38| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (30153:16): [True: 11, False: 27] ------------------ 30154| 38| uint8_t* d = dst_ptr; 30155| 38| const uint8_t* s = src_ptr; 30156| 38| size_t n = len; 30157| | 30158| 695| while (n >= 1) { ------------------ | Branch (30158:10): [True: 657, False: 38] ------------------ 30159| 657| wuffs_base__poke_u32le__no_bounds_check( 30160| 657| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); 30161| | 30162| 657| s += 1 * 2; 30163| 657| d += 1 * 4; 30164| 657| n -= 1; 30165| 657| } 30166| | 30167| 38| return len; 30168| 38|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16be: 30294| 10| size_t src_len) { 30295| 10| size_t dst_len8 = dst_len / 8; 30296| 10| size_t src_len2 = src_len / 2; 30297| 10| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (30297:16): [True: 6, False: 4] ------------------ 30298| 10| uint8_t* d = dst_ptr; 30299| 10| const uint8_t* s = src_ptr; 30300| 10| size_t n = len; 30301| | 30302| 63| while (n >= 1) { ------------------ | Branch (30302:10): [True: 53, False: 10] ------------------ 30303| 53| uint64_t s0 = 30304| 53| ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(s + (0 * 2)))); 30305| 53| wuffs_base__poke_u64le__no_bounds_check( 30306| 53| d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0)); 30307| | 30308| 53| s += 1 * 2; 30309| 53| d += 1 * 8; 30310| 53| n -= 1; 30311| 53| } 30312| | 30313| 10| return len; 30314| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16le: 31251| 139| wuffs_base__pixel_blend blend) { 31252| 139| switch (dst_pixfmt.repr) { ------------------ | Branch (31252:11): [True: 131, False: 8] ------------------ 31253| 18| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 18|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31253:5): [True: 18, False: 121] ------------------ 31254| 18| return wuffs_private_impl__swizzle_y__y_16le; 31255| | 31256| 6| case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: ------------------ | | 4944| 6|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B ------------------ | Branch (31256:5): [True: 6, False: 133] ------------------ 31257| 6| return wuffs_private_impl__swizzle_copy_2_2; 31258| | 31259| 20| case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: ------------------ | | 4945| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B ------------------ | Branch (31259:5): [True: 20, False: 119] ------------------ 31260| 20| return wuffs_private_impl__swizzle_y_16le__y_16be; 31261| | 31262| 20| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31262:5): [True: 20, False: 119] ------------------ 31263| 20| return wuffs_private_impl__swizzle_bgr_565__y_16le; 31264| | 31265| 6| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31265:5): [True: 6, False: 133] ------------------ 31266| 14| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 14|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31266:5): [True: 8, False: 131] ------------------ 31267| 14| return wuffs_private_impl__swizzle_xxx__y_16le; 31268| | 31269| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31269:5): [True: 6, False: 133] ------------------ 31270| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31270:5): [True: 3, False: 136] ------------------ 31271| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31271:5): [True: 0, False: 139] ------------------ 31272| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31272:5): [True: 4, False: 135] ------------------ 31273| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31273:5): [True: 8, False: 131] ------------------ 31274| 41| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 41|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31274:5): [True: 20, False: 119] ------------------ 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: 139] ------------------ 31276| 41| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 41|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31276:5): [True: 0, False: 139] ------------------ 31277| 41| return wuffs_private_impl__swizzle_xxxx__y_16le; 31278| | 31279| 10| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31279:5): [True: 10, False: 129] ------------------ 31280| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31280:5): [True: 2, False: 137] ------------------ 31281| 12| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31281:5): [True: 0, False: 139] ------------------ 31282| 12| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE: ------------------ | | 4975| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB ------------------ | Branch (31282:5): [True: 0, False: 139] ------------------ 31283| 12| return wuffs_private_impl__swizzle_xxxxxxxx__y_16le; 31284| 139| } 31285| 8| return NULL; 31286| 139|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__y_16le: 30889| 18| size_t src_len) { 30890| 18| size_t src_len2 = src_len / 2; 30891| 18| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30891:16): [True: 6, False: 12] ------------------ 30892| 18| uint8_t* d = dst_ptr; 30893| 18| const uint8_t* s = src_ptr; 30894| 18| size_t n = len; 30895| | 30896| | // TODO: unroll. 30897| | 30898| 481| while (n >= 1) { ------------------ | Branch (30898:10): [True: 463, False: 18] ------------------ 30899| 463| d[0] = s[1]; 30900| | 30901| 463| s += 1 * 2; 30902| 463| d += 1 * 1; 30903| 463| n -= 1; 30904| 463| } 30905| | 30906| 18| return len; 30907| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16le: 26686| 20| size_t src_len) { 26687| 20| size_t dst_len2 = dst_len / 2; 26688| 20| size_t src_len2 = src_len / 2; 26689| 20| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26689:16): [True: 5, False: 15] ------------------ 26690| 20| uint8_t* d = dst_ptr; 26691| 20| const uint8_t* s = src_ptr; 26692| 20| size_t n = len; 26693| | 26694| | // TODO: unroll. 26695| | 26696| 1.04k| while (n >= 1) { ------------------ | Branch (26696:10): [True: 1.02k, False: 20] ------------------ 26697| 1.02k| uint32_t y5 = (uint32_t)(s[1] >> 3); 26698| 1.02k| uint32_t y6 = (uint32_t)(s[1] >> 2); 26699| 1.02k| uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0); 26700| 1.02k| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26701| | 26702| 1.02k| s += 1 * 2; 26703| 1.02k| d += 1 * 2; 26704| 1.02k| n -= 1; 26705| 1.02k| } 26706| | 26707| 20| return len; 26708| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16le: 29866| 14| size_t src_len) { 29867| 14| size_t dst_len3 = dst_len / 3; 29868| 14| size_t src_len2 = src_len / 2; 29869| 14| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29869:16): [True: 6, False: 8] ------------------ 29870| 14| uint8_t* d = dst_ptr; 29871| 14| const uint8_t* s = src_ptr; 29872| 14| size_t n = len; 29873| | 29874| | // TODO: unroll. 29875| | 29876| 319| while (n >= 1) { ------------------ | Branch (29876:10): [True: 305, False: 14] ------------------ 29877| 305| uint8_t s0 = s[1]; 29878| 305| d[0] = s0; 29879| 305| d[1] = s0; 29880| 305| d[2] = s0; 29881| | 29882| 305| s += 1 * 2; 29883| 305| d += 1 * 3; 29884| 305| n -= 1; 29885| 305| } 29886| | 29887| 14| return len; 29888| 14|} 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: 20, False: 21] ------------------ 30180| 41| uint8_t* d = dst_ptr; 30181| 41| const uint8_t* s = src_ptr; 30182| 41| size_t n = len; 30183| | 30184| 834| while (n >= 1) { ------------------ | Branch (30184:10): [True: 793, False: 41] ------------------ 30185| 793| wuffs_base__poke_u32le__no_bounds_check( 30186| 793| d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[1])); 30187| | 30188| 793| s += 1 * 2; 30189| 793| d += 1 * 4; 30190| 793| n -= 1; 30191| 793| } 30192| | 30193| 41| return len; 30194| 41|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16le: 30322| 12| size_t src_len) { 30323| 12| size_t dst_len8 = dst_len / 8; 30324| 12| size_t src_len2 = src_len / 2; 30325| 12| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (30325:16): [True: 6, False: 6] ------------------ 30326| 12| uint8_t* d = dst_ptr; 30327| 12| const uint8_t* s = src_ptr; 30328| 12| size_t n = len; 30329| | 30330| 96| while (n >= 1) { ------------------ | Branch (30330:10): [True: 84, False: 12] ------------------ 30331| 84| uint64_t s0 = 30332| 84| ((uint64_t)(wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))); 30333| 84| wuffs_base__poke_u64le__no_bounds_check( 30334| 84| d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0)); 30335| | 30336| 84| s += 1 * 2; 30337| 84| d += 1 * 8; 30338| 84| n -= 1; 30339| 84| } 30340| | 30341| 12| return len; 30342| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul: 31294| 283| wuffs_base__pixel_blend blend) { 31295| 283| switch (dst_pixfmt.repr) { ------------------ | Branch (31295:11): [True: 264, False: 19] ------------------ 31296| 33| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 33|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31296:5): [True: 33, False: 250] ------------------ 31297| 33| switch (blend) { ------------------ | Branch (31297:15): [True: 33, False: 0] ------------------ 31298| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31298:9): [True: 18, False: 15] ------------------ 31299| 18| return wuffs_private_impl__swizzle_y__ya_nonpremul__src; 31300| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31300:9): [True: 15, False: 18] ------------------ 31301| 15| return wuffs_private_impl__swizzle_y__ya_nonpremul__src_over; 31302| 33| } 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: 248] ------------------ 31306| 35| switch (blend) { ------------------ | Branch (31306:15): [True: 35, False: 0] ------------------ 31307| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31307:9): [True: 2, False: 33] ------------------ 31308| 2| return wuffs_private_impl__swizzle_copy_2_2; 31309| 33| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 33|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31309:9): [True: 33, False: 2] ------------------ 31310| 33| return wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over; 31311| 35| } 31312| 0| return NULL; 31313| | 31314| 33| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 33|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31314:5): [True: 33, False: 250] ------------------ 31315| 33| switch (blend) { ------------------ | Branch (31315:15): [True: 33, False: 0] ------------------ 31316| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31316:9): [True: 16, False: 17] ------------------ 31317| 16| return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src; 31318| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31318:9): [True: 17, False: 16] ------------------ 31319| 17| return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over; 31320| 33| } 31321| 0| return NULL; 31322| | 31323| 20| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31323:5): [True: 20, False: 263] ------------------ 31324| 31| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 31|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31324:5): [True: 11, False: 272] ------------------ 31325| 31| switch (blend) { ------------------ | Branch (31325:15): [True: 31, False: 0] ------------------ 31326| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31326:9): [True: 16, False: 15] ------------------ 31327| 16| 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: 16] ------------------ 31329| 15| return wuffs_private_impl__swizzle_xxx__ya_nonpremul__src_over; 31330| 31| } 31331| 0| return NULL; 31332| | 31333| 27| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 27|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31333:5): [True: 27, False: 256] ------------------ 31334| 45| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 45|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31334:5): [True: 18, False: 265] ------------------ 31335| 45| switch (blend) { ------------------ | Branch (31335:15): [True: 45, False: 0] ------------------ 31336| 19| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31336:9): [True: 19, False: 26] ------------------ 31337| 19| return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src; 31338| 26| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 26|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31338:9): [True: 26, False: 19] ------------------ 31339| 26| return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over; 31340| 45| } 31341| 0| return NULL; 31342| | 31343| 18| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31343:5): [True: 18, False: 265] ------------------ 31344| 40| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 40|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31344:5): [True: 22, False: 261] ------------------ 31345| 40| switch (blend) { ------------------ | Branch (31345:15): [True: 40, False: 0] ------------------ 31346| 20| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31346:9): [True: 20, False: 20] ------------------ 31347| 20| return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src; 31348| 20| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31348:9): [True: 20, False: 20] ------------------ 31349| 20| return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over; 31350| 40| } 31351| 0| return NULL; 31352| | 31353| 47| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 47|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31353:5): [True: 47, False: 236] ------------------ 31354| 47| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE: ------------------ | | 4973| 47|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB ------------------ | Branch (31354:5): [True: 0, False: 283] ------------------ 31355| 47| switch (blend) { ------------------ | Branch (31355:15): [True: 47, 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: 37] ------------------ 31357| 10| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src; 31358| 37| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 37|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31358:9): [True: 37, False: 10] ------------------ 31359| 37| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over; 31360| 47| } 31361| 0| return NULL; 31362| 283| } 31363| 19| return NULL; 31364| 283|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src: 30915| 18| size_t src_len) { 30916| 18| size_t src_len2 = src_len / 2; 30917| 18| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30917:16): [True: 4, False: 14] ------------------ 30918| 18| uint8_t* d = dst_ptr; 30919| 18| const uint8_t* s = src_ptr; 30920| 18| size_t n = len; 30921| | 30922| | // TODO: unroll. 30923| | 30924| 476| while (n >= 1) { ------------------ | Branch (30924:10): [True: 458, False: 18] ------------------ 30925| 458| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 30926| 458| d[0] = (uint8_t) 30927| 458| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0); 30928| | 30929| 458| s += 1 * 2; 30930| 458| d += 1 * 1; 30931| 458| n -= 1; 30932| 458| } 30933| | 30934| 18| return len; 30935| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src_over: 30943| 15| size_t src_len) { 30944| 15| size_t src_len2 = src_len / 2; 30945| 15| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30945:16): [True: 2, False: 13] ------------------ 30946| 15| uint8_t* d = dst_ptr; 30947| 15| const uint8_t* s = src_ptr; 30948| 15| size_t n = len; 30949| | 30950| | // TODO: unroll. 30951| | 30952| 637| while (n >= 1) { ------------------ | Branch (30952:10): [True: 622, False: 15] ------------------ 30953| 622| uint32_t d0 = 0xFF000000 | ((uint32_t)(d[0]) * 0x010101); 30954| 622| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 30955| 622| d[0] = (uint8_t)wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, 30956| 622| s0); 30957| | 30958| 622| s += 1 * 2; 30959| 622| d += 1 * 1; 30960| 622| n -= 1; 30961| 622| } 30962| | 30963| 15| return len; 30964| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u32_axxx: 25610| 5.28k| uint32_t src_nonpremul) { 25611| | // Extract 16-bit color components. 25612| 5.28k| uint32_t da = 0x101 * (0xFF & (dst_premul >> 24)); 25613| 5.28k| uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16)); 25614| 5.28k| uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8)); 25615| 5.28k| uint32_t db = 0x101 * (0xFF & (dst_premul >> 0)); 25616| 5.28k| uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24)); 25617| 5.28k| uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16)); 25618| 5.28k| uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8)); 25619| 5.28k| 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| 5.28k| uint32_t ia = 0xFFFF - sa; 25623| | 25624| | // Composite src (nonpremul) over dst (premul). 25625| 5.28k| da = sa + ((da * ia) / 0xFFFF); 25626| 5.28k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25627| 5.28k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25628| 5.28k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25629| | 25630| | // Convert from 16-bit color to 8-bit color. 25631| 5.28k| da >>= 8; 25632| 5.28k| dr >>= 8; 25633| 5.28k| dg >>= 8; 25634| 5.28k| db >>= 8; 25635| | 25636| | // Combine components. 25637| 5.28k| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25638| 5.28k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over: 31102| 33| size_t src_len) { 31103| 33| size_t dst_len2 = dst_len / 2; 31104| 33| size_t src_len2 = src_len / 2; 31105| 33| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (31105:16): [True: 7, False: 26] ------------------ 31106| 33| uint8_t* d = dst_ptr; 31107| 33| const uint8_t* s = src_ptr; 31108| 33| size_t n = len; 31109| | 31110| 1.16k| while (n >= 1) { ------------------ | Branch (31110:10): [True: 1.13k, False: 33] ------------------ 31111| 1.13k| uint32_t d0 = ((uint32_t)(d[1]) << 24) | ((uint32_t)(d[0]) * 0x010101); 31112| 1.13k| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 31113| 1.13k| uint32_t c0 = 31114| 1.13k| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0); 31115| 1.13k| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)(c0 >> 16)); 31116| | 31117| 1.13k| s += 1 * 2; 31118| 1.13k| d += 1 * 2; 31119| 1.13k| n -= 1; 31120| 1.13k| } 31121| | 31122| 33| return len; 31123| 33|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx: 25426| 2.61k| 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.61k| uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24)); 25435| 2.61k| if (da == 0) { ------------------ | Branch (25435:7): [True: 615, False: 1.99k] ------------------ 25436| 615| return src_nonpremul; 25437| 615| } 25438| 1.99k| uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16)); 25439| 1.99k| uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8)); 25440| 1.99k| uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0)); 25441| 1.99k| uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24)); 25442| 1.99k| uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16)); 25443| 1.99k| uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8)); 25444| 1.99k| uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0)); 25445| | 25446| | // Convert dst from nonpremul to premul. 25447| 1.99k| dr = (dr * da) / 0xFFFF; 25448| 1.99k| dg = (dg * da) / 0xFFFF; 25449| 1.99k| db = (db * da) / 0xFFFF; 25450| | 25451| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25452| 1.99k| uint32_t ia = 0xFFFF - sa; 25453| | 25454| | // Composite src (nonpremul) over dst (premul). 25455| 1.99k| da = sa + ((da * ia) / 0xFFFF); 25456| 1.99k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25457| 1.99k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25458| 1.99k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25459| | 25460| | // Convert dst from premul to nonpremul. 25461| 1.99k| if (da != 0) { ------------------ | Branch (25461:7): [True: 1.99k, False: 0] ------------------ 25462| 1.99k| dr = (dr * 0xFFFF) / da; 25463| 1.99k| dg = (dg * 0xFFFF) / da; 25464| 1.99k| db = (db * 0xFFFF) / da; 25465| 1.99k| } 25466| | 25467| | // Convert from 16-bit color to 8-bit color. 25468| 1.99k| da >>= 8; 25469| 1.99k| dr >>= 8; 25470| 1.99k| dg >>= 8; 25471| 1.99k| db >>= 8; 25472| | 25473| | // Combine components. 25474| 1.99k| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25475| 2.61k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src: 26716| 16| size_t src_len) { 26717| 16| size_t dst_len2 = dst_len / 2; 26718| 16| size_t src_len2 = src_len / 2; 26719| 16| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26719:16): [True: 3, False: 13] ------------------ 26720| 16| uint8_t* d = dst_ptr; 26721| 16| const uint8_t* s = src_ptr; 26722| 16| size_t n = len; 26723| | 26724| | // TODO: unroll. 26725| | 26726| 698| while (n >= 1) { ------------------ | Branch (26726:10): [True: 682, False: 16] ------------------ 26727| 682| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 26728| | 26729| 682| wuffs_base__poke_u16le__no_bounds_check( 26730| 682| d + (0 * 2), 26731| 682| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26732| 682| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26733| 682| s0))); 26734| | 26735| 682| s += 1 * 2; 26736| 682| d += 1 * 2; 26737| 682| n -= 1; 26738| 682| } 26739| | 26740| 16| return len; 26741| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over: 26750| 17| size_t src_len) { 26751| 17| size_t dst_len2 = dst_len / 2; 26752| 17| size_t src_len2 = src_len / 2; 26753| 17| size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2; ------------------ | Branch (26753:16): [True: 3, False: 14] ------------------ 26754| 17| uint8_t* d = dst_ptr; 26755| 17| const uint8_t* s = src_ptr; 26756| 17| size_t n = len; 26757| | 26758| | // TODO: unroll. 26759| | 26760| 533| while (n >= 1) { ------------------ | Branch (26760:10): [True: 516, False: 17] ------------------ 26761| | // Extract 16-bit color components. 26762| 516| uint32_t sa = 0x101 * ((uint32_t)s[1]); 26763| 516| uint32_t sy = 0x101 * ((uint32_t)s[0]); 26764| | 26765| | // Convert from 565 color to 16-bit color. 26766| 516| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26767| 516| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26768| 516| uint32_t dr = (0x8421 * old_r5) >> 4; 26769| 516| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26770| 516| uint32_t dg = (0x1041 * old_g6) >> 2; 26771| 516| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26772| 516| uint32_t db = (0x8421 * old_b5) >> 4; 26773| | 26774| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26775| 516| uint32_t ia = 0xFFFF - sa; 26776| | 26777| | // Composite src (nonpremul) over dst (premul). 26778| 516| dr = ((sy * sa) + (dr * ia)) / 0xFFFF; 26779| 516| dg = ((sy * sa) + (dg * ia)) / 0xFFFF; 26780| 516| db = ((sy * sa) + (db * ia)) / 0xFFFF; 26781| | 26782| | // Convert from 16-bit color to 565 color and combine the components. 26783| 516| uint32_t new_r5 = 0x1F & (dr >> 11); 26784| 516| uint32_t new_g6 = 0x3F & (dg >> 10); 26785| 516| uint32_t new_b5 = 0x1F & (db >> 11); 26786| 516| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26787| 516| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26788| | 26789| 516| s += 1 * 2; 26790| 516| d += 1 * 2; 26791| 516| n -= 1; 26792| 516| } 26793| | 26794| 17| return len; 26795| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__ya_nonpremul__src: 29896| 16| size_t src_len) { 29897| 16| size_t dst_len3 = dst_len / 3; 29898| 16| size_t src_len2 = src_len / 2; 29899| 16| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (29899:16): [True: 7, False: 9] ------------------ 29900| 16| uint8_t* d = dst_ptr; 29901| 16| const uint8_t* s = src_ptr; 29902| 16| size_t n = len; 29903| | 29904| | // TODO: unroll. 29905| | 29906| 375| while (n >= 1) { ------------------ | Branch (29906:10): [True: 359, False: 16] ------------------ 29907| 359| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 29908| 359| wuffs_base__poke_u24le__no_bounds_check( 29909| 359| d + (0 * 3), 29910| 359| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 29911| | 29912| 359| s += 1 * 2; 29913| 359| d += 1 * 3; 29914| 359| n -= 1; 29915| 359| } 29916| | 29917| 16| return len; 29918| 16|} 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: 6, False: 9] ------------------ 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| 282| while (n >= 1) { ------------------ | Branch (29937:10): [True: 267, False: 15] ------------------ 29938| 267| uint32_t d0 = 29939| 267| wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000; 29940| 267| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 29941| 267| wuffs_base__poke_u24le__no_bounds_check( 29942| 267| d + (0 * 3), 29943| 267| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 29944| | 29945| 267| s += 1 * 2; 29946| 267| d += 1 * 3; 29947| 267| n -= 1; 29948| 267| } 29949| | 29950| 15| return len; 29951| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src: 27952| 19| size_t src_len) { 27953| 19| size_t dst_len4 = dst_len / 4; 27954| 19| size_t src_len2 = src_len / 2; 27955| 19| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (27955:16): [True: 9, False: 10] ------------------ 27956| 19| uint8_t* d = dst_ptr; 27957| 19| const uint8_t* s = src_ptr; 27958| 19| size_t n = len; 27959| | 27960| | // TODO: unroll. 27961| | 27962| 376| while (n >= 1) { ------------------ | Branch (27962:10): [True: 357, False: 19] ------------------ 27963| 357| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 27964| 357| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 27965| | 27966| 357| s += 1 * 2; 27967| 357| d += 1 * 4; 27968| 357| n -= 1; 27969| 357| } 27970| | 27971| 19| return len; 27972| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over: 27981| 26| size_t src_len) { 27982| 26| size_t dst_len4 = dst_len / 4; 27983| 26| size_t src_len2 = src_len / 2; 27984| 26| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (27984:16): [True: 12, False: 14] ------------------ 27985| 26| uint8_t* d = dst_ptr; 27986| 26| const uint8_t* s = src_ptr; 27987| 26| size_t n = len; 27988| | 27989| | // TODO: unroll. 27990| | 27991| 350| while (n >= 1) { ------------------ | Branch (27991:10): [True: 324, False: 26] ------------------ 27992| 324| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27993| 324| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 27994| 324| wuffs_base__poke_u32le__no_bounds_check( 27995| 324| d + (0 * 4), 27996| 324| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27997| | 27998| 324| s += 1 * 2; 27999| 324| d += 1 * 4; 28000| 324| n -= 1; 28001| 324| } 28002| | 28003| 26| return len; 28004| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src: 28936| 20| size_t src_len) { 28937| 20| size_t dst_len4 = dst_len / 4; 28938| 20| size_t src_len2 = src_len / 2; 28939| 20| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28939:16): [True: 10, False: 10] ------------------ 28940| 20| uint8_t* d = dst_ptr; 28941| 20| const uint8_t* s = src_ptr; 28942| 20| size_t n = len; 28943| | 28944| | // TODO: unroll. 28945| | 28946| 468| while (n >= 1) { ------------------ | Branch (28946:10): [True: 448, False: 20] ------------------ 28947| 448| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 28948| 448| wuffs_base__poke_u32le__no_bounds_check( 28949| 448| d + (0 * 4), 28950| 448| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28951| | 28952| 448| s += 1 * 2; 28953| 448| d += 1 * 4; 28954| 448| n -= 1; 28955| 448| } 28956| | 28957| 20| return len; 28958| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over: 28967| 20| size_t src_len) { 28968| 20| size_t dst_len4 = dst_len / 4; 28969| 20| size_t src_len2 = src_len / 2; 28970| 20| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (28970:16): [True: 10, False: 10] ------------------ 28971| 20| uint8_t* d = dst_ptr; 28972| 20| const uint8_t* s = src_ptr; 28973| 20| size_t n = len; 28974| | 28975| | // TODO: unroll. 28976| | 28977| 363| while (n >= 1) { ------------------ | Branch (28977:10): [True: 343, False: 20] ------------------ 28978| 343| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28979| 343| uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); 28980| 343| wuffs_base__poke_u32le__no_bounds_check( 28981| 343| d + (0 * 4), 28982| 343| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28983| | 28984| 343| s += 1 * 2; 28985| 343| d += 1 * 4; 28986| 343| n -= 1; 28987| 343| } 28988| | 28989| 20| return len; 28990| 20|} 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: 6, False: 4] ------------------ 28391| 10| uint8_t* d = dst_ptr; 28392| 10| const uint8_t* s = src_ptr; 28393| | 28394| 10| size_t n = len; 28395| 123| while (n >= 1) { ------------------ | Branch (28395:10): [True: 113, False: 10] ------------------ 28396| 113| uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) | 28397| 113| ((uint64_t)(s[0]) * 0x0000010101010101); 28398| 113| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 28399| | 28400| 113| s += 1 * 2; 28401| 113| d += 1 * 8; 28402| 113| n -= 1; 28403| 113| } 28404| 10| return len; 28405| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over: 28414| 37| size_t src_len) { 28415| 37| size_t dst_len8 = dst_len / 8; 28416| 37| size_t src_len2 = src_len / 2; 28417| 37| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (28417:16): [True: 15, False: 22] ------------------ 28418| 37| uint8_t* d = dst_ptr; 28419| 37| const uint8_t* s = src_ptr; 28420| | 28421| 37| size_t n = len; 28422| 276| while (n >= 1) { ------------------ | Branch (28422:10): [True: 239, False: 37] ------------------ 28423| 239| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28424| 239| uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) | 28425| 239| ((uint64_t)(s[0]) * 0x0000010101010101); 28426| 239| wuffs_base__poke_u64le__no_bounds_check( 28427| 239| d + (0 * 8), 28428| 239| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28429| | 28430| 239| s += 1 * 2; 28431| 239| d += 1 * 8; 28432| 239| n -= 1; 28433| 239| } 28434| 37| return len; 28435| 37|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx: 25480| 1.58k| 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.58k| uint64_t da = 0xFFFF & (dst_nonpremul >> 48); 25489| 1.58k| if (da == 0) { ------------------ | Branch (25489:7): [True: 263, False: 1.32k] ------------------ 25490| 263| return src_nonpremul; 25491| 263| } 25492| 1.32k| uint64_t dr = 0xFFFF & (dst_nonpremul >> 32); 25493| 1.32k| uint64_t dg = 0xFFFF & (dst_nonpremul >> 16); 25494| 1.32k| uint64_t db = 0xFFFF & (dst_nonpremul >> 0); 25495| 1.32k| uint64_t sa = 0xFFFF & (src_nonpremul >> 48); 25496| 1.32k| uint64_t sr = 0xFFFF & (src_nonpremul >> 32); 25497| 1.32k| uint64_t sg = 0xFFFF & (src_nonpremul >> 16); 25498| 1.32k| uint64_t sb = 0xFFFF & (src_nonpremul >> 0); 25499| | 25500| | // Convert dst from nonpremul to premul. 25501| 1.32k| dr = (dr * da) / 0xFFFF; 25502| 1.32k| dg = (dg * da) / 0xFFFF; 25503| 1.32k| db = (db * da) / 0xFFFF; 25504| | 25505| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25506| 1.32k| uint64_t ia = 0xFFFF - sa; 25507| | 25508| | // Composite src (nonpremul) over dst (premul). 25509| 1.32k| da = sa + ((da * ia) / 0xFFFF); 25510| 1.32k| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25511| 1.32k| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25512| 1.32k| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25513| | 25514| | // Convert dst from premul to nonpremul. 25515| 1.32k| if (da != 0) { ------------------ | Branch (25515:7): [True: 1.32k, False: 0] ------------------ 25516| 1.32k| dr = (dr * 0xFFFF) / da; 25517| 1.32k| dg = (dg * 0xFFFF) / da; 25518| 1.32k| db = (db * 0xFFFF) / da; 25519| 1.32k| } 25520| | 25521| | // Combine components. 25522| 1.32k| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25523| 1.58k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul: 31372| 230| wuffs_base__pixel_blend blend) { 31373| 230| switch (dst_pixfmt.repr) { ------------------ | Branch (31373:11): [True: 210, False: 20] ------------------ 31374| 41| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 41|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31374:5): [True: 41, False: 189] ------------------ 31375| 41| switch (blend) { ------------------ | Branch (31375:15): [True: 41, False: 0] ------------------ 31376| 20| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 20|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31376:9): [True: 20, False: 21] ------------------ 31377| 20| if (wuffs_private_impl__swizzle_squash_align4_y_8888( ------------------ | Branch (31377:15): [True: 0, False: 20] ------------------ 31378| 20| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31379| 20| src_palette.len, true) != 31380| 20| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 20|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31381| 0| return NULL; 31382| 0| } 31383| 20| return wuffs_private_impl__swizzle_y__index__src; 31384| 21| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 21|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31384:9): [True: 21, False: 20] ------------------ 31385| 21| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31385:15): [True: 0, False: 21] ------------------ 31386| 21| src_palette) != 31387| 21| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 21|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31388| 0| return NULL; 31389| 0| } 31390| 21| return wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over; 31391| 41| } 31392| 0| return NULL; 31393| | 31394| 10| case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: ------------------ | | 4958| 10|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 ------------------ | Branch (31394:5): [True: 10, False: 220] ------------------ 31395| 10| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31395:11): [True: 0, False: 10] ------------------ 31396| 10| src_palette) != 31397| 10| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 10|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31398| 0| return NULL; 31399| 0| } 31400| 10| switch (blend) { ------------------ | Branch (31400:15): [True: 8, False: 2] ------------------ 31401| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31401:9): [True: 8, False: 2] ------------------ 31402| 8| return wuffs_private_impl__swizzle_copy_1_1; 31403| 10| } 31404| 2| return NULL; 31405| | 31406| 17| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31406:5): [True: 17, False: 213] ------------------ 31407| 17| switch (blend) { ------------------ | Branch (31407:15): [True: 17, False: 0] ------------------ 31408| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31408:9): [True: 4, False: 13] ------------------ 31409| 4| if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888( ------------------ | Branch (31409:15): [True: 0, False: 4] ------------------ 31410| 4| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31411| 4| src_palette.len, true) != 31412| 4| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31413| 0| return NULL; 31414| 0| } 31415| 4| return wuffs_private_impl__swizzle_bgr_565__index__src; 31416| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31416:9): [True: 13, False: 4] ------------------ 31417| 13| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31417:15): [True: 0, False: 13] ------------------ 31418| 13| src_palette) != 31419| 13| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 13|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31420| 0| return NULL; 31421| 0| } 31422| 13| return wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over; 31423| 17| } 31424| 0| return NULL; 31425| | 31426| 18| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 18|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31426:5): [True: 18, False: 212] ------------------ 31427| 18| switch (blend) { ------------------ | Branch (31427:15): [True: 18, False: 0] ------------------ 31428| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31428:9): [True: 7, False: 11] ------------------ 31429| 7| if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src( ------------------ | Branch (31429:15): [True: 0, False: 7] ------------------ 31430| 7| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31431| 7| src_palette.len) != 31432| 7| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 7|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31433| 0| return NULL; 31434| 0| } 31435| 7| return wuffs_private_impl__swizzle_xxx__index__src; 31436| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31436:9): [True: 11, False: 7] ------------------ 31437| 11| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31437:15): [True: 0, False: 11] ------------------ 31438| 11| src_palette) != 31439| 11| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31440| 0| return NULL; 31441| 0| } 31442| 11| return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over; 31443| 18| } 31444| 0| return NULL; 31445| | 31446| 24| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 24|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31446:5): [True: 24, False: 206] ------------------ 31447| 24| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31447:11): [True: 0, False: 24] ------------------ 31448| 24| src_palette) != 31449| 24| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 24|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31450| 0| return NULL; 31451| 0| } 31452| 24| switch (blend) { ------------------ | Branch (31452:15): [True: 24, 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: 17] ------------------ 31454| 7| return wuffs_private_impl__swizzle_xxxx__index__src; 31455| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31455:9): [True: 17, False: 7] ------------------ 31456| 17| return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over; 31457| 24| } 31458| 0| return NULL; 31459| | 31460| 50| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 50|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31460:5): [True: 50, False: 180] ------------------ 31461| 50| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31461:11): [True: 0, False: 50] ------------------ 31462| 50| src_palette) != 31463| 50| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 50|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31464| 0| return NULL; 31465| 0| } 31466| 50| switch (blend) { ------------------ | Branch (31466:15): [True: 50, False: 0] ------------------ 31467| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31467:9): [True: 7, False: 43] ------------------ 31468| 7| return wuffs_private_impl__swizzle_xxxxxxxx__index__src; 31469| 43| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 43|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31469:9): [True: 43, False: 7] ------------------ 31470| 43| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over; 31471| 50| } 31472| 0| return NULL; 31473| | 31474| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31474:5): [True: 12, False: 218] ------------------ 31475| 12| switch (blend) { ------------------ | Branch (31475:15): [True: 12, False: 0] ------------------ 31476| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31476:9): [True: 4, False: 8] ------------------ 31477| 4| if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src( ------------------ | Branch (31477:15): [True: 0, False: 4] ------------------ 31478| 4| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31479| 4| src_palette.len) != 31480| 4| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31481| 0| return NULL; 31482| 0| } 31483| 4| 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: 4] ------------------ 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| 12| } 31492| 0| return NULL; 31493| | 31494| 20| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 20|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31494:5): [True: 20, False: 210] ------------------ 31495| 20| switch (blend) { ------------------ | Branch (31495:15): [True: 20, False: 0] ------------------ 31496| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31496:9): [True: 11, False: 9] ------------------ 31497| 11| if (wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src( ------------------ | Branch (31497:15): [True: 0, False: 11] ------------------ 31498| 11| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31499| 11| src_palette.len) != 31500| 11| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31501| 0| return NULL; 31502| 0| } 31503| 11| return wuffs_private_impl__swizzle_xxx__index__src; 31504| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31504:9): [True: 9, False: 11] ------------------ 31505| 9| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31505:15): [True: 0, False: 9] ------------------ 31506| 9| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31507| 9| src_palette.len) != 31508| 9| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 9|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31509| 0| return NULL; 31510| 0| } 31511| 9| return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over; 31512| 20| } 31513| 0| return NULL; 31514| | 31515| 13| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 13|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31515:5): [True: 13, False: 217] ------------------ 31516| 13| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31516:11): [True: 0, False: 13] ------------------ 31517| 13| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31518| 13| src_palette.len) != 31519| 13| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 13|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31520| 0| return NULL; 31521| 0| } 31522| 13| switch (blend) { ------------------ | Branch (31522:15): [True: 13, False: 0] ------------------ 31523| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31523:9): [True: 5, False: 8] ------------------ 31524| 5| return wuffs_private_impl__swizzle_xxxx__index__src; 31525| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31525:9): [True: 8, False: 5] ------------------ 31526| 8| return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over; 31527| 13| } 31528| 0| return NULL; 31529| | 31530| 5| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 5|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31530:5): [True: 5, False: 225] ------------------ 31531| 5| switch (blend) { ------------------ | Branch (31531:15): [True: 5, 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: 3] ------------------ 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| 3| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31540:9): [True: 3, False: 2] ------------------ 31541| 3| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31541:15): [True: 0, False: 3] ------------------ 31542| 3| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31543| 3| src_palette.len) != 31544| 3| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 3|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31545| 0| return NULL; 31546| 0| } 31547| 3| return wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over; 31548| 5| } 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: 230] ------------------ 31552| | // TODO. 31553| 0| break; 31554| 230| } 31555| 20| return NULL; 31556| 230|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_y_8888: 25763| 53| bool nonpremul) { 25764| 53| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25764:17): [True: 0, False: 53] ------------------ 25765| 53| uint8_t* d = dst_ptr; 25766| 53| const uint8_t* s = src_ptr; 25767| | 25768| 53| size_t n = len; 25769| 13.6k| while (n--) { ------------------ | Branch (25769:10): [True: 13.5k, False: 53] ------------------ 25770| 13.5k| uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s); 25771| 13.5k| if (nonpremul) { ------------------ | Branch (25771:9): [True: 5.12k, False: 8.44k] ------------------ 25772| 5.12k| argb = 25773| 5.12k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb); 25774| 5.12k| } 25775| 13.5k| uint32_t s0 = wuffs_base__color_u32_argb_premul__as__color_u8_gray(argb); 25776| 13.5k| wuffs_base__poke_u32le__no_bounds_check( 25777| 13.5k| d, (argb & 0xFF000000) | (s0 * 0x010101)); 25778| 13.5k| s += 4; 25779| 13.5k| d += 4; 25780| 13.5k| } 25781| 53| return len; 25782| 53|} 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: 7, False: 16] ------------------ 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.73k| while (n >= 1) { ------------------ | Branch (30984:10): [True: 1.71k, False: 23] ------------------ 30985| 1.71k| d[0] = dst_palette_ptr[(size_t)s[0] * 4]; 30986| | 30987| 1.71k| s += 1 * 1; 30988| 1.71k| d += 1 * 1; 30989| 1.71k| n -= 1; 30990| 1.71k| } 30991| | 30992| 23| return len; 30993| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__slice_u8__copy_from_slice: 18632| 308| wuffs_base__slice_u8 src) { 18633| 308| size_t len = dst.len < src.len ? dst.len : src.len; ------------------ | Branch (18633:16): [True: 0, False: 308] ------------------ 18634| 308| if (len > 0) { ------------------ | Branch (18634:7): [True: 308, False: 0] ------------------ 18635| 308| memmove(dst.ptr, src.ptr, len); 18636| 308| } 18637| 308| return len; 18638| 308|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over: 31002| 21| size_t src_len) { 31003| 21| if (dst_palette_len != ------------------ | Branch (31003:7): [True: 0, False: 21] ------------------ 31004| 21| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 21|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31005| 0| return 0; 31006| 0| } 31007| 21| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (31007:16): [True: 2, False: 19] ------------------ 31008| 21| uint8_t* d = dst_ptr; 31009| 21| const uint8_t* s = src_ptr; 31010| 21| size_t n = len; 31011| | 31012| | // TODO: unroll. 31013| | 31014| 2.18k| while (n >= 1) { ------------------ | Branch (31014:10): [True: 2.16k, False: 21] ------------------ 31015| 2.16k| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 31016| 2.16k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 31017| 2.16k| ((size_t)s[0] * 4)); 31018| 2.16k| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 31019| 2.16k| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 31020| | 31021| 2.16k| s += 1 * 1; 31022| 2.16k| d += 1 * 1; 31023| 2.16k| n -= 1; 31024| 2.16k| } 31025| | 31026| 21| return len; 31027| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_bgr_565_8888: 25732| 41| bool nonpremul) { 25733| 41| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25733:17): [True: 0, False: 41] ------------------ 25734| 41| uint8_t* d = dst_ptr; 25735| 41| const uint8_t* s = src_ptr; 25736| | 25737| 41| size_t n = len; 25738| 10.5k| while (n--) { ------------------ | Branch (25738:10): [True: 10.4k, False: 41] ------------------ 25739| 10.4k| uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s); 25740| 10.4k| if (nonpremul) { ------------------ | Branch (25740:9): [True: 1.02k, False: 9.47k] ------------------ 25741| 1.02k| argb = 25742| 1.02k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb); 25743| 1.02k| } 25744| 10.4k| uint32_t b5 = 0x1F & (argb >> (8 - 5)); 25745| 10.4k| uint32_t g6 = 0x3F & (argb >> (16 - 6)); 25746| 10.4k| uint32_t r5 = 0x1F & (argb >> (24 - 5)); 25747| 10.4k| uint32_t alpha = argb & 0xFF000000; 25748| 10.4k| wuffs_base__poke_u32le__no_bounds_check( 25749| 10.4k| d, alpha | (r5 << 11) | (g6 << 5) | (b5 << 0)); 25750| 10.4k| s += 4; 25751| 10.4k| d += 4; 25752| 10.4k| } 25753| 41| return len; 25754| 41|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index__src: 26803| 16| size_t src_len) { 26804| 16| if (dst_palette_len != ------------------ | Branch (26804:7): [True: 0, False: 16] ------------------ 26805| 16| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 16|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26806| 0| return 0; 26807| 0| } 26808| 16| size_t dst_len2 = dst_len / 2; 26809| 16| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26809:16): [True: 6, False: 10] ------------------ 26810| 16| uint8_t* d = dst_ptr; 26811| 16| const uint8_t* s = src_ptr; 26812| 16| size_t n = len; 26813| | 26814| 16| const size_t loop_unroll_count = 4; 26815| | 26816| 167| while (n >= loop_unroll_count) { ------------------ | Branch (26816:10): [True: 151, False: 16] ------------------ 26817| 151| wuffs_base__poke_u16le__no_bounds_check( 26818| 151| d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check( 26819| 151| dst_palette_ptr + ((size_t)s[0] * 4))); 26820| 151| wuffs_base__poke_u16le__no_bounds_check( 26821| 151| d + (1 * 2), wuffs_base__peek_u16le__no_bounds_check( 26822| 151| dst_palette_ptr + ((size_t)s[1] * 4))); 26823| 151| wuffs_base__poke_u16le__no_bounds_check( 26824| 151| d + (2 * 2), wuffs_base__peek_u16le__no_bounds_check( 26825| 151| dst_palette_ptr + ((size_t)s[2] * 4))); 26826| 151| wuffs_base__poke_u16le__no_bounds_check( 26827| 151| d + (3 * 2), wuffs_base__peek_u16le__no_bounds_check( 26828| 151| dst_palette_ptr + ((size_t)s[3] * 4))); 26829| | 26830| 151| s += loop_unroll_count * 1; 26831| 151| d += loop_unroll_count * 2; 26832| 151| n -= loop_unroll_count; 26833| 151| } 26834| | 26835| 38| while (n >= 1) { ------------------ | Branch (26835:10): [True: 22, False: 16] ------------------ 26836| 22| wuffs_base__poke_u16le__no_bounds_check( 26837| 22| d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check( 26838| 22| dst_palette_ptr + ((size_t)s[0] * 4))); 26839| | 26840| 22| s += 1 * 1; 26841| 22| d += 1 * 2; 26842| 22| n -= 1; 26843| 22| } 26844| | 26845| 16| return len; 26846| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over: 26855| 13| size_t src_len) { 26856| 13| if (dst_palette_len != ------------------ | Branch (26856:7): [True: 0, False: 13] ------------------ 26857| 13| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 13|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26858| 0| return 0; 26859| 0| } 26860| 13| size_t dst_len2 = dst_len / 2; 26861| 13| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26861:16): [True: 4, False: 9] ------------------ 26862| 13| uint8_t* d = dst_ptr; 26863| 13| const uint8_t* s = src_ptr; 26864| 13| size_t n = len; 26865| | 26866| | // TODO: unroll. 26867| | 26868| 589| while (n >= 1) { ------------------ | Branch (26868:10): [True: 576, False: 13] ------------------ 26869| 576| uint32_t d0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 26870| 576| wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2))); 26871| 576| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 26872| 576| ((size_t)s[0] * 4)); 26873| 576| wuffs_base__poke_u16le__no_bounds_check( 26874| 576| d + (0 * 2), 26875| 576| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26876| 576| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0))); 26877| | 26878| 576| s += 1 * 1; 26879| 576| d += 1 * 2; 26880| 576| n -= 1; 26881| 576| } 26882| | 26883| 13| return len; 26884| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src: 28446| 29| size_t src_len) { 28447| 29| size_t dst_len4 = dst_len / 4; 28448| 29| size_t src_len4 = src_len / 4; 28449| 29| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28449:16): [True: 4, False: 25] ------------------ 28450| 29| uint8_t* d = dst_ptr; 28451| 29| const uint8_t* s = src_ptr; 28452| 29| size_t n = len; 28453| | 28454| | // TODO: unroll. 28455| | 28456| 3.04k| while (n >= 1) { ------------------ | Branch (28456:10): [True: 3.01k, False: 29] ------------------ 28457| 3.01k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 28458| 3.01k| wuffs_base__poke_u32le__no_bounds_check( 28459| 3.01k| d + (0 * 4), 28460| 3.01k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28461| | 28462| 3.01k| s += 1 * 4; 28463| 3.01k| d += 1 * 4; 28464| 3.01k| n -= 1; 28465| 3.01k| } 28466| | 28467| 29| return len; 28468| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index__src: 29622| 23| size_t src_len) { 29623| 23| if (dst_palette_len != ------------------ | Branch (29623:7): [True: 0, False: 23] ------------------ 29624| 23| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 23|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29625| 0| return 0; 29626| 0| } 29627| 23| size_t dst_len3 = dst_len / 3; 29628| 23| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29628:16): [True: 10, False: 13] ------------------ 29629| 23| uint8_t* d = dst_ptr; 29630| 23| const uint8_t* s = src_ptr; 29631| 23| size_t n = len; 29632| | 29633| 23| 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| 153| while (n > loop_unroll_count) { ------------------ | Branch (29642:10): [True: 130, False: 23] ------------------ 29643| 130| wuffs_base__poke_u32le__no_bounds_check( 29644| 130| d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check( 29645| 130| dst_palette_ptr + ((size_t)s[0] * 4))); 29646| 130| wuffs_base__poke_u32le__no_bounds_check( 29647| 130| d + (1 * 3), wuffs_base__peek_u32le__no_bounds_check( 29648| 130| dst_palette_ptr + ((size_t)s[1] * 4))); 29649| 130| wuffs_base__poke_u32le__no_bounds_check( 29650| 130| d + (2 * 3), wuffs_base__peek_u32le__no_bounds_check( 29651| 130| dst_palette_ptr + ((size_t)s[2] * 4))); 29652| 130| wuffs_base__poke_u32le__no_bounds_check( 29653| 130| d + (3 * 3), wuffs_base__peek_u32le__no_bounds_check( 29654| 130| dst_palette_ptr + ((size_t)s[3] * 4))); 29655| | 29656| 130| s += loop_unroll_count * 1; 29657| 130| d += loop_unroll_count * 3; 29658| 130| n -= loop_unroll_count; 29659| 130| } 29660| | 29661| 68| while (n >= 1) { ------------------ | Branch (29661:10): [True: 45, False: 23] ------------------ 29662| 45| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29663| 45| ((size_t)s[0] * 4)); 29664| 45| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29665| | 29666| 45| s += 1 * 1; 29667| 45| d += 1 * 3; 29668| 45| n -= 1; 29669| 45| } 29670| | 29671| 23| return len; 29672| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over: 29681| 20| size_t src_len) { 29682| 20| if (dst_palette_len != ------------------ | Branch (29682:7): [True: 0, False: 20] ------------------ 29683| 20| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 20|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29684| 0| return 0; 29685| 0| } 29686| 20| size_t dst_len3 = dst_len / 3; 29687| 20| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29687:16): [True: 11, False: 9] ------------------ 29688| 20| uint8_t* d = dst_ptr; 29689| 20| const uint8_t* s = src_ptr; 29690| 20| size_t n = len; 29691| | 29692| | // TODO: unroll. 29693| | 29694| 392| while (n >= 1) { ------------------ | Branch (29694:10): [True: 372, False: 20] ------------------ 29695| 372| uint32_t d0 = 29696| 372| wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000; 29697| 372| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29698| 372| ((size_t)s[0] * 4)); 29699| 372| wuffs_base__poke_u24le__no_bounds_check( 29700| 372| d + (0 * 3), 29701| 372| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 29702| | 29703| 372| s += 1 * 1; 29704| 372| d += 1 * 3; 29705| 372| n -= 1; 29706| 372| } 29707| | 29708| 20| return len; 29709| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index__src: 29961| 24| size_t src_len) { 29962| 24| if (dst_palette_len != ------------------ | Branch (29962:7): [True: 0, False: 24] ------------------ 29963| 24| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 24|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29964| 0| return 0; 29965| 0| } 29966| 24| size_t dst_len4 = dst_len / 4; 29967| 24| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (29967:16): [True: 14, False: 10] ------------------ 29968| 24| uint8_t* d = dst_ptr; 29969| 24| const uint8_t* s = src_ptr; 29970| 24| size_t n = len; 29971| | 29972| 24| const size_t loop_unroll_count = 4; 29973| | 29974| 146| while (n >= loop_unroll_count) { ------------------ | Branch (29974:10): [True: 122, False: 24] ------------------ 29975| 122| wuffs_base__poke_u32le__no_bounds_check( 29976| 122| d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check( 29977| 122| dst_palette_ptr + ((size_t)s[0] * 4))); 29978| 122| wuffs_base__poke_u32le__no_bounds_check( 29979| 122| d + (1 * 4), wuffs_base__peek_u32le__no_bounds_check( 29980| 122| dst_palette_ptr + ((size_t)s[1] * 4))); 29981| 122| wuffs_base__poke_u32le__no_bounds_check( 29982| 122| d + (2 * 4), wuffs_base__peek_u32le__no_bounds_check( 29983| 122| dst_palette_ptr + ((size_t)s[2] * 4))); 29984| 122| wuffs_base__poke_u32le__no_bounds_check( 29985| 122| d + (3 * 4), wuffs_base__peek_u32le__no_bounds_check( 29986| 122| dst_palette_ptr + ((size_t)s[3] * 4))); 29987| | 29988| 122| s += loop_unroll_count * 1; 29989| 122| d += loop_unroll_count * 4; 29990| 122| n -= loop_unroll_count; 29991| 122| } 29992| | 29993| 52| while (n >= 1) { ------------------ | Branch (29993:10): [True: 28, False: 24] ------------------ 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| 24| return len; 30004| 24|} 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: 14, False: 11] ------------------ 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| 376| while (n >= 1) { ------------------ | Branch (27837:10): [True: 351, False: 25] ------------------ 27838| 351| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27839| 351| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 27840| 351| ((size_t)s[0] * 4)); 27841| 351| wuffs_base__poke_u32le__no_bounds_check( 27842| 351| d + (0 * 4), 27843| 351| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27844| | 27845| 351| s += 1 * 1; 27846| 351| d += 1 * 4; 27847| 351| n -= 1; 27848| 351| } 27849| | 27850| 25| return len; 27851| 25|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index__src: 30204| 16| size_t src_len) { 30205| 16| if (dst_palette_len != ------------------ | Branch (30205:7): [True: 0, False: 16] ------------------ 30206| 16| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 16|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30207| 0| return 0; 30208| 0| } 30209| 16| size_t dst_len8 = dst_len / 8; 30210| 16| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (30210:16): [True: 8, False: 8] ------------------ 30211| 16| uint8_t* d = dst_ptr; 30212| 16| const uint8_t* s = src_ptr; 30213| 16| size_t n = len; 30214| | 30215| 166| while (n >= 1) { ------------------ | Branch (30215:10): [True: 150, False: 16] ------------------ 30216| 150| wuffs_base__poke_u64le__no_bounds_check( 30217| 150| d + (0 * 8), wuffs_base__color_u32__as__color_u64( 30218| 150| wuffs_base__peek_u32le__no_bounds_check( 30219| 150| dst_palette_ptr + ((size_t)s[0] * 4)))); 30220| | 30221| 150| s += 1 * 1; 30222| 150| d += 1 * 8; 30223| 150| n -= 1; 30224| 150| } 30225| | 30226| 16| return len; 30227| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over: 28225| 43| size_t src_len) { 28226| 43| if (dst_palette_len != ------------------ | Branch (28226:7): [True: 0, False: 43] ------------------ 28227| 43| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 43|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 28228| 0| return 0; 28229| 0| } 28230| 43| size_t dst_len8 = dst_len / 8; 28231| 43| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (28231:16): [True: 30, False: 13] ------------------ 28232| 43| uint8_t* d = dst_ptr; 28233| 43| const uint8_t* s = src_ptr; 28234| 43| size_t n = len; 28235| | 28236| 351| while (n >= 1) { ------------------ | Branch (28236:10): [True: 308, False: 43] ------------------ 28237| 308| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28238| 308| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28239| 308| wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 28240| 308| ((size_t)s[0] * 4))); 28241| 308| wuffs_base__poke_u64le__no_bounds_check( 28242| 308| d + (0 * 8), 28243| 308| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28244| | 28245| 308| s += 1 * 1; 28246| 308| d += 1 * 8; 28247| 308| n -= 1; 28248| 308| } 28249| | 28250| 43| return len; 28251| 43|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over: 28670| 11| size_t src_len) { 28671| 11| if (dst_palette_len != ------------------ | Branch (28671:7): [True: 0, False: 11] ------------------ 28672| 11| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 28673| 0| return 0; 28674| 0| } 28675| 11| size_t dst_len4 = dst_len / 4; 28676| 11| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (28676:16): [True: 7, False: 4] ------------------ 28677| 11| uint8_t* d = dst_ptr; 28678| 11| const uint8_t* s = src_ptr; 28679| 11| size_t n = len; 28680| | 28681| | // TODO: unroll. 28682| | 28683| 155| while (n >= 1) { ------------------ | Branch (28683:10): [True: 144, False: 11] ------------------ 28684| 144| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28685| 144| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 28686| 144| ((size_t)s[0] * 4)); 28687| 144| wuffs_base__poke_u32le__no_bounds_check( 28688| 144| d + (0 * 4), 28689| 144| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28690| | 28691| 144| s += 1 * 1; 28692| 144| d += 1 * 4; 28693| 144| n -= 1; 28694| 144| } 28695| | 28696| 11| return len; 28697| 11|} 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: 3, False: 23] ------------------ 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| 3.66k| while (n >= 1) { ------------------ | Branch (28716:10): [True: 3.63k, False: 26] ------------------ 28717| 3.63k| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28718| 3.63k| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28719| 3.63k| wuffs_base__poke_u32le__no_bounds_check( 28720| 3.63k| d + (0 * 4), 28721| 3.63k| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0)); 28722| | 28723| 3.63k| s += 1 * 4; 28724| 3.63k| d += 1 * 4; 28725| 3.63k| n -= 1; 28726| 3.63k| } 28727| | 28728| 26| return len; 28729| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx: 25865| 109| size_t src_len) { 25866| 109| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25866:17): [True: 0, False: 109] ------------------ 25867| 109| uint8_t* d = dst_ptr; 25868| 109| const uint8_t* s = src_ptr; 25869| | 25870| 109| size_t n = len; 25871| 28.0k| while (n--) { ------------------ | Branch (25871:10): [True: 27.9k, False: 109] ------------------ 25872| 27.9k| uint8_t s0 = s[0]; 25873| 27.9k| uint8_t s1 = s[1]; 25874| 27.9k| uint8_t s2 = s[2]; 25875| 27.9k| uint8_t s3 = s[3]; 25876| 27.9k| d[0] = s2; 25877| 27.9k| d[1] = s1; 25878| 27.9k| d[2] = s0; 25879| 27.9k| d[3] = s3; 25880| 27.9k| s += 4; 25881| 27.9k| d += 4; 25882| 27.9k| } 25883| 109| return len; 25884| 109|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary: 31564| 340| wuffs_base__pixel_blend blend) { 31565| 340| switch (dst_pixfmt.repr) { ------------------ | Branch (31565:11): [True: 325, False: 15] ------------------ 31566| 33| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 33|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31566:5): [True: 33, False: 307] ------------------ 31567| 33| if (wuffs_private_impl__swizzle_squash_align4_y_8888( ------------------ | Branch (31567:11): [True: 0, False: 33] ------------------ 31568| 33| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31569| 33| src_palette.len, false) != 31570| 33| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 33|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31571| 0| return NULL; 31572| 0| } 31573| 33| switch (blend) { ------------------ | Branch (31573:15): [True: 33, False: 0] ------------------ 31574| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31574:9): [True: 3, False: 30] ------------------ 31575| 3| return wuffs_private_impl__swizzle_y__index__src; 31576| 30| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 30|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31576:9): [True: 30, False: 3] ------------------ 31577| 30| return wuffs_private_impl__swizzle_y__index_binary_alpha__src_over; 31578| 33| } 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: 334] ------------------ 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: 340] ------------------ 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: 332] ------------------ 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| 37| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 37|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31595:5): [True: 37, False: 303] ------------------ 31596| 37| if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888( ------------------ | Branch (31596:11): [True: 0, False: 37] ------------------ 31597| 37| dst_palette.ptr, dst_palette.len, src_palette.ptr, 31598| 37| src_palette.len, false) != 31599| 37| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 37|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31600| 0| return NULL; 31601| 0| } 31602| 37| switch (blend) { ------------------ | Branch (31602:15): [True: 37, 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: 25] ------------------ 31604| 12| return wuffs_private_impl__swizzle_bgr_565__index__src; 31605| 25| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 25|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31605:9): [True: 25, False: 12] ------------------ 31606| 25| return wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over; 31607| 37| } 31608| 0| return NULL; 31609| | 31610| 60| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 60|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31610:5): [True: 60, False: 280] ------------------ 31611| 60| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31611:11): [True: 0, False: 60] ------------------ 31612| 60| src_palette) != 31613| 60| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 60|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31614| 0| return NULL; 31615| 0| } 31616| 60| switch (blend) { ------------------ | Branch (31616:15): [True: 60, False: 0] ------------------ 31617| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31617:9): [True: 3, False: 57] ------------------ 31618| 3| 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: 3] ------------------ 31620| 57| return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over; 31621| 60| } 31622| 0| return NULL; 31623| | 31624| 24| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 24|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31624:5): [True: 24, False: 316] ------------------ 31625| 51| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 51|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31625:5): [True: 27, False: 313] ------------------ 31626| 51| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 51|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31626:5): [True: 0, False: 340] ------------------ 31627| 51| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31627:11): [True: 0, False: 51] ------------------ 31628| 51| src_palette) != 31629| 51| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 51|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31630| 0| return NULL; 31631| 0| } 31632| 51| switch (blend) { ------------------ | Branch (31632:15): [True: 51, False: 0] ------------------ 31633| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31633:9): [True: 1, False: 50] ------------------ 31634| 1| return wuffs_private_impl__swizzle_xxxx__index__src; 31635| 50| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 50|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31635:9): [True: 50, False: 1] ------------------ 31636| 50| return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over; 31637| 51| } 31638| 0| return NULL; 31639| | 31640| 20| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31640:5): [True: 20, False: 320] ------------------ 31641| 46| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 46|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31641:5): [True: 26, False: 314] ------------------ 31642| 46| if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, ------------------ | Branch (31642:11): [True: 0, False: 46] ------------------ 31643| 46| src_palette) != 31644| 46| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 46|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31645| 0| return NULL; 31646| 0| } 31647| 46| switch (blend) { ------------------ | Branch (31647:15): [True: 46, 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: 37] ------------------ 31649| 9| return wuffs_private_impl__swizzle_xxxxxxxx__index__src; 31650| 37| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 37|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31650:9): [True: 37, False: 9] ------------------ 31651| 37| return wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over; 31652| 46| } 31653| 0| return NULL; 31654| | 31655| 35| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 35|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31655:5): [True: 35, False: 305] ------------------ 31656| 35| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31656:11): [True: 0, False: 35] ------------------ 31657| 35| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31658| 35| src_palette.len) != 31659| 35| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 35|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31660| 0| return NULL; 31661| 0| } 31662| 35| switch (blend) { ------------------ | Branch (31662:15): [True: 35, False: 0] ------------------ 31663| 2| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31663:9): [True: 2, False: 33] ------------------ 31664| 2| return wuffs_private_impl__swizzle_xxx__index__src; 31665| 33| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 33|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31665:9): [True: 33, False: 2] ------------------ 31666| 33| return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over; 31667| 35| } 31668| 0| return NULL; 31669| | 31670| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31670:5): [True: 21, False: 319] ------------------ 31671| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31671:5): [True: 28, False: 312] ------------------ 31672| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31672:5): [True: 0, False: 340] ------------------ 31673| 49| if (wuffs_private_impl__swizzle_swap_rgbx_bgrx( ------------------ | Branch (31673:11): [True: 0, False: 49] ------------------ 31674| 49| dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr, 31675| 49| src_palette.len) != 31676| 49| (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { ------------------ | | 4900| 49|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31677| 0| return NULL; 31678| 0| } 31679| 49| switch (blend) { ------------------ | Branch (31679:15): [True: 49, 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: 44] ------------------ 31681| 5| return wuffs_private_impl__swizzle_xxxx__index__src; 31682| 44| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 44|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31682:9): [True: 44, False: 5] ------------------ 31683| 44| return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over; 31684| 49| } 31685| 0| return NULL; 31686| 340| } 31687| 15| return NULL; 31688| 340|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_binary_alpha__src_over: 31036| 30| size_t src_len) { 31037| 30| if (dst_palette_len != ------------------ | Branch (31037:7): [True: 0, False: 30] ------------------ 31038| 30| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 30|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 31039| 0| return 0; 31040| 0| } 31041| 30| size_t len = (dst_len < src_len) ? dst_len : src_len; ------------------ | Branch (31041:16): [True: 5, False: 25] ------------------ 31042| 30| uint8_t* d = dst_ptr; 31043| 30| const uint8_t* s = src_ptr; 31044| 30| size_t n = len; 31045| | 31046| | // TODO: unroll. 31047| | 31048| 2.10k| while (n >= 1) { ------------------ | Branch (31048:10): [True: 2.07k, False: 30] ------------------ 31049| 2.07k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 31050| 2.07k| ((size_t)s[0] * 4)); 31051| 2.07k| if (s0) { ------------------ | Branch (31051:9): [True: 1.75k, False: 319] ------------------ 31052| 1.75k| d[0] = (uint8_t)s0; 31053| 1.75k| } 31054| | 31055| 2.07k| s += 1 * 1; 31056| 2.07k| d += 1 * 1; 31057| 2.07k| n -= 1; 31058| 2.07k| } 31059| | 31060| 30| return len; 31061| 30|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over: 26893| 25| size_t src_len) { 26894| 25| if (dst_palette_len != ------------------ | Branch (26894:7): [True: 0, False: 25] ------------------ 26895| 25| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 25|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 26896| 0| return 0; 26897| 0| } 26898| 25| size_t dst_len2 = dst_len / 2; 26899| 25| size_t len = (dst_len2 < src_len) ? dst_len2 : src_len; ------------------ | Branch (26899:16): [True: 9, False: 16] ------------------ 26900| 25| uint8_t* d = dst_ptr; 26901| 25| const uint8_t* s = src_ptr; 26902| 25| size_t n = len; 26903| | 26904| | // TODO: unroll. 26905| | 26906| 1.06k| while (n >= 1) { ------------------ | Branch (26906:10): [True: 1.04k, False: 25] ------------------ 26907| 1.04k| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 26908| 1.04k| ((size_t)s[0] * 4)); 26909| 1.04k| if (s0) { ------------------ | Branch (26909:9): [True: 937, False: 106] ------------------ 26910| 937| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)s0); 26911| 937| } 26912| | 26913| 1.04k| s += 1 * 1; 26914| 1.04k| d += 1 * 2; 26915| 1.04k| n -= 1; 26916| 1.04k| } 26917| | 26918| 25| return len; 26919| 25|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over: 29718| 90| size_t src_len) { 29719| 90| if (dst_palette_len != ------------------ | Branch (29719:7): [True: 0, False: 90] ------------------ 29720| 90| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 90|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 29721| 0| return 0; 29722| 0| } 29723| 90| size_t dst_len3 = dst_len / 3; 29724| 90| size_t len = (dst_len3 < src_len) ? dst_len3 : src_len; ------------------ | Branch (29724:16): [True: 49, False: 41] ------------------ 29725| 90| uint8_t* d = dst_ptr; 29726| 90| const uint8_t* s = src_ptr; 29727| 90| size_t n = len; 29728| | 29729| 90| const size_t loop_unroll_count = 4; 29730| | 29731| 993| while (n >= loop_unroll_count) { ------------------ | Branch (29731:10): [True: 903, False: 90] ------------------ 29732| 903| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29733| 903| ((size_t)s[0] * 4)); 29734| 903| if (s0) { ------------------ | Branch (29734:9): [True: 686, False: 217] ------------------ 29735| 686| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29736| 686| } 29737| 903| uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29738| 903| ((size_t)s[1] * 4)); 29739| 903| if (s1) { ------------------ | Branch (29739:9): [True: 692, False: 211] ------------------ 29740| 692| wuffs_base__poke_u24le__no_bounds_check(d + (1 * 3), s1); 29741| 692| } 29742| 903| uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29743| 903| ((size_t)s[2] * 4)); 29744| 903| if (s2) { ------------------ | Branch (29744:9): [True: 682, False: 221] ------------------ 29745| 682| wuffs_base__poke_u24le__no_bounds_check(d + (2 * 3), s2); 29746| 682| } 29747| 903| uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29748| 903| ((size_t)s[3] * 4)); 29749| 903| if (s3) { ------------------ | Branch (29749:9): [True: 697, False: 206] ------------------ 29750| 697| wuffs_base__poke_u24le__no_bounds_check(d + (3 * 3), s3); 29751| 697| } 29752| | 29753| 903| s += loop_unroll_count * 1; 29754| 903| d += loop_unroll_count * 3; 29755| 903| n -= loop_unroll_count; 29756| 903| } 29757| | 29758| 247| while (n >= 1) { ------------------ | Branch (29758:10): [True: 157, False: 90] ------------------ 29759| 157| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 29760| 157| ((size_t)s[0] * 4)); 29761| 157| if (s0) { ------------------ | Branch (29761:9): [True: 125, False: 32] ------------------ 29762| 125| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 29763| 125| } 29764| | 29765| 157| s += 1 * 1; 29766| 157| d += 1 * 3; 29767| 157| n -= 1; 29768| 157| } 29769| | 29770| 90| return len; 29771| 90|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over: 30013| 94| size_t src_len) { 30014| 94| if (dst_palette_len != ------------------ | Branch (30014:7): [True: 0, False: 94] ------------------ 30015| 94| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 94|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30016| 0| return 0; 30017| 0| } 30018| 94| size_t dst_len4 = dst_len / 4; 30019| 94| size_t len = (dst_len4 < src_len) ? dst_len4 : src_len; ------------------ | Branch (30019:16): [True: 61, False: 33] ------------------ 30020| 94| uint8_t* d = dst_ptr; 30021| 94| const uint8_t* s = src_ptr; 30022| 94| size_t n = len; 30023| | 30024| 94| const size_t loop_unroll_count = 4; 30025| | 30026| 802| while (n >= loop_unroll_count) { ------------------ | Branch (30026:10): [True: 708, False: 94] ------------------ 30027| 708| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30028| 708| ((size_t)s[0] * 4)); 30029| 708| if (s0) { ------------------ | Branch (30029:9): [True: 565, False: 143] ------------------ 30030| 565| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 30031| 565| } 30032| 708| uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30033| 708| ((size_t)s[1] * 4)); 30034| 708| if (s1) { ------------------ | Branch (30034:9): [True: 583, False: 125] ------------------ 30035| 583| wuffs_base__poke_u32le__no_bounds_check(d + (1 * 4), s1); 30036| 583| } 30037| 708| uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30038| 708| ((size_t)s[2] * 4)); 30039| 708| if (s2) { ------------------ | Branch (30039:9): [True: 581, False: 127] ------------------ 30040| 581| wuffs_base__poke_u32le__no_bounds_check(d + (2 * 4), s2); 30041| 581| } 30042| 708| uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30043| 708| ((size_t)s[3] * 4)); 30044| 708| if (s3) { ------------------ | Branch (30044:9): [True: 584, False: 124] ------------------ 30045| 584| wuffs_base__poke_u32le__no_bounds_check(d + (3 * 4), s3); 30046| 584| } 30047| | 30048| 708| s += loop_unroll_count * 1; 30049| 708| d += loop_unroll_count * 4; 30050| 708| n -= loop_unroll_count; 30051| 708| } 30052| | 30053| 259| while (n >= 1) { ------------------ | Branch (30053:10): [True: 165, False: 94] ------------------ 30054| 165| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30055| 165| ((size_t)s[0] * 4)); 30056| 165| if (s0) { ------------------ | Branch (30056:9): [True: 146, False: 19] ------------------ 30057| 146| wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0); 30058| 146| } 30059| | 30060| 165| s += 1 * 1; 30061| 165| d += 1 * 4; 30062| 165| n -= 1; 30063| 165| } 30064| | 30065| 94| return len; 30066| 94|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over: 30236| 37| size_t src_len) { 30237| 37| if (dst_palette_len != ------------------ | Branch (30237:7): [True: 0, False: 37] ------------------ 30238| 37| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 37|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 30239| 0| return 0; 30240| 0| } 30241| 37| size_t dst_len8 = dst_len / 8; 30242| 37| size_t len = (dst_len8 < src_len) ? dst_len8 : src_len; ------------------ | Branch (30242:16): [True: 30, False: 7] ------------------ 30243| 37| uint8_t* d = dst_ptr; 30244| 37| const uint8_t* s = src_ptr; 30245| 37| size_t n = len; 30246| | 30247| 537| while (n >= 1) { ------------------ | Branch (30247:10): [True: 500, False: 37] ------------------ 30248| 500| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + 30249| 500| ((size_t)s[0] * 4)); 30250| 500| if (s0) { ------------------ | Branch (30250:9): [True: 391, False: 109] ------------------ 30251| 391| wuffs_base__poke_u64le__no_bounds_check( 30252| 391| d + (0 * 8), wuffs_base__color_u32__as__color_u64(s0)); 30253| 391| } 30254| | 30255| 500| s += 1 * 1; 30256| 500| d += 1 * 8; 30257| 500| n -= 1; 30258| 500| } 30259| | 30260| 37| return len; 30261| 37|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr_565: 31696| 121| wuffs_base__pixel_blend blend) { 31697| 121| switch (dst_pixfmt.repr) { ------------------ | Branch (31697:11): [True: 111, False: 10] ------------------ 31698| 18| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 18|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31698:5): [True: 18, False: 103] ------------------ 31699| 18| return wuffs_private_impl__swizzle_y__bgr_565; 31700| | 31701| 7| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31701:5): [True: 7, False: 114] ------------------ 31702| 7| return wuffs_private_impl__swizzle_copy_2_2; 31703| | 31704| 12| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31704:5): [True: 12, False: 109] ------------------ 31705| 12| return wuffs_private_impl__swizzle_bgr__bgr_565; 31706| | 31707| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31707:5): [True: 6, False: 115] ------------------ 31708| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31708:5): [True: 3, False: 118] ------------------ 31709| 9| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31709:5): [True: 0, False: 121] ------------------ 31710| 19| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31710:5): [True: 10, False: 111] ------------------ 31711| 19| return wuffs_private_impl__swizzle_bgrw__bgr_565; 31712| | 31713| 2| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 2|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31713:5): [True: 2, False: 119] ------------------ 31714| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31714:5): [True: 10, False: 111] ------------------ 31715| 12| 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: 106] ------------------ 31718| 15| return wuffs_private_impl__swizzle_rgb__bgr_565; 31719| | 31720| 7| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 7|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31720:5): [True: 7, False: 114] ------------------ 31721| 28| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 28|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31721:5): [True: 21, False: 100] ------------------ 31722| 28| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 28|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (31722:5): [True: 0, False: 121] ------------------ 31723| 28| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 28|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31723:5): [True: 0, False: 121] ------------------ 31724| 28| return wuffs_private_impl__swizzle_rgbw__bgr_565; 31725| 121| } 31726| 10| return NULL; 31727| 121|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr_565: 30380| 18| size_t src_len) { 30381| 18| size_t src_len2 = src_len / 2; 30382| 18| size_t len = (dst_len < src_len2) ? dst_len : src_len2; ------------------ | Branch (30382:16): [True: 3, False: 15] ------------------ 30383| 18| uint8_t* d = dst_ptr; 30384| 18| const uint8_t* s = src_ptr; 30385| 18| size_t n = len; 30386| | 30387| | // TODO: unroll. 30388| | 30389| 797| while (n >= 1) { ------------------ | Branch (30389:10): [True: 779, False: 18] ------------------ 30390| 779| uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 30391| 779| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))); 30392| 779| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30393| | 30394| 779| s += 1 * 2; 30395| 779| d += 1 * 1; 30396| 779| n -= 1; 30397| 779| } 30398| | 30399| 18| return len; 30400| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgr_565: 26929| 12| size_t src_len) { 26930| 12| size_t dst_len3 = dst_len / 3; 26931| 12| size_t src_len2 = src_len / 2; 26932| 12| size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2; ------------------ | Branch (26932:16): [True: 6, False: 6] ------------------ 26933| 12| uint8_t* d = dst_ptr; 26934| 12| const uint8_t* s = src_ptr; 26935| 12| size_t n = len; 26936| | 26937| | // TODO: unroll. 26938| | 26939| 397| while (n >= 1) { ------------------ | Branch (26939:10): [True: 385, False: 12] ------------------ 26940| 385| uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 26941| 385| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))); 26942| 385| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26943| | 26944| 385| s += 1 * 2; 26945| 385| d += 1 * 3; 26946| 385| n -= 1; 26947| 385| } 26948| | 26949| 12| return len; 26950| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr_565: 29060| 19| size_t src_len) { 29061| 19| size_t dst_len4 = dst_len / 4; 29062| 19| size_t src_len2 = src_len / 2; 29063| 19| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (29063:16): [True: 13, False: 6] ------------------ 29064| 19| uint8_t* d = dst_ptr; 29065| 19| const uint8_t* s = src_ptr; 29066| 19| size_t n = len; 29067| | 29068| | // TODO: unroll. 29069| | 29070| 337| while (n >= 1) { ------------------ | Branch (29070:10): [True: 318, False: 19] ------------------ 29071| 318| wuffs_base__poke_u32le__no_bounds_check( 29072| 318| d + (0 * 4), wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29073| 318| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))); 29074| | 29075| 318| s += 1 * 2; 29076| 318| d += 1 * 4; 29077| 318| n -= 1; 29078| 318| } 29079| | 29080| 19| return len; 29081| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr_565: 29329| 12| size_t src_len) { 29330| 12| size_t dst_len8 = dst_len / 8; 29331| 12| size_t src_len2 = src_len / 2; 29332| 12| size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2; ------------------ | Branch (29332:16): [True: 7, False: 5] ------------------ 29333| 12| uint8_t* d = dst_ptr; 29334| 12| const uint8_t* s = src_ptr; 29335| 12| size_t n = len; 29336| | 29337| 105| while (n >= 1) { ------------------ | Branch (29337:10): [True: 93, False: 12] ------------------ 29338| 93| wuffs_base__poke_u64le__no_bounds_check( 29339| 93| d + (0 * 8), 29340| 93| wuffs_base__color_u32__as__color_u64( 29341| 93| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29342| 93| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 29343| | 29344| 93| s += 1 * 2; 29345| 93| d += 1 * 8; 29346| 93| n -= 1; 29347| 93| } 29348| | 29349| 12| return len; 29350| 12|} 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: 6, False: 9] ------------------ 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| 191| while (n >= 1) { ------------------ | Branch (29440:10): [True: 176, False: 15] ------------------ 29441| 176| wuffs_base__poke_u24le__no_bounds_check( 29442| 176| d + (0 * 3), 29443| 176| wuffs_base__color_swap_u32_argb_abgr( 29444| 176| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29445| 176| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 29446| | 29447| 176| s += 1 * 2; 29448| 176| d += 1 * 3; 29449| 176| n -= 1; 29450| 176| } 29451| | 29452| 15| return len; 29453| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgbw__bgr_565: 29589| 28| size_t src_len) { 29590| 28| size_t dst_len4 = dst_len / 4; 29591| 28| size_t src_len2 = src_len / 2; 29592| 28| size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2; ------------------ | Branch (29592:16): [True: 13, False: 15] ------------------ 29593| 28| uint8_t* d = dst_ptr; 29594| 28| const uint8_t* s = src_ptr; 29595| 28| size_t n = len; 29596| | 29597| | // TODO: unroll. 29598| | 29599| 670| while (n >= 1) { ------------------ | Branch (29599:10): [True: 642, False: 28] ------------------ 29600| 642| wuffs_base__poke_u32le__no_bounds_check( 29601| 642| d + (0 * 4), 29602| 642| wuffs_base__color_swap_u32_argb_abgr( 29603| 642| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( 29604| 642| wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))))); 29605| | 29606| 642| s += 1 * 2; 29607| 642| d += 1 * 4; 29608| 642| n -= 1; 29609| 642| } 29610| | 29611| 28| return len; 29612| 28|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr: 31735| 129| wuffs_base__pixel_blend blend) { 31736| 129| switch (dst_pixfmt.repr) { ------------------ | Branch (31736:11): [True: 117, False: 12] ------------------ 31737| 19| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 19|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31737:5): [True: 19, False: 110] ------------------ 31738| 19| return wuffs_private_impl__swizzle_y__bgr; 31739| | 31740| 16| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 16|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31740:5): [True: 16, False: 113] ------------------ 31741| 16| return wuffs_private_impl__swizzle_bgr_565__bgr; 31742| | 31743| 7| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31743:5): [True: 7, False: 122] ------------------ 31744| 7| return wuffs_private_impl__swizzle_copy_3_3; 31745| | 31746| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31746:5): [True: 4, False: 125] ------------------ 31747| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31747:5): [True: 11, False: 118] ------------------ 31748| 15| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (31748:5): [True: 0, False: 129] ------------------ 31749| 32| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 32|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31749:5): [True: 17, False: 112] ------------------ 31750| 32|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 31751| 32| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (31751:11): [True: 32, False: 0] ------------------ 31752| 32| return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42; 31753| 32| } 31754| 0|#endif 31755| 0| return wuffs_private_impl__swizzle_bgrw__bgr; 31756| | 31757| 10| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31757:5): [True: 10, False: 119] ------------------ 31758| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (31758:5): [True: 2, False: 127] ------------------ 31759| 12| 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: 114] ------------------ 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: 119] ------------------ 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: 123] ------------------ 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: 129] ------------------ 31767| 16| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31767:5): [True: 0, False: 129] ------------------ 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| 129| } 31775| 12| return NULL; 31776| 129|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr: 30352| 19| size_t src_len) { 30353| 19| size_t src_len3 = src_len / 3; 30354| 19| size_t len = (dst_len < src_len3) ? dst_len : src_len3; ------------------ | Branch (30354:16): [True: 5, False: 14] ------------------ 30355| 19| uint8_t* d = dst_ptr; 30356| 19| const uint8_t* s = src_ptr; 30357| 19| size_t n = len; 30358| | 30359| | // TODO: unroll. 30360| | 30361| 373| while (n >= 1) { ------------------ | Branch (30361:10): [True: 354, False: 19] ------------------ 30362| 354| uint32_t s0 = 30363| 354| 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(s + (0 * 3)); 30364| 354| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30365| | 30366| 354| s += 1 * 3; 30367| 354| d += 1 * 1; 30368| 354| n -= 1; 30369| 354| } 30370| | 30371| 19| return len; 30372| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgr: 26009| 16| size_t src_len) { 26010| 16| size_t dst_len2 = dst_len / 2; 26011| 16| size_t src_len3 = src_len / 3; 26012| 16| size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3; ------------------ | Branch (26012:16): [True: 3, False: 13] ------------------ 26013| 16| uint8_t* d = dst_ptr; 26014| 16| const uint8_t* s = src_ptr; 26015| 16| size_t n = len; 26016| | 26017| | // TODO: unroll. 26018| | 26019| 410| while (n >= 1) { ------------------ | Branch (26019:10): [True: 394, False: 16] ------------------ 26020| 394| uint32_t b5 = (uint32_t)(s[0] >> 3); 26021| 394| uint32_t g6 = (uint32_t)(s[1] >> 2); 26022| 394| uint32_t r5 = (uint32_t)(s[2] >> 3); 26023| 394| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 26024| 394| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26025| | 26026| 394| s += 1 * 3; 26027| 394| d += 1 * 2; 26028| 394| n -= 1; 26029| 394| } 26030| | 26031| 16| return len; 26032| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_3_3: 25959| 16| size_t src_len) { 25960| 16| size_t dst_len3 = dst_len / 3; 25961| 16| size_t src_len3 = src_len / 3; 25962| 16| size_t len = (dst_len3 < src_len3) ? dst_len3 : src_len3; ------------------ | Branch (25962:16): [True: 4, False: 12] ------------------ 25963| 16| if (len > 0) { ------------------ | Branch (25963:7): [True: 14, False: 2] ------------------ 25964| 14| memmove(dst_ptr, src_ptr, len * 3); 25965| 14| } 25966| 16| return len; 25967| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42: 29121| 43| size_t src_len) { 29122| 43| size_t dst_len4 = dst_len / 4; 29123| 43| size_t src_len3 = src_len / 3; 29124| 43| size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3; ------------------ | Branch (29124:16): [True: 13, False: 30] ------------------ 29125| 43| uint8_t* d = dst_ptr; 29126| 43| const uint8_t* s = src_ptr; 29127| 43| size_t n = len; 29128| | 29129| 43| __m128i shuffle = _mm_set_epi8(+0x00, +0x0B, +0x0A, +0x09, // 29130| 43| +0x00, +0x08, +0x07, +0x06, // 29131| 43| +0x00, +0x05, +0x04, +0x03, // 29132| 43| +0x00, +0x02, +0x01, +0x00); 29133| 43| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 29134| 43| -0x01, +0x00, +0x00, +0x00, // 29135| 43| -0x01, +0x00, +0x00, +0x00, // 29136| 43| -0x01, +0x00, +0x00, +0x00); 29137| | 29138| 219| while (n >= 6) { ------------------ | Branch (29138:10): [True: 176, False: 43] ------------------ 29139| 176| __m128i x; 29140| 176| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 29141| 176| x = _mm_shuffle_epi8(x, shuffle); 29142| 176| x = _mm_or_si128(x, or_ff); 29143| 176| _mm_storeu_si128((__m128i*)(void*)d, x); 29144| | 29145| 176| s += 4 * 3; 29146| 176| d += 4 * 4; 29147| 176| n -= 4; 29148| 176| } 29149| | 29150| 166| while (n >= 1) { ------------------ | Branch (29150:10): [True: 123, False: 43] ------------------ 29151| 123| uint8_t b0 = s[0]; 29152| 123| uint8_t b1 = s[1]; 29153| 123| uint8_t b2 = s[2]; 29154| 123| d[0] = b0; 29155| 123| d[1] = b1; 29156| 123| d[2] = b2; 29157| 123| d[3] = 0xFF; 29158| | 29159| 123| s += 1 * 3; 29160| 123| d += 1 * 4; 29161| 123| n -= 1; 29162| 123| } 29163| | 29164| 43| return len; 29165| 43|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr: 29294| 12| size_t src_len) { 29295| 12| size_t dst_len8 = dst_len / 8; 29296| 12| size_t src_len3 = src_len / 3; 29297| 12| size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3; ------------------ | Branch (29297:16): [True: 4, False: 8] ------------------ 29298| 12| uint8_t* d = dst_ptr; 29299| 12| const uint8_t* s = src_ptr; 29300| 12| size_t n = len; 29301| | 29302| 106| while (n >= 1) { ------------------ | Branch (29302:10): [True: 94, False: 12] ------------------ 29303| 94| uint8_t s0 = s[0]; 29304| 94| uint8_t s1 = s[1]; 29305| 94| uint8_t s2 = s[2]; 29306| 94| d[0] = s0; 29307| 94| d[1] = s0; 29308| 94| d[2] = s1; 29309| 94| d[3] = s1; 29310| 94| d[4] = s2; 29311| 94| d[5] = s2; 29312| 94| d[6] = 0xFF; 29313| 94| d[7] = 0xFF; 29314| | 29315| 94| s += 1 * 3; 29316| 94| d += 1 * 8; 29317| 94| n -= 1; 29318| 94| } 29319| | 29320| 12| return len; 29321| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgb_bgr: 25792| 26| size_t src_len) { 25793| 26| size_t len = (dst_len < src_len ? dst_len : src_len) / 3; ------------------ | Branch (25793:17): [True: 5, False: 21] ------------------ 25794| 26| uint8_t* d = dst_ptr; 25795| 26| const uint8_t* s = src_ptr; 25796| | 25797| 26| size_t n = len; 25798| 699| while (n--) { ------------------ | Branch (25798:10): [True: 673, False: 26] ------------------ 25799| 673| uint8_t s0 = s[0]; 25800| 673| uint8_t s1 = s[1]; 25801| 673| uint8_t s2 = s[2]; 25802| 673| d[0] = s2; 25803| 673| d[1] = s1; 25804| 673| d[2] = s0; 25805| 673| s += 3; 25806| 673| d += 3; 25807| 673| } 25808| 26| return len; 25809| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42: 29174| 35| size_t src_len) { 29175| 35| size_t dst_len4 = dst_len / 4; 29176| 35| size_t src_len3 = src_len / 3; 29177| 35| size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3; ------------------ | Branch (29177:16): [True: 11, False: 24] ------------------ 29178| 35| uint8_t* d = dst_ptr; 29179| 35| const uint8_t* s = src_ptr; 29180| 35| size_t n = len; 29181| | 29182| 35| __m128i shuffle = _mm_set_epi8(+0x00, +0x09, +0x0A, +0x0B, // 29183| 35| +0x00, +0x06, +0x07, +0x08, // 29184| 35| +0x00, +0x03, +0x04, +0x05, // 29185| 35| +0x00, +0x00, +0x01, +0x02); 29186| 35| __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, // 29187| 35| -0x01, +0x00, +0x00, +0x00, // 29188| 35| -0x01, +0x00, +0x00, +0x00, // 29189| 35| -0x01, +0x00, +0x00, +0x00); 29190| | 29191| 209| while (n >= 6) { ------------------ | Branch (29191:10): [True: 174, False: 35] ------------------ 29192| 174| __m128i x; 29193| 174| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 29194| 174| x = _mm_shuffle_epi8(x, shuffle); 29195| 174| x = _mm_or_si128(x, or_ff); 29196| 174| _mm_storeu_si128((__m128i*)(void*)d, x); 29197| | 29198| 174| s += 4 * 3; 29199| 174| d += 4 * 4; 29200| 174| n -= 4; 29201| 174| } 29202| | 29203| 134| while (n >= 1) { ------------------ | Branch (29203:10): [True: 99, False: 35] ------------------ 29204| 99| uint8_t b0 = s[0]; 29205| 99| uint8_t b1 = s[1]; 29206| 99| uint8_t b2 = s[2]; 29207| 99| d[0] = b2; 29208| 99| d[1] = b1; 29209| 99| d[2] = b0; 29210| 99| d[3] = 0xFF; 29211| | 29212| 99| s += 1 * 3; 29213| 99| d += 1 * 4; 29214| 99| n -= 1; 29215| 99| } 29216| | 29217| 35| return len; 29218| 35|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul: 31784| 230| wuffs_base__pixel_blend blend) { 31785| 230| switch (dst_pixfmt.repr) { ------------------ | Branch (31785:11): [True: 209, False: 21] ------------------ 31786| 24| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 24|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31786:5): [True: 24, False: 206] ------------------ 31787| 24| switch (blend) { ------------------ | Branch (31787:15): [True: 24, False: 0] ------------------ 31788| 15| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31788:9): [True: 15, False: 9] ------------------ 31789| 15| return wuffs_private_impl__swizzle_y__bgra_nonpremul__src; 31790| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31790:9): [True: 9, False: 15] ------------------ 31791| 9| return wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over; 31792| 24| } 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: 197] ------------------ 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| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31804:5): [True: 19, False: 211] ------------------ 31805| 19| switch (blend) { ------------------ | Branch (31805:15): [True: 19, False: 0] ------------------ 31806| 4| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31806:9): [True: 4, False: 15] ------------------ 31807| 4| 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: 4] ------------------ 31809| 15| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over; 31810| 19| } 31811| 0| return NULL; 31812| | 31813| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (31813:5): [True: 17, False: 213] ------------------ 31814| 17| switch (blend) { ------------------ | Branch (31814:15): [True: 17, False: 0] ------------------ 31815| 0| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31815:9): [True: 0, False: 17] ------------------ 31816| 0| return wuffs_private_impl__swizzle_copy_4_4; 31817| 17| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31817:9): [True: 17, False: 0] ------------------ 31818| 17| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over; 31819| 17| } 31820| 0| return NULL; 31821| | 31822| 43| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 43|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31822:5): [True: 43, False: 187] ------------------ 31823| 43| switch (blend) { ------------------ | Branch (31823:15): [True: 43, False: 0] ------------------ 31824| 12| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31824:9): [True: 12, False: 31] ------------------ 31825| 12| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src; 31826| 31| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 31|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31826:9): [True: 31, False: 12] ------------------ 31827| 31| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over; 31828| 43| } 31829| 0| return NULL; 31830| | 31831| 4| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31831:5): [True: 4, False: 226] ------------------ 31832| 4| switch (blend) { ------------------ | Branch (31832:15): [True: 4, 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: 2] ------------------ 31834| 2| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src; 31835| 2| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 2|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31835:9): [True: 2, False: 2] ------------------ 31836| 2| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over; 31837| 4| } 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: 230] ------------------ 31841| 7| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31841:5): [True: 7, False: 223] ------------------ 31842| | // TODO. 31843| 7| break; 31844| | 31845| 22| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 22|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31845:5): [True: 22, False: 208] ------------------ 31846| 22| switch (blend) { ------------------ | Branch (31846:15): [True: 22, 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: 11] ------------------ 31848| 11| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src; 31849| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31849:9): [True: 11, False: 11] ------------------ 31850| 11| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over; 31851| 22| } 31852| 0| return NULL; 31853| | 31854| 23| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31854:5): [True: 23, False: 207] ------------------ 31855| 23| switch (blend) { ------------------ | Branch (31855:15): [True: 23, 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: 5] ------------------ 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| 5| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31863:9): [True: 5, False: 18] ------------------ 31864| 5| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over; 31865| 23| } 31866| 0| return NULL; 31867| | 31868| 17| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 17|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31868:5): [True: 17, False: 213] ------------------ 31869| 17| switch (blend) { ------------------ | Branch (31869:15): [True: 17, 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: 9] ------------------ 31871| 8| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src; 31872| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31872:9): [True: 9, False: 8] ------------------ 31873| 9| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over; 31874| 17| } 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: 230] ------------------ 31878| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31878:5): [True: 0, False: 230] ------------------ 31879| | // TODO. 31880| 0| break; 31881| 230| } 31882| 28| return NULL; 31883| 230|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src: 30408| 15| size_t src_len) { 30409| 15| size_t src_len4 = src_len / 4; 30410| 15| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30410:16): [True: 1, False: 14] ------------------ 30411| 15| uint8_t* d = dst_ptr; 30412| 15| const uint8_t* s = src_ptr; 30413| 15| size_t n = len; 30414| | 30415| | // TODO: unroll. 30416| | 30417| 261| while (n >= 1) { ------------------ | Branch (30417:10): [True: 246, False: 15] ------------------ 30418| 246| uint32_t s0 = 30419| 246| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 30420| 246| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30421| 246| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30422| | 30423| 246| s += 1 * 4; 30424| 246| d += 1 * 1; 30425| 246| n -= 1; 30426| 246| } 30427| | 30428| 15| return len; 30429| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over: 30438| 9| size_t src_len) { 30439| 9| size_t src_len4 = src_len / 4; 30440| 9| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30440:16): [True: 4, False: 5] ------------------ 30441| 9| uint8_t* d = dst_ptr; 30442| 9| const uint8_t* s = src_ptr; 30443| 9| size_t n = len; 30444| | 30445| | // TODO: unroll. 30446| | 30447| 112| while (n >= 1) { ------------------ | Branch (30447:10): [True: 103, False: 9] ------------------ 30448| 103| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30449| 103| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 30450| 103| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30451| 103| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 30452| | 30453| 103| s += 1 * 4; 30454| 103| d += 1 * 1; 30455| 103| n -= 1; 30456| 103| } 30457| | 30458| 9| return len; 30459| 9|} 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| 537| while (n >= 1) { ------------------ | Branch (26082:10): [True: 519, False: 18] ------------------ 26083| 519| wuffs_base__poke_u16le__no_bounds_check( 26084| 519| d + (0 * 2), 26085| 519| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26086| 519| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26087| 519| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 26088| | 26089| 519| s += 1 * 4; 26090| 519| d += 1 * 2; 26091| 519| n -= 1; 26092| 519| } 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: 2, False: 13] ------------------ 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| 410| while (n >= 1) { ------------------ | Branch (26146:10): [True: 395, False: 15] ------------------ 26147| | // Extract 16-bit color components. 26148| 395| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26149| 395| uint32_t sr = 0x101 * ((uint32_t)s[2]); 26150| 395| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26151| 395| uint32_t sb = 0x101 * ((uint32_t)s[0]); 26152| | 26153| | // Convert from 565 color to 16-bit color. 26154| 395| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26155| 395| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26156| 395| uint32_t dr = (0x8421 * old_r5) >> 4; 26157| 395| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26158| 395| uint32_t dg = (0x1041 * old_g6) >> 2; 26159| 395| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26160| 395| uint32_t db = (0x8421 * old_b5) >> 4; 26161| | 26162| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26163| 395| uint32_t ia = 0xFFFF - sa; 26164| | 26165| | // Composite src (nonpremul) over dst (premul). 26166| 395| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26167| 395| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26168| 395| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26169| | 26170| | // Convert from 16-bit color to 565 color and combine the components. 26171| 395| uint32_t new_r5 = 0x1F & (dr >> 11); 26172| 395| uint32_t new_g6 = 0x3F & (dg >> 10); 26173| 395| uint32_t new_b5 = 0x1F & (db >> 11); 26174| 395| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26175| 395| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26176| | 26177| 395| s += 1 * 4; 26178| 395| d += 1 * 2; 26179| 395| n -= 1; 26180| 395| } 26181| | 26182| 15| return len; 26183| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src: 26958| 14| size_t src_len) { 26959| 14| size_t dst_len3 = dst_len / 3; 26960| 14| size_t src_len4 = src_len / 4; 26961| 14| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (26961:16): [True: 1, False: 13] ------------------ 26962| 14| uint8_t* d = dst_ptr; 26963| 14| const uint8_t* s = src_ptr; 26964| 14| size_t n = len; 26965| | 26966| | // TODO: unroll. 26967| | 26968| 249| while (n >= 1) { ------------------ | Branch (26968:10): [True: 235, False: 14] ------------------ 26969| 235| uint32_t s0 = 26970| 235| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26971| 235| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 26972| 235| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 26973| | 26974| 235| s += 1 * 4; 26975| 235| d += 1 * 3; 26976| 235| n -= 1; 26977| 235| } 26978| | 26979| 14| return len; 26980| 14|} 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| 348| while (n >= 1) { ------------------ | Branch (27030:10): [True: 331, False: 17] ------------------ 27031| | // Extract 16-bit color components. 27032| 331| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27033| 331| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27034| 331| uint32_t db = 0x101 * ((uint32_t)d[0]); 27035| 331| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27036| 331| uint32_t sr = 0x101 * ((uint32_t)s[2]); 27037| 331| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27038| 331| 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| 331| uint32_t ia = 0xFFFF - sa; 27042| | 27043| | // Composite src (nonpremul) over dst (premul). 27044| 331| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27045| 331| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27046| 331| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27047| | 27048| | // Convert from 16-bit color to 8-bit color. 27049| 331| d[0] = (uint8_t)(db >> 8); 27050| 331| d[1] = (uint8_t)(dg >> 8); 27051| 331| d[2] = (uint8_t)(dr >> 8); 27052| | 27053| 331| s += 1 * 4; 27054| 331| d += 1 * 3; 27055| 331| n -= 1; 27056| 331| } 27057| | 27058| 17| return len; 27059| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_4_4: 25975| 17| size_t src_len) { 25976| 17| size_t dst_len4 = dst_len / 4; 25977| 17| size_t src_len4 = src_len / 4; 25978| 17| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (25978:16): [True: 3, False: 14] ------------------ 25979| 17| if (len > 0) { ------------------ | Branch (25979:7): [True: 15, False: 2] ------------------ 25980| 15| memmove(dst_ptr, src_ptr, len * 4); 25981| 15| } 25982| 17| return len; 25983| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over: 27614| 26| size_t src_len) { 27615| 26| size_t dst_len4 = dst_len / 4; 27616| 26| size_t src_len4 = src_len / 4; 27617| 26| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27617:16): [True: 8, False: 18] ------------------ 27618| 26| uint8_t* d = dst_ptr; 27619| 26| const uint8_t* s = src_ptr; 27620| 26| size_t n = len; 27621| | 27622| 303| while (n >= 1) { ------------------ | Branch (27622:10): [True: 277, False: 26] ------------------ 27623| 277| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27624| 277| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27625| 277| wuffs_base__poke_u32le__no_bounds_check( 27626| 277| d + (0 * 4), 27627| 277| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27628| | 27629| 277| s += 1 * 4; 27630| 277| d += 1 * 4; 27631| 277| n -= 1; 27632| 277| } 27633| | 27634| 26| return len; 27635| 26|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src: 28015| 12| size_t src_len) { 28016| 12| size_t dst_len8 = dst_len / 8; 28017| 12| size_t src_len4 = src_len / 4; 28018| 12| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28018:16): [True: 5, False: 7] ------------------ 28019| 12| uint8_t* d = dst_ptr; 28020| 12| const uint8_t* s = src_ptr; 28021| | 28022| 12| size_t n = len; 28023| 137| while (n >= 1) { ------------------ | Branch (28023:10): [True: 125, False: 12] ------------------ 28024| 125| uint8_t s0 = s[0]; 28025| 125| uint8_t s1 = s[1]; 28026| 125| uint8_t s2 = s[2]; 28027| 125| uint8_t s3 = s[3]; 28028| 125| d[0] = s0; 28029| 125| d[1] = s0; 28030| 125| d[2] = s1; 28031| 125| d[3] = s1; 28032| 125| d[4] = s2; 28033| 125| d[5] = s2; 28034| 125| d[6] = s3; 28035| 125| d[7] = s3; 28036| | 28037| 125| s += 1 * 4; 28038| 125| d += 1 * 8; 28039| 125| n -= 1; 28040| 125| } 28041| 12| return len; 28042| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over: 28051| 31| size_t src_len) { 28052| 31| size_t dst_len8 = dst_len / 8; 28053| 31| size_t src_len4 = src_len / 4; 28054| 31| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28054:16): [True: 12, False: 19] ------------------ 28055| 31| uint8_t* d = dst_ptr; 28056| 31| const uint8_t* s = src_ptr; 28057| | 28058| 31| size_t n = len; 28059| 159| while (n >= 1) { ------------------ | Branch (28059:10): [True: 128, False: 31] ------------------ 28060| 128| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28061| 128| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28062| 128| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28063| 128| wuffs_base__poke_u64le__no_bounds_check( 28064| 128| d + (0 * 8), 28065| 128| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28066| | 28067| 128| s += 1 * 4; 28068| 128| d += 1 * 8; 28069| 128| n -= 1; 28070| 128| } 28071| 31| return len; 28072| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over: 28508| 17| size_t src_len) { 28509| 17| size_t dst_len4 = dst_len / 4; 28510| 17| size_t src_len4 = src_len / 4; 28511| 17| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28511:16): [True: 3, False: 14] ------------------ 28512| 17| uint8_t* d = dst_ptr; 28513| 17| const uint8_t* s = src_ptr; 28514| 17| size_t n = len; 28515| | 28516| | // TODO: unroll. 28517| | 28518| 285| while (n >= 1) { ------------------ | Branch (28518:10): [True: 268, False: 17] ------------------ 28519| 268| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28520| 268| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 28521| 268| wuffs_base__poke_u32le__no_bounds_check( 28522| 268| d + (0 * 4), 28523| 268| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28524| | 28525| 268| s += 1 * 4; 28526| 268| d += 1 * 4; 28527| 268| n -= 1; 28528| 268| } 28529| | 28530| 17| return len; 28531| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src: 27268| 11| size_t src_len) { 27269| 11| size_t dst_len3 = dst_len / 3; 27270| 11| size_t src_len4 = src_len / 4; 27271| 11| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27271:16): [True: 1, False: 10] ------------------ 27272| 11| uint8_t* d = dst_ptr; 27273| 11| const uint8_t* s = src_ptr; 27274| 11| size_t n = len; 27275| | 27276| | // TODO: unroll. 27277| | 27278| 222| while (n >= 1) { ------------------ | Branch (27278:10): [True: 211, False: 11] ------------------ 27279| 211| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27280| 211| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 27281| 211| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 27282| 211| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27283| | 27284| 211| s += 1 * 4; 27285| 211| d += 1 * 3; 27286| 211| n -= 1; 27287| 211| } 27288| | 27289| 11| return len; 27290| 11|} 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: 2, False: 16] ------------------ 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| 229| while (n >= 1) { ------------------ | Branch (27340:10): [True: 211, False: 18] ------------------ 27341| | // Extract 16-bit color components. 27342| 211| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27343| 211| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27344| 211| uint32_t db = 0x101 * ((uint32_t)d[0]); 27345| 211| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27346| 211| uint32_t sb = 0x101 * ((uint32_t)s[2]); 27347| 211| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27348| 211| 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| 211| uint32_t ia = 0xFFFF - sa; 27352| | 27353| | // Composite src (nonpremul) over dst (premul). 27354| 211| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27355| 211| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27356| 211| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27357| | 27358| | // Convert from 16-bit color to 8-bit color. 27359| 211| d[0] = (uint8_t)(db >> 8); 27360| 211| d[1] = (uint8_t)(dg >> 8); 27361| 211| d[2] = (uint8_t)(dr >> 8); 27362| | 27363| 211| s += 1 * 4; 27364| 211| d += 1 * 3; 27365| 211| n -= 1; 27366| 211| } 27367| | 27368| 18| return len; 27369| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42: 25820| 34| size_t src_len) { 25821| 34| size_t len = (dst_len < src_len ? dst_len : src_len) / 4; ------------------ | Branch (25821:17): [True: 10, False: 24] ------------------ 25822| 34| uint8_t* d = dst_ptr; 25823| 34| const uint8_t* s = src_ptr; 25824| 34| size_t n = len; 25825| | 25826| 34| __m128i shuffle = _mm_set_epi8(+0x0F, +0x0C, +0x0D, +0x0E, // 25827| 34| +0x0B, +0x08, +0x09, +0x0A, // 25828| 34| +0x07, +0x04, +0x05, +0x06, // 25829| 34| +0x03, +0x00, +0x01, +0x02); 25830| | 25831| 199| while (n >= 4) { ------------------ | Branch (25831:10): [True: 165, False: 34] ------------------ 25832| 165| __m128i x; 25833| 165| x = _mm_lddqu_si128((const __m128i*)(const void*)s); 25834| 165| x = _mm_shuffle_epi8(x, shuffle); 25835| 165| _mm_storeu_si128((__m128i*)(void*)d, x); 25836| | 25837| 165| s += 4 * 4; 25838| 165| d += 4 * 4; 25839| 165| n -= 4; 25840| 165| } 25841| | 25842| 71| while (n--) { ------------------ | Branch (25842:10): [True: 37, False: 34] ------------------ 25843| 37| uint8_t s0 = s[0]; 25844| 37| uint8_t s1 = s[1]; 25845| 37| uint8_t s2 = s[2]; 25846| 37| uint8_t s3 = s[3]; 25847| 37| d[0] = s2; 25848| 37| d[1] = s1; 25849| 37| d[2] = s0; 25850| 37| d[3] = s3; 25851| 37| s += 4; 25852| 37| d += 4; 25853| 37| } 25854| 34| return len; 25855| 34|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over: 27860| 29| size_t src_len) { 27861| 29| size_t dst_len4 = dst_len / 4; 27862| 29| size_t src_len4 = src_len / 4; 27863| 29| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27863:16): [True: 4, False: 25] ------------------ 27864| 29| uint8_t* d = dst_ptr; 27865| 29| const uint8_t* s = src_ptr; 27866| 29| size_t n = len; 27867| | 27868| 557| while (n >= 1) { ------------------ | Branch (27868:10): [True: 528, False: 29] ------------------ 27869| 528| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27870| 528| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27871| 528| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27872| 528| wuffs_base__poke_u32le__no_bounds_check( 27873| 528| d + (0 * 4), 27874| 528| wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0)); 27875| | 27876| 528| s += 1 * 4; 27877| 528| d += 1 * 4; 27878| 528| n -= 1; 27879| 528| } 27880| | 27881| 29| return len; 27882| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over: 28738| 17| size_t src_len) { 28739| 17| size_t dst_len4 = dst_len / 4; 28740| 17| size_t src_len4 = src_len / 4; 28741| 17| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28741:16): [True: 2, False: 15] ------------------ 28742| 17| uint8_t* d = dst_ptr; 28743| 17| const uint8_t* s = src_ptr; 28744| 17| size_t n = len; 28745| | 28746| | // TODO: unroll. 28747| | 28748| 292| while (n >= 1) { ------------------ | Branch (28748:10): [True: 275, False: 17] ------------------ 28749| 275| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28750| 275| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28751| 275| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28752| 275| wuffs_base__poke_u32le__no_bounds_check( 28753| 275| d + (0 * 4), 28754| 275| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 28755| | 28756| 275| s += 1 * 4; 28757| 275| d += 1 * 4; 28758| 275| n -= 1; 28759| 275| } 28760| | 28761| 17| return len; 28762| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le: 31891| 299| wuffs_base__pixel_blend blend) { 31892| 299| switch (dst_pixfmt.repr) { ------------------ | Branch (31892:11): [True: 280, False: 19] ------------------ 31893| 18| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 18|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31893:5): [True: 18, False: 281] ------------------ 31894| 18| switch (blend) { ------------------ | Branch (31894:15): [True: 18, 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: 10] ------------------ 31896| 8| return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src; 31897| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31897:9): [True: 10, False: 8] ------------------ 31898| 10| return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over; 31899| 18| } 31900| 0| return NULL; 31901| | 31902| 36| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 36|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (31902:5): [True: 36, False: 263] ------------------ 31903| 36| switch (blend) { ------------------ | Branch (31903:15): [True: 36, False: 0] ------------------ 31904| 21| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 21|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31904:9): [True: 21, False: 15] ------------------ 31905| 21| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src; 31906| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31906:9): [True: 15, False: 21] ------------------ 31907| 15| return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over; 31908| 36| } 31909| 0| return NULL; 31910| | 31911| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (31911:5): [True: 19, False: 280] ------------------ 31912| 19| switch (blend) { ------------------ | Branch (31912:15): [True: 19, False: 0] ------------------ 31913| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31913:9): [True: 10, False: 9] ------------------ 31914| 10| 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: 10] ------------------ 31916| 9| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src_over; 31917| 19| } 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: 251] ------------------ 31921| 48| switch (blend) { ------------------ | Branch (31921:15): [True: 48, False: 0] ------------------ 31922| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31922:9): [True: 13, False: 35] ------------------ 31923| 13| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src; 31924| 35| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 35|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31924:9): [True: 35, False: 13] ------------------ 31925| 35| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over; 31926| 48| } 31927| 0| return NULL; 31928| | 31929| 35| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 35|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (31929:5): [True: 35, False: 264] ------------------ 31930| 35| switch (blend) { ------------------ | Branch (31930:15): [True: 35, 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: 31] ------------------ 31932| 4| return wuffs_private_impl__swizzle_copy_8_8; 31933| 31| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 31|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31933:9): [True: 31, False: 4] ------------------ 31934| 31| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over; 31935| 35| } 31936| 0| return NULL; 31937| | 31938| 28| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 28|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (31938:5): [True: 28, False: 271] ------------------ 31939| 28| switch (blend) { ------------------ | Branch (31939:15): [True: 28, False: 0] ------------------ 31940| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31940:9): [True: 10, False: 18] ------------------ 31941| 10| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src; 31942| 18| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31942:9): [True: 18, False: 10] ------------------ 31943| 18| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over; 31944| 28| } 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: 299] ------------------ 31948| 1| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 1|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (31948:5): [True: 1, False: 298] ------------------ 31949| | // TODO. 31950| 1| break; 31951| | 31952| 26| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (31952:5): [True: 26, False: 273] ------------------ 31953| 26| switch (blend) { ------------------ | Branch (31953:15): [True: 26, 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: 11] ------------------ 31955| 15| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src; 31956| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31956:9): [True: 11, False: 15] ------------------ 31957| 11| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over; 31958| 26| } 31959| 0| return NULL; 31960| | 31961| 43| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (31961:5): [True: 43, False: 256] ------------------ 31962| 43| switch (blend) { ------------------ | Branch (31962:15): [True: 43, False: 0] ------------------ 31963| 15| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31963:9): [True: 15, False: 28] ------------------ 31964| 15| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src; 31965| 28| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 28|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31965:9): [True: 28, False: 15] ------------------ 31966| 28| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over; 31967| 43| } 31968| 0| break; 31969| | 31970| 26| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 26|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (31970:5): [True: 26, False: 273] ------------------ 31971| 26| switch (blend) { ------------------ | Branch (31971:15): [True: 26, False: 0] ------------------ 31972| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31972:9): [True: 13, False: 13] ------------------ 31973| 13| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src; 31974| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31974:9): [True: 13, False: 13] ------------------ 31975| 13| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over; 31976| 26| } 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: 299] ------------------ 31980| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (31980:5): [True: 0, False: 299] ------------------ 31981| | // TODO. 31982| 0| break; 31983| 299| } 31984| 20| return NULL; 31985| 299|} 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| 69| while (n >= 1) { ------------------ | Branch (30477:10): [True: 61, False: 8] ------------------ 30478| 61| d[0] = wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray( 30479| 61| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 30480| | 30481| 61| s += 1 * 8; 30482| 61| d += 1 * 1; 30483| 61| n -= 1; 30484| 61| } 30485| | 30486| 8| return len; 30487| 8|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray: 4629| 61| uint64_t argb_nonpremul) { 4630| 61| uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); 4631| | 4632| 61| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); 4633| 61| r16 = (r16 * a16) / 0xFFFF; 4634| 61| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); 4635| 61| g16 = (g16 * a16) / 0xFFFF; 4636| 61| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); 4637| 61| 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| 61| uint32_t weighted_average = 4646| 61| (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; 4647| 61| return (uint8_t)(weighted_average >> 24); 4648| 61|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over: 30496| 10| size_t src_len) { 30497| 10| size_t src_len8 = src_len / 8; 30498| 10| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (30498:16): [True: 2, False: 8] ------------------ 30499| 10| uint8_t* d = dst_ptr; 30500| 10| const uint8_t* s = src_ptr; 30501| 10| size_t n = len; 30502| | 30503| | // TODO: unroll. 30504| | 30505| 75| while (n >= 1) { ------------------ | Branch (30505:10): [True: 65, False: 10] ------------------ 30506| | // Extract 16-bit color components. 30507| 65| uint32_t dr = 0x101 * ((uint32_t)d[0]); 30508| 65| uint32_t dg = 0x101 * ((uint32_t)d[0]); 30509| 65| uint32_t db = 0x101 * ((uint32_t)d[0]); 30510| 65| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 30511| 65| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 30512| 65| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 30513| 65| 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| 65| uint32_t ia = 0xFFFF - sa; 30517| | 30518| | // Composite src (nonpremul) over dst (premul). 30519| 65| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 30520| 65| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 30521| 65| db = ((sb * sa) + (db * ia)) / 0xFFFF; 30522| | 30523| | // Convert to 16-bit color to 8-bit gray. 30524| 65| uint32_t weighted_average = 30525| 65| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 30526| 65| d[0] = (uint8_t)(weighted_average >> 24); 30527| | 30528| 65| s += 1 * 8; 30529| 65| d += 1 * 1; 30530| 65| n -= 1; 30531| 65| } 30532| | 30533| 10| return len; 30534| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src: 26104| 21| size_t src_len) { 26105| 21| size_t dst_len2 = dst_len / 2; 26106| 21| size_t src_len8 = src_len / 8; 26107| 21| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (26107:16): [True: 2, False: 19] ------------------ 26108| 21| uint8_t* d = dst_ptr; 26109| 21| const uint8_t* s = src_ptr; 26110| 21| size_t n = len; 26111| | 26112| | // TODO: unroll. 26113| | 26114| 217| while (n >= 1) { ------------------ | Branch (26114:10): [True: 196, False: 21] ------------------ 26115| 196| wuffs_base__poke_u16le__no_bounds_check( 26116| 196| d + (0 * 2), 26117| 196| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26118| 196| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 26119| 196| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 26120| | 26121| 196| s += 1 * 8; 26122| 196| d += 1 * 2; 26123| 196| n -= 1; 26124| 196| } 26125| | 26126| 21| return len; 26127| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over: 26192| 15| size_t src_len) { 26193| 15| size_t dst_len2 = dst_len / 2; 26194| 15| size_t src_len8 = src_len / 8; 26195| 15| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (26195:16): [True: 1, False: 14] ------------------ 26196| 15| uint8_t* d = dst_ptr; 26197| 15| const uint8_t* s = src_ptr; 26198| 15| size_t n = len; 26199| | 26200| | // TODO: unroll. 26201| | 26202| 195| while (n >= 1) { ------------------ | Branch (26202:10): [True: 180, False: 15] ------------------ 26203| | // Extract 16-bit color components. 26204| 180| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26205| 180| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26206| 180| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26207| 180| 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| 180| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26211| 180| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26212| 180| uint32_t dr = (0x8421 * old_r5) >> 4; 26213| 180| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26214| 180| uint32_t dg = (0x1041 * old_g6) >> 2; 26215| 180| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26216| 180| uint32_t db = (0x8421 * old_b5) >> 4; 26217| | 26218| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26219| 180| uint32_t ia = 0xFFFF - sa; 26220| | 26221| | // Composite src (nonpremul) over dst (premul). 26222| 180| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26223| 180| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26224| 180| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26225| | 26226| | // Convert from 16-bit color to 565 color and combine the components. 26227| 180| uint32_t new_r5 = 0x1F & (dr >> 11); 26228| 180| uint32_t new_g6 = 0x3F & (dg >> 10); 26229| 180| uint32_t new_b5 = 0x1F & (db >> 11); 26230| 180| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26231| 180| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26232| | 26233| 180| s += 1 * 8; 26234| 180| d += 1 * 2; 26235| 180| n -= 1; 26236| 180| } 26237| | 26238| 15| return len; 26239| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src: 26989| 10| size_t src_len) { 26990| 10| size_t dst_len3 = dst_len / 3; 26991| 10| size_t src_len8 = src_len / 8; 26992| 10| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (26992:16): [True: 1, False: 9] ------------------ 26993| 10| uint8_t* d = dst_ptr; 26994| 10| const uint8_t* s = src_ptr; 26995| 10| size_t n = len; 26996| | 26997| | // TODO: unroll. 26998| | 26999| 109| while (n >= 1) { ------------------ | Branch (26999:10): [True: 99, False: 10] ------------------ 27000| 99| uint32_t s0 = 27001| 99| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 27002| 99| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 27003| 99| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27004| | 27005| 99| s += 1 * 8; 27006| 99| d += 1 * 3; 27007| 99| n -= 1; 27008| 99| } 27009| | 27010| 10| return len; 27011| 10|} 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| 78| while (n >= 1) { ------------------ | Branch (27078:10): [True: 69, False: 9] ------------------ 27079| | // Extract 16-bit color components. 27080| 69| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27081| 69| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27082| 69| uint32_t db = 0x101 * ((uint32_t)d[0]); 27083| 69| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27084| 69| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27085| 69| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27086| 69| 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| 69| uint32_t ia = 0xFFFF - sa; 27090| | 27091| | // Composite src (nonpremul) over dst (premul). 27092| 69| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27093| 69| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27094| 69| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27095| | 27096| | // Convert from 16-bit color to 8-bit color. 27097| 69| d[0] = (uint8_t)(db >> 8); 27098| 69| d[1] = (uint8_t)(dg >> 8); 27099| 69| d[2] = (uint8_t)(dr >> 8); 27100| | 27101| 69| s += 1 * 8; 27102| 69| d += 1 * 3; 27103| 69| n -= 1; 27104| 69| } 27105| | 27106| 9| return len; 27107| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src: 27644| 13| size_t src_len) { 27645| 13| size_t dst_len4 = dst_len / 4; 27646| 13| size_t src_len8 = src_len / 8; 27647| 13| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27647:16): [True: 1, False: 12] ------------------ 27648| 13| uint8_t* d = dst_ptr; 27649| 13| const uint8_t* s = src_ptr; 27650| | 27651| 13| size_t n = len; 27652| 138| while (n >= 1) { ------------------ | Branch (27652:10): [True: 125, False: 13] ------------------ 27653| 125| wuffs_base__poke_u32le__no_bounds_check( 27654| 125| d + (0 * 4), wuffs_base__color_u64__as__color_u32( 27655| 125| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 27656| | 27657| 125| s += 1 * 8; 27658| 125| d += 1 * 4; 27659| 125| n -= 1; 27660| 125| } 27661| 13| return len; 27662| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over: 27671| 35| size_t src_len) { 27672| 35| size_t dst_len4 = dst_len / 4; 27673| 35| size_t src_len8 = src_len / 8; 27674| 35| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27674:16): [True: 1, False: 34] ------------------ 27675| 35| uint8_t* d = dst_ptr; 27676| 35| const uint8_t* s = src_ptr; 27677| 35| size_t n = len; 27678| | 27679| 398| while (n >= 1) { ------------------ | Branch (27679:10): [True: 363, False: 35] ------------------ 27680| 363| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 27681| 363| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 27682| 363| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27683| 363| wuffs_base__poke_u32le__no_bounds_check( 27684| 363| d + (0 * 4), 27685| 363| wuffs_base__color_u64__as__color_u32( 27686| 363| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, 27687| 363| s0))); 27688| | 27689| 363| s += 1 * 8; 27690| 363| d += 1 * 4; 27691| 363| n -= 1; 27692| 363| } 27693| | 27694| 35| return len; 27695| 35|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_8_8: 25991| 5| size_t src_len) { 25992| 5| size_t dst_len8 = dst_len / 8; 25993| 5| size_t src_len8 = src_len / 8; 25994| 5| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (25994:16): [True: 3, False: 2] ------------------ 25995| 5| if (len > 0) { ------------------ | Branch (25995:7): [True: 4, False: 1] ------------------ 25996| 4| memmove(dst_ptr, src_ptr, len * 8); 25997| 4| } 25998| 5| return len; 25999| 5|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over: 28081| 31| size_t src_len) { 28082| 31| size_t dst_len8 = dst_len / 8; 28083| 31| size_t src_len8 = src_len / 8; 28084| 31| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (28084:16): [True: 4, False: 27] ------------------ 28085| 31| uint8_t* d = dst_ptr; 28086| 31| const uint8_t* s = src_ptr; 28087| | 28088| 31| size_t n = len; 28089| 241| while (n >= 1) { ------------------ | Branch (28089:10): [True: 210, False: 31] ------------------ 28090| 210| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28091| 210| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28092| 210| wuffs_base__poke_u64le__no_bounds_check( 28093| 210| d + (0 * 8), 28094| 210| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28095| | 28096| 210| s += 1 * 8; 28097| 210| d += 1 * 8; 28098| 210| n -= 1; 28099| 210| } 28100| 31| return len; 28101| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src: 28477| 10| size_t src_len) { 28478| 10| size_t dst_len4 = dst_len / 4; 28479| 10| size_t src_len8 = src_len / 8; 28480| 10| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28480:16): [True: 2, False: 8] ------------------ 28481| 10| uint8_t* d = dst_ptr; 28482| 10| const uint8_t* s = src_ptr; 28483| 10| size_t n = len; 28484| | 28485| | // TODO: unroll. 28486| | 28487| 121| while (n >= 1) { ------------------ | Branch (28487:10): [True: 111, False: 10] ------------------ 28488| 111| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28489| 111| wuffs_base__poke_u32le__no_bounds_check( 28490| 111| d + (0 * 4), 28491| 111| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(s0)); 28492| | 28493| 111| s += 1 * 8; 28494| 111| d += 1 * 4; 28495| 111| n -= 1; 28496| 111| } 28497| | 28498| 10| return len; 28499| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over: 28540| 18| size_t src_len) { 28541| 18| size_t dst_len4 = dst_len / 4; 28542| 18| size_t src_len8 = src_len / 8; 28543| 18| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28543:16): [True: 2, False: 16] ------------------ 28544| 18| uint8_t* d = dst_ptr; 28545| 18| const uint8_t* s = src_ptr; 28546| 18| size_t n = len; 28547| | 28548| | // TODO: unroll. 28549| | 28550| 236| while (n >= 1) { ------------------ | Branch (28550:10): [True: 218, False: 18] ------------------ 28551| 218| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28552| 218| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28553| 218| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28554| 218| wuffs_base__poke_u32le__no_bounds_check( 28555| 218| d + (0 * 4), 28556| 218| wuffs_base__color_u64__as__color_u32( 28557| 218| wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0))); 28558| | 28559| 218| s += 1 * 8; 28560| 218| d += 1 * 4; 28561| 218| n -= 1; 28562| 218| } 28563| | 28564| 18| return len; 28565| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u64_axxx: 25643| 327| uint64_t src_nonpremul) { 25644| | // Extract components. 25645| 327| uint64_t da = 0xFFFF & (dst_premul >> 48); 25646| 327| uint64_t dr = 0xFFFF & (dst_premul >> 32); 25647| 327| uint64_t dg = 0xFFFF & (dst_premul >> 16); 25648| 327| uint64_t db = 0xFFFF & (dst_premul >> 0); 25649| 327| uint64_t sa = 0xFFFF & (src_nonpremul >> 48); 25650| 327| uint64_t sr = 0xFFFF & (src_nonpremul >> 32); 25651| 327| uint64_t sg = 0xFFFF & (src_nonpremul >> 16); 25652| 327| uint64_t sb = 0xFFFF & (src_nonpremul >> 0); 25653| | 25654| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25655| 327| uint64_t ia = 0xFFFF - sa; 25656| | 25657| | // Composite src (nonpremul) over dst (premul). 25658| 327| da = sa + ((da * ia) / 0xFFFF); 25659| 327| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 25660| 327| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 25661| 327| db = ((sb * sa) + (db * ia)) / 0xFFFF; 25662| | 25663| | // Combine components. 25664| 327| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25665| 327|} 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: 4, False: 11] ------------------ 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| 146| while (n >= 1) { ------------------ | Branch (27309:10): [True: 131, False: 15] ------------------ 27310| 131| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27311| 131| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 27312| 131| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 27313| 131| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27314| | 27315| 131| s += 1 * 8; 27316| 131| d += 1 * 3; 27317| 131| n -= 1; 27318| 131| } 27319| | 27320| 15| return len; 27321| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over: 27378| 11| size_t src_len) { 27379| 11| size_t dst_len3 = dst_len / 3; 27380| 11| size_t src_len8 = src_len / 8; 27381| 11| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27381:16): [True: 1, False: 10] ------------------ 27382| 11| uint8_t* d = dst_ptr; 27383| 11| const uint8_t* s = src_ptr; 27384| 11| size_t n = len; 27385| | 27386| | // TODO: unroll. 27387| | 27388| 142| while (n >= 1) { ------------------ | Branch (27388:10): [True: 131, False: 11] ------------------ 27389| | // Extract 16-bit color components. 27390| 131| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27391| 131| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27392| 131| uint32_t db = 0x101 * ((uint32_t)d[0]); 27393| 131| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27394| 131| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27395| 131| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27396| 131| 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| 131| uint32_t ia = 0xFFFF - sa; 27400| | 27401| | // Composite src (nonpremul) over dst (premul). 27402| 131| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 27403| 131| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 27404| 131| db = ((sb * sa) + (db * ia)) / 0xFFFF; 27405| | 27406| | // Convert from 16-bit color to 8-bit color. 27407| 131| d[0] = (uint8_t)(db >> 8); 27408| 131| d[1] = (uint8_t)(dg >> 8); 27409| 131| d[2] = (uint8_t)(dr >> 8); 27410| | 27411| 131| s += 1 * 8; 27412| 131| d += 1 * 3; 27413| 131| n -= 1; 27414| 131| } 27415| | 27416| 11| return len; 27417| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src: 29464| 15| size_t src_len) { 29465| 15| size_t dst_len4 = dst_len / 4; 29466| 15| size_t src_len8 = src_len / 8; 29467| 15| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29467:16): [True: 4, False: 11] ------------------ 29468| 15| uint8_t* d = dst_ptr; 29469| 15| const uint8_t* s = src_ptr; 29470| | 29471| 15| size_t n = len; 29472| 161| while (n >= 1) { ------------------ | Branch (29472:10): [True: 146, False: 15] ------------------ 29473| 146| wuffs_base__poke_u32le__no_bounds_check( 29474| 146| d + (0 * 4), 29475| 146| wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr( 29476| 146| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 29477| | 29478| 146| s += 1 * 8; 29479| 146| d += 1 * 4; 29480| 146| n -= 1; 29481| 146| } 29482| 15| return len; 29483| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr: 24486| 500|wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) { 24487| 500| uint32_t a = ((uint32_t)(0xFF & (c >> 56))); 24488| 500| uint32_t r = ((uint32_t)(0xFF & (c >> 40))); 24489| 500| uint32_t g = ((uint32_t)(0xFF & (c >> 24))); 24490| 500| uint32_t b = ((uint32_t)(0xFF & (c >> 8))); 24491| 500| return (a << 24) | (b << 16) | (g << 8) | (r << 0); 24492| 500|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over: 29492| 28| size_t src_len) { 29493| 28| size_t dst_len4 = dst_len / 4; 29494| 28| size_t src_len8 = src_len / 8; 29495| 28| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29495:16): [True: 2, False: 26] ------------------ 29496| 28| uint8_t* d = dst_ptr; 29497| 28| const uint8_t* s = src_ptr; 29498| 28| size_t n = len; 29499| | 29500| 219| while (n >= 1) { ------------------ | Branch (29500:10): [True: 191, False: 28] ------------------ 29501| 191| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 29502| 191| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 29503| 191| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 29504| 191| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 29505| 191| wuffs_base__poke_u32le__no_bounds_check( 29506| 191| d + (0 * 4), 29507| 191| wuffs_base__color_u64__as__color_u32( 29508| 191| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, 29509| 191| s0))); 29510| | 29511| 191| s += 1 * 8; 29512| 191| d += 1 * 4; 29513| 191| n -= 1; 29514| 191| } 29515| | 29516| 28| return len; 29517| 28|} pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u64_argb_abgr: 4839| 572|wuffs_base__color_swap_u64_argb_abgr(uint64_t u) { 4840| 572| uint64_t o = u & 0xFFFF0000FFFF0000ull; 4841| 572| uint64_t r = u & 0x0000FFFF00000000ull; 4842| 572| uint64_t b = u & 0x000000000000FFFFull; 4843| 572| return o | (r >> 32) | (b << 32); 4844| 572|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src: 28771| 13| size_t src_len) { 28772| 13| size_t dst_len4 = dst_len / 4; 28773| 13| size_t src_len8 = src_len / 8; 28774| 13| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28774:16): [True: 1, False: 12] ------------------ 28775| 13| uint8_t* d = dst_ptr; 28776| 13| const uint8_t* s = src_ptr; 28777| 13| size_t n = len; 28778| | 28779| | // TODO: unroll. 28780| | 28781| 102| while (n >= 1) { ------------------ | Branch (28781:10): [True: 89, False: 13] ------------------ 28782| 89| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28783| 89| wuffs_base__poke_u32le__no_bounds_check( 28784| 89| d + (0 * 4), 28785| 89| wuffs_base__color_swap_u32_argb_abgr( 28786| 89| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( 28787| 89| s0))); 28788| | 28789| 89| s += 1 * 8; 28790| 89| d += 1 * 4; 28791| 89| n -= 1; 28792| 89| } 28793| | 28794| 13| return len; 28795| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over: 28804| 13| size_t src_len) { 28805| 13| size_t dst_len4 = dst_len / 4; 28806| 13| size_t src_len8 = src_len / 8; 28807| 13| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28807:16): [True: 2, False: 11] ------------------ 28808| 13| uint8_t* d = dst_ptr; 28809| 13| const uint8_t* s = src_ptr; 28810| 13| size_t n = len; 28811| | 28812| | // TODO: unroll. 28813| | 28814| 122| while (n >= 1) { ------------------ | Branch (28814:10): [True: 109, False: 13] ------------------ 28815| 109| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28816| 109| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28817| 109| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28818| 109| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28819| 109| wuffs_base__poke_u32le__no_bounds_check( 28820| 109| d + (0 * 4), 28821| 109| wuffs_base__color_u64__as__color_u32( 28822| 109| wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0))); 28823| | 28824| 109| s += 1 * 8; 28825| 109| d += 1 * 4; 28826| 109| n -= 1; 28827| 109| } 28828| | 28829| 13| return len; 28830| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul: 31993| 267| wuffs_base__pixel_blend blend) { 31994| 267| switch (dst_pixfmt.repr) { ------------------ | Branch (31994:11): [True: 244, False: 23] ------------------ 31995| 29| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 29|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (31995:5): [True: 29, False: 238] ------------------ 31996| 29| switch (blend) { ------------------ | Branch (31996:15): [True: 29, False: 0] ------------------ 31997| 13| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (31997:9): [True: 13, False: 16] ------------------ 31998| 13| return wuffs_private_impl__swizzle_y__bgra_premul__src; 31999| 16| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (31999:9): [True: 16, False: 13] ------------------ 32000| 16| return wuffs_private_impl__swizzle_y__bgra_premul__src_over; 32001| 29| } 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: 248] ------------------ 32005| 19| switch (blend) { ------------------ | Branch (32005:15): [True: 19, False: 0] ------------------ 32006| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32006:9): [True: 10, False: 9] ------------------ 32007| 10| return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src; 32008| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32008:9): [True: 9, False: 10] ------------------ 32009| 9| return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over; 32010| 19| } 32011| 0| return NULL; 32012| | 32013| 20| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32013:5): [True: 20, False: 247] ------------------ 32014| 20| switch (blend) { ------------------ | Branch (32014:15): [True: 20, False: 0] ------------------ 32015| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32015:9): [True: 9, False: 11] ------------------ 32016| 9| return wuffs_private_impl__swizzle_bgr__bgra_premul__src; 32017| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32017:9): [True: 11, False: 9] ------------------ 32018| 11| return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; 32019| 20| } 32020| 0| return NULL; 32021| | 32022| 27| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 27|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32022:5): [True: 27, False: 240] ------------------ 32023| 27| switch (blend) { ------------------ | Branch (32023:15): [True: 27, False: 0] ------------------ 32024| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32024:9): [True: 16, False: 11] ------------------ 32025| 16| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src; 32026| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32026:9): [True: 11, False: 16] ------------------ 32027| 11| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; 32028| 27| } 32029| 0| return NULL; 32030| | 32031| 60| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 60|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32031:5): [True: 60, False: 207] ------------------ 32032| 60| switch (blend) { ------------------ | Branch (32032:15): [True: 60, False: 0] ------------------ 32033| 31| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 31|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32033:9): [True: 31, False: 29] ------------------ 32034| 31| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src; 32035| 29| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 29|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32035:9): [True: 29, False: 31] ------------------ 32036| 29| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over; 32037| 60| } 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: 249] ------------------ 32041| 18| switch (blend) { ------------------ | Branch (32041:15): [True: 18, False: 0] ------------------ 32042| 11| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32042:9): [True: 11, False: 7] ------------------ 32043| 11| return wuffs_private_impl__swizzle_copy_4_4; 32044| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32044:9): [True: 7, False: 11] ------------------ 32045| 7| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; 32046| 18| } 32047| 0| return NULL; 32048| | 32049| 15| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 15|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32049:5): [True: 15, False: 252] ------------------ 32050| 15| switch (blend) { ------------------ | Branch (32050:15): [True: 15, False: 0] ------------------ 32051| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32051:9): [True: 10, False: 5] ------------------ 32052| 10| return wuffs_private_impl__swizzle_bgr__rgba_premul__src; 32053| 5| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32053:9): [True: 5, False: 10] ------------------ 32054| 5| return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; 32055| 15| } 32056| 0| return NULL; 32057| | 32058| 49| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32058:5): [True: 49, False: 218] ------------------ 32059| 49| switch (blend) { ------------------ | Branch (32059:15): [True: 49, False: 0] ------------------ 32060| 27| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 27|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32060:9): [True: 27, False: 22] ------------------ 32061| 27| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src; 32062| 22| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 22|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32062:9): [True: 22, False: 27] ------------------ 32063| 22| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; 32064| 49| } 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: 260] ------------------ 32068| 7| switch (blend) { ------------------ | Branch (32068:15): [True: 7, False: 0] ------------------ 32069| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32069:9): [True: 1, False: 6] ------------------ 32070| 1|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32071| 1| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32071:15): [True: 1, False: 0] ------------------ 32072| 1| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 32073| 1| } 32074| 0|#endif 32075| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 32076| 6| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 6|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32076:9): [True: 6, False: 1] ------------------ 32077| 6| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; 32078| 7| } 32079| 0| return NULL; 32080| 267| } 32081| 23| return NULL; 32082| 267|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src: 30542| 13| size_t src_len) { 30543| 13| size_t src_len4 = src_len / 4; 30544| 13| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30544:16): [True: 1, False: 12] ------------------ 30545| 13| uint8_t* d = dst_ptr; 30546| 13| const uint8_t* s = src_ptr; 30547| 13| size_t n = len; 30548| | 30549| | // TODO: unroll. 30550| | 30551| 283| while (n >= 1) { ------------------ | Branch (30551:10): [True: 270, False: 13] ------------------ 30552| 270| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 30553| 270| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30554| | 30555| 270| s += 1 * 4; 30556| 270| d += 1 * 1; 30557| 270| n -= 1; 30558| 270| } 30559| | 30560| 13| return len; 30561| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src_over: 30569| 16| size_t src_len) { 30570| 16| size_t src_len4 = src_len / 4; 30571| 16| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30571:16): [True: 1, False: 15] ------------------ 30572| 16| uint8_t* d = dst_ptr; 30573| 16| const uint8_t* s = src_ptr; 30574| 16| size_t n = len; 30575| | 30576| | // TODO: unroll. 30577| | 30578| 274| while (n >= 1) { ------------------ | Branch (30578:10): [True: 258, False: 16] ------------------ 30579| | // Extract 16-bit color components. 30580| 258| uint32_t dr = 0x101 * ((uint32_t)d[0]); 30581| 258| uint32_t dg = 0x101 * ((uint32_t)d[0]); 30582| 258| uint32_t db = 0x101 * ((uint32_t)d[0]); 30583| 258| uint32_t sa = 0x101 * ((uint32_t)s[3]); 30584| 258| uint32_t sr = 0x101 * ((uint32_t)s[2]); 30585| 258| uint32_t sg = 0x101 * ((uint32_t)s[1]); 30586| 258| 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| 258| uint32_t ia = 0xFFFF - sa; 30590| | 30591| | // Composite src (premul) over dst (premul). 30592| 258| dr = sr + ((dr * ia) / 0xFFFF); 30593| 258| dg = sg + ((dg * ia) / 0xFFFF); 30594| 258| db = sb + ((db * ia) / 0xFFFF); 30595| | 30596| | // Convert to 16-bit color to 8-bit gray. 30597| 258| uint32_t weighted_average = 30598| 258| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 30599| 258| d[0] = (uint8_t)(weighted_average >> 24); 30600| | 30601| 258| s += 1 * 4; 30602| 258| d += 1 * 1; 30603| 258| n -= 1; 30604| 258| } 30605| | 30606| 16| return len; 30607| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src: 26247| 10| size_t src_len) { 26248| 10| size_t dst_len2 = dst_len / 2; 26249| 10| size_t src_len4 = src_len / 4; 26250| 10| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26250:16): [True: 2, False: 8] ------------------ 26251| 10| uint8_t* d = dst_ptr; 26252| 10| const uint8_t* s = src_ptr; 26253| 10| size_t n = len; 26254| | 26255| | // TODO: unroll. 26256| | 26257| 129| while (n >= 1) { ------------------ | Branch (26257:10): [True: 119, False: 10] ------------------ 26258| 119| wuffs_base__poke_u16le__no_bounds_check( 26259| 119| d + (0 * 2), wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26260| 119| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 26261| | 26262| 119| s += 1 * 4; 26263| 119| d += 1 * 2; 26264| 119| n -= 1; 26265| 119| } 26266| | 26267| 10| return len; 26268| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over: 26309| 9| size_t src_len) { 26310| 9| size_t dst_len2 = dst_len / 2; 26311| 9| size_t src_len4 = src_len / 4; 26312| 9| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26312:16): [True: 2, False: 7] ------------------ 26313| 9| uint8_t* d = dst_ptr; 26314| 9| const uint8_t* s = src_ptr; 26315| 9| size_t n = len; 26316| | 26317| | // TODO: unroll. 26318| | 26319| 114| while (n >= 1) { ------------------ | Branch (26319:10): [True: 105, False: 9] ------------------ 26320| | // Extract 16-bit color components. 26321| 105| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26322| 105| uint32_t sr = 0x101 * ((uint32_t)s[2]); 26323| 105| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26324| 105| uint32_t sb = 0x101 * ((uint32_t)s[0]); 26325| | 26326| | // Convert from 565 color to 16-bit color. 26327| 105| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26328| 105| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26329| 105| uint32_t dr = (0x8421 * old_r5) >> 4; 26330| 105| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26331| 105| uint32_t dg = (0x1041 * old_g6) >> 2; 26332| 105| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26333| 105| uint32_t db = (0x8421 * old_b5) >> 4; 26334| | 26335| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26336| 105| uint32_t ia = 0xFFFF - sa; 26337| | 26338| | // Composite src (premul) over dst (premul). 26339| 105| dr = sr + ((dr * ia) / 0xFFFF); 26340| 105| dg = sg + ((dg * ia) / 0xFFFF); 26341| 105| db = sb + ((db * ia) / 0xFFFF); 26342| | 26343| | // Convert from 16-bit color to 565 color and combine the components. 26344| 105| uint32_t new_r5 = 0x1F & (dr >> 11); 26345| 105| uint32_t new_g6 = 0x3F & (dg >> 10); 26346| 105| uint32_t new_b5 = 0x1F & (db >> 11); 26347| 105| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26348| 105| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26349| | 26350| 105| s += 1 * 4; 26351| 105| d += 1 * 2; 26352| 105| n -= 1; 26353| 105| } 26354| | 26355| 9| return len; 26356| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src: 27115| 17| size_t src_len) { 27116| 17| size_t dst_len3 = dst_len / 3; 27117| 17| size_t src_len4 = src_len / 4; 27118| 17| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27118:16): [True: 3, False: 14] ------------------ 27119| 17| uint8_t* d = dst_ptr; 27120| 17| const uint8_t* s = src_ptr; 27121| 17| size_t n = len; 27122| | 27123| 328| while (n >= 1) { ------------------ | Branch (27123:10): [True: 311, False: 17] ------------------ 27124| 311| uint8_t s0 = s[0]; 27125| 311| uint8_t s1 = s[1]; 27126| 311| uint8_t s2 = s[2]; 27127| 311| d[0] = s0; 27128| 311| d[1] = s1; 27129| 311| d[2] = s2; 27130| | 27131| 311| s += 1 * 4; 27132| 311| d += 1 * 3; 27133| 311| n -= 1; 27134| 311| } 27135| | 27136| 17| return len; 27137| 17|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src_over: 27175| 16| size_t src_len) { 27176| 16| size_t dst_len3 = dst_len / 3; 27177| 16| size_t src_len4 = src_len / 4; 27178| 16| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27178:16): [True: 3, False: 13] ------------------ 27179| 16| uint8_t* d = dst_ptr; 27180| 16| const uint8_t* s = src_ptr; 27181| 16| size_t n = len; 27182| | 27183| 381| while (n >= 1) { ------------------ | Branch (27183:10): [True: 365, False: 16] ------------------ 27184| | // Extract 16-bit color components. 27185| 365| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27186| 365| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27187| 365| uint32_t db = 0x101 * ((uint32_t)d[0]); 27188| 365| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27189| 365| uint32_t sr = 0x101 * ((uint32_t)s[2]); 27190| 365| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27191| 365| 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| 365| uint32_t ia = 0xFFFF - sa; 27195| | 27196| | // Composite src (premul) over dst (premul). 27197| 365| dr = sr + ((dr * ia) / 0xFFFF); 27198| 365| dg = sg + ((dg * ia) / 0xFFFF); 27199| 365| db = sb + ((db * ia) / 0xFFFF); 27200| | 27201| | // Convert from 16-bit color to 8-bit color. 27202| 365| d[0] = (uint8_t)(db >> 8); 27203| 365| d[1] = (uint8_t)(dg >> 8); 27204| 365| d[2] = (uint8_t)(dr >> 8); 27205| | 27206| 365| s += 1 * 4; 27207| 365| d += 1 * 3; 27208| 365| n -= 1; 27209| 365| } 27210| | 27211| 16| return len; 27212| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src: 27704| 38| size_t src_len) { 27705| 38| size_t dst_len4 = dst_len / 4; 27706| 38| size_t src_len4 = src_len / 4; 27707| 38| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27707:16): [True: 8, False: 30] ------------------ 27708| 38| uint8_t* d = dst_ptr; 27709| 38| const uint8_t* s = src_ptr; 27710| 38| size_t n = len; 27711| | 27712| 545| while (n >= 1) { ------------------ | Branch (27712:10): [True: 507, False: 38] ------------------ 27713| 507| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27714| 507| wuffs_base__poke_u32le__no_bounds_check( 27715| 507| d + (0 * 4), 27716| 507| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0)); 27717| | 27718| 507| s += 1 * 4; 27719| 507| d += 1 * 4; 27720| 507| n -= 1; 27721| 507| } 27722| | 27723| 38| return len; 27724| 38|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over: 27733| 32| size_t src_len) { 27734| 32| size_t dst_len4 = dst_len / 4; 27735| 32| size_t src_len4 = src_len / 4; 27736| 32| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27736:16): [True: 10, False: 22] ------------------ 27737| 32| uint8_t* d = dst_ptr; 27738| 32| const uint8_t* s = src_ptr; 27739| 32| size_t n = len; 27740| | 27741| 424| while (n >= 1) { ------------------ | Branch (27741:10): [True: 392, False: 32] ------------------ 27742| 392| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27743| 392| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 27744| 392| wuffs_base__poke_u32le__no_bounds_check( 27745| 392| d + (0 * 4), 27746| 392| wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0)); 27747| | 27748| 392| s += 1 * 4; 27749| 392| d += 1 * 4; 27750| 392| n -= 1; 27751| 392| } 27752| | 27753| 32| return len; 27754| 32|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u32_axxx: 25527| 776| uint32_t src_premul) { 25528| | // Extract 16-bit color components. 25529| 776| uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24)); 25530| 776| uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16)); 25531| 776| uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8)); 25532| 776| uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0)); 25533| 776| uint32_t sa = 0x101 * (0xFF & (src_premul >> 24)); 25534| 776| uint32_t sr = 0x101 * (0xFF & (src_premul >> 16)); 25535| 776| uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)); 25536| 776| uint32_t sb = 0x101 * (0xFF & (src_premul >> 0)); 25537| | 25538| | // Convert dst from nonpremul to premul. 25539| 776| dr = (dr * da) / 0xFFFF; 25540| 776| dg = (dg * da) / 0xFFFF; 25541| 776| db = (db * da) / 0xFFFF; 25542| | 25543| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25544| 776| uint32_t ia = 0xFFFF - sa; 25545| | 25546| | // Composite src (premul) over dst (premul). 25547| 776| da = sa + ((da * ia) / 0xFFFF); 25548| 776| dr = sr + ((dr * ia) / 0xFFFF); 25549| 776| dg = sg + ((dg * ia) / 0xFFFF); 25550| 776| db = sb + ((db * ia) / 0xFFFF); 25551| | 25552| | // Convert dst from premul to nonpremul. 25553| 776| if (da != 0) { ------------------ | Branch (25553:7): [True: 594, False: 182] ------------------ 25554| 594| dr = (dr * 0xFFFF) / da; 25555| 594| dg = (dg * 0xFFFF) / da; 25556| 594| db = (db * 0xFFFF) / da; 25557| 594| } 25558| | 25559| | // Convert from 16-bit color to 8-bit color. 25560| 776| da >>= 8; 25561| 776| dr >>= 8; 25562| 776| dg >>= 8; 25563| 776| db >>= 8; 25564| | 25565| | // Combine components. 25566| 776| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25567| 776|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src: 28110| 31| size_t src_len) { 28111| 31| size_t dst_len8 = dst_len / 8; 28112| 31| size_t src_len4 = src_len / 4; 28113| 31| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28113:16): [True: 14, False: 17] ------------------ 28114| 31| uint8_t* d = dst_ptr; 28115| 31| const uint8_t* s = src_ptr; 28116| | 28117| 31| size_t n = len; 28118| 223| while (n >= 1) { ------------------ | Branch (28118:10): [True: 192, False: 31] ------------------ 28119| 192| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28120| 192| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 28121| 192| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 28122| 192| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 28123| | 28124| 192| s += 1 * 4; 28125| 192| d += 1 * 8; 28126| 192| n -= 1; 28127| 192| } 28128| 31| return len; 28129| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over: 28138| 29| size_t src_len) { 28139| 29| size_t dst_len8 = dst_len / 8; 28140| 29| size_t src_len4 = src_len / 4; 28141| 29| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28141:16): [True: 8, False: 21] ------------------ 28142| 29| uint8_t* d = dst_ptr; 28143| 29| const uint8_t* s = src_ptr; 28144| | 28145| 29| size_t n = len; 28146| 225| while (n >= 1) { ------------------ | Branch (28146:10): [True: 196, False: 29] ------------------ 28147| 196| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28148| 196| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28149| 196| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28150| 196| wuffs_base__poke_u64le__no_bounds_check( 28151| 196| d + (0 * 8), 28152| 196| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 28153| | 28154| 196| s += 1 * 4; 28155| 196| d += 1 * 8; 28156| 196| n -= 1; 28157| 196| } 28158| 29| return len; 28159| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u64_axxx: 25571| 932| uint64_t src_premul) { 25572| | // Extract components. 25573| 932| uint64_t da = 0xFFFF & (dst_nonpremul >> 48); 25574| 932| uint64_t dr = 0xFFFF & (dst_nonpremul >> 32); 25575| 932| uint64_t dg = 0xFFFF & (dst_nonpremul >> 16); 25576| 932| uint64_t db = 0xFFFF & (dst_nonpremul >> 0); 25577| 932| uint64_t sa = 0xFFFF & (src_premul >> 48); 25578| 932| uint64_t sr = 0xFFFF & (src_premul >> 32); 25579| 932| uint64_t sg = 0xFFFF & (src_premul >> 16); 25580| 932| uint64_t sb = 0xFFFF & (src_premul >> 0); 25581| | 25582| | // Convert dst from nonpremul to premul. 25583| 932| dr = (dr * da) / 0xFFFF; 25584| 932| dg = (dg * da) / 0xFFFF; 25585| 932| db = (db * da) / 0xFFFF; 25586| | 25587| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25588| 932| uint64_t ia = 0xFFFF - sa; 25589| | 25590| | // Composite src (premul) over dst (premul). 25591| 932| da = sa + ((da * ia) / 0xFFFF); 25592| 932| dr = sr + ((dr * ia) / 0xFFFF); 25593| 932| dg = sg + ((dg * ia) / 0xFFFF); 25594| 932| db = sb + ((db * ia) / 0xFFFF); 25595| | 25596| | // Convert dst from premul to nonpremul. 25597| 932| if (da != 0) { ------------------ | Branch (25597:7): [True: 751, False: 181] ------------------ 25598| 751| dr = (dr * 0xFFFF) / da; 25599| 751| dg = (dg * 0xFFFF) / da; 25600| 751| db = (db * 0xFFFF) / da; 25601| 751| } 25602| | 25603| | // Combine components. 25604| 932| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25605| 932|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over: 28604| 20| size_t src_len) { 28605| 20| size_t dst_len4 = dst_len / 4; 28606| 20| size_t src_len4 = src_len / 4; 28607| 20| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28607:16): [True: 6, False: 14] ------------------ 28608| 20| uint8_t* d = dst_ptr; 28609| 20| const uint8_t* s = src_ptr; 28610| 20| size_t n = len; 28611| | 28612| | // TODO: unroll. 28613| | 28614| 251| while (n >= 1) { ------------------ | Branch (28614:10): [True: 231, False: 20] ------------------ 28615| 231| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28616| 231| uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 28617| 231| wuffs_base__poke_u32le__no_bounds_check( 28618| 231| d + (0 * 4), 28619| 231| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 28620| | 28621| 231| s += 1 * 4; 28622| 231| d += 1 * 4; 28623| 231| n -= 1; 28624| 231| } 28625| | 28626| 20| return len; 28627| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u32_axxx: 25669| 710| uint32_t src_premul) { 25670| | // Extract 16-bit color components. 25671| 710| uint32_t da = 0x101 * (0xFF & (dst_premul >> 24)); 25672| 710| uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16)); 25673| 710| uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8)); 25674| 710| uint32_t db = 0x101 * (0xFF & (dst_premul >> 0)); 25675| 710| uint32_t sa = 0x101 * (0xFF & (src_premul >> 24)); 25676| 710| uint32_t sr = 0x101 * (0xFF & (src_premul >> 16)); 25677| 710| uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)); 25678| 710| 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| 710| uint32_t ia = 0xFFFF - sa; 25682| | 25683| | // Composite src (premul) over dst (premul). 25684| 710| da = sa + ((da * ia) / 0xFFFF); 25685| 710| dr = sr + ((dr * ia) / 0xFFFF); 25686| 710| dg = sg + ((dg * ia) / 0xFFFF); 25687| 710| db = sb + ((db * ia) / 0xFFFF); 25688| | 25689| | // Convert from 16-bit color to 8-bit color. 25690| 710| da >>= 8; 25691| 710| dr >>= 8; 25692| 710| dg >>= 8; 25693| 710| db >>= 8; 25694| | 25695| | // Combine components. 25696| 710| return (db << 0) | (dg << 8) | (dr << 16) | (da << 24); 25697| 710|} 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| 159| while (n >= 1) { ------------------ | Branch (27433:10): [True: 148, False: 11] ------------------ 27434| 148| uint8_t s0 = s[0]; 27435| 148| uint8_t s1 = s[1]; 27436| 148| uint8_t s2 = s[2]; 27437| 148| d[0] = s2; 27438| 148| d[1] = s1; 27439| 148| d[2] = s0; 27440| | 27441| 148| s += 1 * 4; 27442| 148| d += 1 * 3; 27443| 148| n -= 1; 27444| 148| } 27445| | 27446| 11| return len; 27447| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul__src_over: 27486| 13| size_t src_len) { 27487| 13| size_t dst_len3 = dst_len / 3; 27488| 13| size_t src_len4 = src_len / 4; 27489| 13| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27489:16): [True: 3, False: 10] ------------------ 27490| 13| uint8_t* d = dst_ptr; 27491| 13| const uint8_t* s = src_ptr; 27492| 13| size_t n = len; 27493| | 27494| 199| while (n >= 1) { ------------------ | Branch (27494:10): [True: 186, False: 13] ------------------ 27495| | // Extract 16-bit color components. 27496| 186| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27497| 186| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27498| 186| uint32_t db = 0x101 * ((uint32_t)d[0]); 27499| 186| uint32_t sa = 0x101 * ((uint32_t)s[3]); 27500| 186| uint32_t sb = 0x101 * ((uint32_t)s[2]); 27501| 186| uint32_t sg = 0x101 * ((uint32_t)s[1]); 27502| 186| 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| 186| uint32_t ia = 0xFFFF - sa; 27506| | 27507| | // Composite src (premul) over dst (premul). 27508| 186| dr = sr + ((dr * ia) / 0xFFFF); 27509| 186| dg = sg + ((dg * ia) / 0xFFFF); 27510| 186| db = sb + ((db * ia) / 0xFFFF); 27511| | 27512| | // Convert from 16-bit color to 8-bit color. 27513| 186| d[0] = (uint8_t)(db >> 8); 27514| 186| d[1] = (uint8_t)(dg >> 8); 27515| 186| d[2] = (uint8_t)(dr >> 8); 27516| | 27517| 186| s += 1 * 4; 27518| 186| d += 1 * 3; 27519| 186| n -= 1; 27520| 186| } 27521| | 27522| 13| return len; 27523| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src: 27891| 35| size_t src_len) { 27892| 35| size_t dst_len4 = dst_len / 4; 27893| 35| size_t src_len4 = src_len / 4; 27894| 35| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (27894:16): [True: 6, False: 29] ------------------ 27895| 35| uint8_t* d = dst_ptr; 27896| 35| const uint8_t* s = src_ptr; 27897| 35| size_t n = len; 27898| | 27899| 454| while (n >= 1) { ------------------ | Branch (27899:10): [True: 419, False: 35] ------------------ 27900| 419| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27901| 419| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27902| 419| wuffs_base__poke_u32le__no_bounds_check( 27903| 419| d + (0 * 4), 27904| 419| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0)); 27905| | 27906| 419| s += 1 * 4; 27907| 419| d += 1 * 4; 27908| 419| n -= 1; 27909| 419| } 27910| | 27911| 35| return len; 27912| 35|} 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: 8, False: 23] ------------------ 27925| 31| uint8_t* d = dst_ptr; 27926| 31| const uint8_t* s = src_ptr; 27927| 31| size_t n = len; 27928| | 27929| 415| while (n >= 1) { ------------------ | Branch (27929:10): [True: 384, False: 31] ------------------ 27930| 384| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 27931| 384| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27932| 384| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 27933| 384| wuffs_base__poke_u32le__no_bounds_check( 27934| 384| d + (0 * 4), 27935| 384| wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0)); 27936| | 27937| 384| s += 1 * 4; 27938| 384| d += 1 * 4; 27939| 384| n -= 1; 27940| 384| } 27941| | 27942| 31| return len; 27943| 31|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over: 28839| 18| size_t src_len) { 28840| 18| size_t dst_len4 = dst_len / 4; 28841| 18| size_t src_len4 = src_len / 4; 28842| 18| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (28842:16): [True: 5, False: 13] ------------------ 28843| 18| uint8_t* d = dst_ptr; 28844| 18| const uint8_t* s = src_ptr; 28845| 18| size_t n = len; 28846| | 28847| 289| while (n >= 1) { ------------------ | Branch (28847:10): [True: 271, False: 18] ------------------ 28848| 271| uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)); 28849| 271| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 28850| 271| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 28851| 271| wuffs_base__poke_u32le__no_bounds_check( 28852| 271| d + (0 * 4), 28853| 271| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 28854| | 28855| 271| s += 1 * 4; 28856| 271| d += 1 * 4; 28857| 271| n -= 1; 28858| 271| } 28859| | 28860| 18| return len; 28861| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le: 32090| 394| wuffs_base__pixel_blend blend) { 32091| 394| switch (dst_pixfmt.repr) { ------------------ | Branch (32091:11): [True: 381, False: 13] ------------------ 32092| 22| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 22|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32092:5): [True: 22, False: 372] ------------------ 32093| 22| switch (blend) { ------------------ | Branch (32093:15): [True: 22, False: 0] ------------------ 32094| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32094:9): [True: 7, False: 15] ------------------ 32095| 7| return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src; 32096| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32096:9): [True: 15, False: 7] ------------------ 32097| 15| return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over; 32098| 22| } 32099| 0| return NULL; 32100| | 32101| 20| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 20|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32101:5): [True: 20, False: 374] ------------------ 32102| 20| switch (blend) { ------------------ | Branch (32102:15): [True: 20, 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: 11] ------------------ 32104| 9| return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src; 32105| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32105:9): [True: 11, False: 9] ------------------ 32106| 11| return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over; 32107| 20| } 32108| 0| return NULL; 32109| | 32110| 19| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32110:5): [True: 19, False: 375] ------------------ 32111| 19| switch (blend) { ------------------ | Branch (32111:15): [True: 19, False: 0] ------------------ 32112| 7| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32112:9): [True: 7, False: 12] ------------------ 32113| 7| return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src; 32114| 12| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32114:9): [True: 12, False: 7] ------------------ 32115| 12| return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over; 32116| 19| } 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: 317] ------------------ 32120| 77| switch (blend) { ------------------ | Branch (32120:15): [True: 77, False: 0] ------------------ 32121| 47| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 47|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32121:9): [True: 47, False: 30] ------------------ 32122| 47| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src; 32123| 30| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 30|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32123:9): [True: 30, False: 47] ------------------ 32124| 30| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over; 32125| 77| } 32126| 0| return NULL; 32127| | 32128| 67| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 67|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32128:5): [True: 67, False: 327] ------------------ 32129| | 32130| 67| switch (blend) { ------------------ | Branch (32130:15): [True: 67, False: 0] ------------------ 32131| 44| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 44|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32131:9): [True: 44, False: 23] ------------------ 32132| 44| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src; 32133| 23| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 23|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32133:9): [True: 23, False: 44] ------------------ 32134| 23| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over; 32135| 67| } 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: 372] ------------------ 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| 12| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: ------------------ | | 4967| 12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB ------------------ | Branch (32147:5): [True: 12, False: 382] ------------------ 32148| 12| switch (blend) { ------------------ | Branch (32148:15): [True: 12, False: 0] ------------------ 32149| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32149:9): [True: 1, False: 11] ------------------ 32150| 1| return wuffs_private_impl__swizzle_copy_8_8; 32151| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32151:9): [True: 11, False: 1] ------------------ 32152| 11| return wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over; 32153| 12| } 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: 394] ------------------ 32157| 2| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 2|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32157:5): [True: 2, False: 392] ------------------ 32158| | // TODO. 32159| 2| break; 32160| | 32161| 30| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 30|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32161:5): [True: 30, False: 364] ------------------ 32162| 30| switch (blend) { ------------------ | Branch (32162:15): [True: 30, 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: 19] ------------------ 32164| 11| return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src; 32165| 19| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32165:9): [True: 19, False: 11] ------------------ 32166| 19| return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over; 32167| 30| } 32168| 0| return NULL; 32169| | 32170| 81| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 81|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32170:5): [True: 81, False: 313] ------------------ 32171| 81| switch (blend) { ------------------ | Branch (32171:15): [True: 81, False: 0] ------------------ 32172| 51| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 51|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32172:9): [True: 51, False: 30] ------------------ 32173| 51| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src; 32174| 30| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 30|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32174:9): [True: 30, False: 51] ------------------ 32175| 30| return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over; 32176| 81| } 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: 365] ------------------ 32180| 29| switch (blend) { ------------------ | Branch (32180:15): [True: 29, False: 0] ------------------ 32181| 18| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32181:9): [True: 18, False: 11] ------------------ 32182| 18| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src; 32183| 11| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32183:9): [True: 11, False: 18] ------------------ 32184| 11| 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: 394] ------------------ 32189| 0| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (32189:5): [True: 0, False: 394] ------------------ 32190| | // TODO. 32191| 0| break; 32192| 394| } 32193| 15| return NULL; 32194| 394|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src: 30615| 7| size_t src_len) { 30616| 7| size_t src_len8 = src_len / 8; 30617| 7| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (30617:16): [True: 1, False: 6] ------------------ 30618| 7| uint8_t* d = dst_ptr; 30619| 7| const uint8_t* s = src_ptr; 30620| 7| size_t n = len; 30621| | 30622| | // TODO: unroll. 30623| | 30624| 68| while (n >= 1) { ------------------ | Branch (30624:10): [True: 61, False: 7] ------------------ 30625| 61| d[0] = wuffs_base__color_u64_argb_premul__as__color_u8_gray( 30626| 61| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 30627| | 30628| 61| s += 1 * 8; 30629| 61| d += 1 * 1; 30630| 61| n -= 1; 30631| 61| } 30632| | 30633| 7| return len; 30634| 7|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u8_gray: 4576| 61|wuffs_base__color_u64_argb_premul__as__color_u8_gray(uint64_t argb_premul) { 4577| 61| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_premul >> 32))); 4578| 61| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_premul >> 16))); 4579| 61| 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| 61| uint32_t weighted_average = 4588| 61| (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; 4589| 61| return (uint8_t)(weighted_average >> 24); 4590| 61|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over: 30643| 15| size_t src_len) { 30644| 15| size_t src_len8 = src_len / 8; 30645| 15| size_t len = (dst_len < src_len8) ? dst_len : src_len8; ------------------ | Branch (30645:16): [True: 1, False: 14] ------------------ 30646| 15| uint8_t* d = dst_ptr; 30647| 15| const uint8_t* s = src_ptr; 30648| 15| size_t n = len; 30649| | 30650| | // TODO: unroll. 30651| | 30652| 116| while (n >= 1) { ------------------ | Branch (30652:10): [True: 101, False: 15] ------------------ 30653| | // Extract 16-bit color components. 30654| 101| uint32_t dr = 0x101 * ((uint32_t)d[0]); 30655| 101| uint32_t dg = 0x101 * ((uint32_t)d[0]); 30656| 101| uint32_t db = 0x101 * ((uint32_t)d[0]); 30657| 101| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 30658| 101| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 30659| 101| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 30660| 101| 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| 101| uint32_t ia = 0xFFFF - sa; 30664| | 30665| | // Composite src (premul) over dst (premul). 30666| 101| dr = sr + ((dr * ia) / 0xFFFF); 30667| 101| dg = sg + ((dg * ia) / 0xFFFF); 30668| 101| db = sb + ((db * ia) / 0xFFFF); 30669| | 30670| | // Convert to 16-bit color to 8-bit gray. 30671| 101| uint32_t weighted_average = 30672| 101| (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; 30673| 101| d[0] = (uint8_t)(weighted_average >> 24); 30674| | 30675| 101| s += 1 * 8; 30676| 101| d += 1 * 1; 30677| 101| n -= 1; 30678| 101| } 30679| | 30680| 15| return len; 30681| 15|} 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: 4, False: 5] ------------------ 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| 81| while (n >= 1) { ------------------ | Branch (26287:10): [True: 72, False: 9] ------------------ 26288| 72| wuffs_base__poke_u16le__no_bounds_check( 26289| 72| d + (0 * 2), 26290| 72| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26291| 72| wuffs_base__color_u64__as__color_u32( 26292| 72| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 26293| | 26294| 72| s += 1 * 8; 26295| 72| d += 1 * 2; 26296| 72| n -= 1; 26297| 72| } 26298| | 26299| 9| return len; 26300| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over: 26365| 11| size_t src_len) { 26366| 11| size_t dst_len2 = dst_len / 2; 26367| 11| size_t src_len8 = src_len / 8; 26368| 11| size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8; ------------------ | Branch (26368:16): [True: 1, False: 10] ------------------ 26369| 11| uint8_t* d = dst_ptr; 26370| 11| const uint8_t* s = src_ptr; 26371| 11| size_t n = len; 26372| | 26373| | // TODO: unroll. 26374| | 26375| 164| while (n >= 1) { ------------------ | Branch (26375:10): [True: 153, False: 11] ------------------ 26376| | // Extract 16-bit color components. 26377| 153| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 26378| 153| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 26379| 153| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 26380| 153| 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| 153| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26384| 153| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26385| 153| uint32_t dr = (0x8421 * old_r5) >> 4; 26386| 153| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26387| 153| uint32_t dg = (0x1041 * old_g6) >> 2; 26388| 153| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26389| 153| uint32_t db = (0x8421 * old_b5) >> 4; 26390| | 26391| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26392| 153| uint32_t ia = 0xFFFF - sa; 26393| | 26394| | // Composite src (premul) over dst (premul). 26395| 153| dr = sr + ((dr * ia) / 0xFFFF); 26396| 153| dg = sg + ((dg * ia) / 0xFFFF); 26397| 153| db = sb + ((db * ia) / 0xFFFF); 26398| | 26399| | // Convert from 16-bit color to 565 color and combine the components. 26400| 153| uint32_t new_r5 = 0x1F & (dr >> 11); 26401| 153| uint32_t new_g6 = 0x3F & (dg >> 10); 26402| 153| uint32_t new_b5 = 0x1F & (db >> 11); 26403| 153| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26404| 153| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26405| | 26406| 153| s += 1 * 8; 26407| 153| d += 1 * 2; 26408| 153| n -= 1; 26409| 153| } 26410| | 26411| 11| return len; 26412| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src: 27146| 7| size_t src_len) { 27147| 7| size_t dst_len3 = dst_len / 3; 27148| 7| size_t src_len8 = src_len / 8; 27149| 7| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27149:16): [True: 1, False: 6] ------------------ 27150| 7| uint8_t* d = dst_ptr; 27151| 7| const uint8_t* s = src_ptr; 27152| 7| size_t n = len; 27153| | 27154| | // TODO: unroll. 27155| | 27156| 56| while (n >= 1) { ------------------ | Branch (27156:10): [True: 49, False: 7] ------------------ 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| 7| return len; 27167| 7|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over: 27221| 12| size_t src_len) { 27222| 12| size_t dst_len3 = dst_len / 3; 27223| 12| size_t src_len8 = src_len / 8; 27224| 12| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27224:16): [True: 1, False: 11] ------------------ 27225| 12| uint8_t* d = dst_ptr; 27226| 12| const uint8_t* s = src_ptr; 27227| 12| size_t n = len; 27228| | 27229| | // TODO: unroll. 27230| | 27231| 140| while (n >= 1) { ------------------ | Branch (27231:10): [True: 128, False: 12] ------------------ 27232| | // Extract 16-bit color components. 27233| 128| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27234| 128| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27235| 128| uint32_t db = 0x101 * ((uint32_t)d[0]); 27236| 128| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27237| 128| uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27238| 128| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27239| 128| 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| 128| uint32_t ia = 0xFFFF - sa; 27243| | 27244| | // Composite src (premul) over dst (premul). 27245| 128| dr = sr + ((dr * ia) / 0xFFFF); 27246| 128| dg = sg + ((dg * ia) / 0xFFFF); 27247| 128| db = sb + ((db * ia) / 0xFFFF); 27248| | 27249| | // Convert from 16-bit color to 8-bit color. 27250| 128| d[0] = (uint8_t)(db >> 8); 27251| 128| d[1] = (uint8_t)(dg >> 8); 27252| 128| d[2] = (uint8_t)(dr >> 8); 27253| | 27254| 128| s += 1 * 8; 27255| 128| d += 1 * 3; 27256| 128| n -= 1; 27257| 128| } 27258| | 27259| 12| return len; 27260| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src: 27763| 47| size_t src_len) { 27764| 47| size_t dst_len4 = dst_len / 4; 27765| 47| size_t src_len8 = src_len / 8; 27766| 47| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27766:16): [True: 7, False: 40] ------------------ 27767| 47| uint8_t* d = dst_ptr; 27768| 47| const uint8_t* s = src_ptr; 27769| | 27770| 47| size_t n = len; 27771| 416| while (n >= 1) { ------------------ | Branch (27771:10): [True: 369, False: 47] ------------------ 27772| 369| wuffs_base__poke_u32le__no_bounds_check( 27773| 369| d + (0 * 4), 27774| 369| wuffs_base__color_u64__as__color_u32( 27775| 369| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul( 27776| 369| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 27777| | 27778| 369| s += 1 * 8; 27779| 369| d += 1 * 4; 27780| 369| n -= 1; 27781| 369| } 27782| 47| return len; 27783| 47|} pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul: 4594| 933| uint64_t argb_premul) { 4595| 933| uint64_t a = 0xFFFF & (argb_premul >> 48); 4596| 933| if (a == 0xFFFF) { ------------------ | Branch (4596:7): [True: 125, False: 808] ------------------ 4597| 125| return argb_premul; 4598| 808| } else if (a == 0) { ------------------ | Branch (4598:14): [True: 135, False: 673] ------------------ 4599| 135| return 0; 4600| 135| } 4601| | 4602| 673| uint64_t r = 0xFFFF & (argb_premul >> 32); 4603| 673| r = (r * 0xFFFF) / a; 4604| 673| uint64_t g = 0xFFFF & (argb_premul >> 16); 4605| 673| g = (g * 0xFFFF) / a; 4606| 673| uint64_t b = 0xFFFF & (argb_premul >> 0); 4607| 673| b = (b * 0xFFFF) / a; 4608| | 4609| 673| return (a << 48) | (r << 32) | (g << 16) | (b << 0); 4610| 933|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over: 27792| 30| size_t src_len) { 27793| 30| size_t dst_len4 = dst_len / 4; 27794| 30| size_t src_len8 = src_len / 8; 27795| 30| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (27795:16): [True: 3, False: 27] ------------------ 27796| 30| uint8_t* d = dst_ptr; 27797| 30| const uint8_t* s = src_ptr; 27798| 30| size_t n = len; 27799| | 27800| 246| while (n >= 1) { ------------------ | Branch (27800:10): [True: 216, False: 30] ------------------ 27801| 216| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 27802| 216| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 27803| 216| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 27804| 216| wuffs_base__poke_u32le__no_bounds_check( 27805| 216| d + (0 * 4), 27806| 216| wuffs_base__color_u64__as__color_u32( 27807| 216| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0))); 27808| | 27809| 216| s += 1 * 8; 27810| 216| d += 1 * 4; 27811| 216| n -= 1; 27812| 216| } 27813| | 27814| 30| return len; 27815| 30|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src: 28168| 44| size_t src_len) { 28169| 44| size_t dst_len8 = dst_len / 8; 28170| 44| size_t src_len8 = src_len / 8; 28171| 44| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (28171:16): [True: 9, False: 35] ------------------ 28172| 44| uint8_t* d = dst_ptr; 28173| 44| const uint8_t* s = src_ptr; 28174| | 28175| 44| size_t n = len; 28176| 254| while (n >= 1) { ------------------ | Branch (28176:10): [True: 210, False: 44] ------------------ 28177| 210| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28178| 210| wuffs_base__poke_u64le__no_bounds_check( 28179| 210| d + (0 * 8), 28180| 210| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(s0)); 28181| | 28182| 210| s += 1 * 8; 28183| 210| d += 1 * 8; 28184| 210| n -= 1; 28185| 210| } 28186| 44| return len; 28187| 44|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over: 28196| 23| size_t src_len) { 28197| 23| size_t dst_len8 = dst_len / 8; 28198| 23| size_t src_len8 = src_len / 8; 28199| 23| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (28199:16): [True: 4, False: 19] ------------------ 28200| 23| uint8_t* d = dst_ptr; 28201| 23| const uint8_t* s = src_ptr; 28202| | 28203| 23| size_t n = len; 28204| 177| while (n >= 1) { ------------------ | Branch (28204:10): [True: 154, False: 23] ------------------ 28205| 154| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28206| 154| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28207| 154| wuffs_base__poke_u64le__no_bounds_check( 28208| 154| d + (0 * 8), 28209| 154| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 28210| | 28211| 154| s += 1 * 8; 28212| 154| d += 1 * 8; 28213| 154| n -= 1; 28214| 154| } 28215| 23| return len; 28216| 23|} 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: 4, False: 7] ------------------ 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| 78| while (n >= 1) { ------------------ | Branch (28584:10): [True: 67, False: 11] ------------------ 28585| 67| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28586| 67| wuffs_base__poke_u32le__no_bounds_check( 28587| 67| d + (0 * 4), wuffs_base__color_u64__as__color_u32(s0)); 28588| | 28589| 67| s += 1 * 8; 28590| 67| d += 1 * 4; 28591| 67| n -= 1; 28592| 67| } 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: 2, False: 9] ------------------ 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| 129| while (n >= 1) { ------------------ | Branch (28646:10): [True: 118, False: 11] ------------------ 28647| 118| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28648| 118| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28649| 118| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28650| 118| wuffs_base__poke_u32le__no_bounds_check( 28651| 118| d + (0 * 4), 28652| 118| wuffs_base__color_u64__as__color_u32( 28653| 118| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0))); 28654| | 28655| 118| s += 1 * 8; 28656| 118| d += 1 * 4; 28657| 118| n -= 1; 28658| 118| } 28659| | 28660| 11| return len; 28661| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u64_axxx: 25701| 305| uint64_t src_premul) { 25702| | // Extract components. 25703| 305| uint64_t da = 0xFFFF & (dst_premul >> 48); 25704| 305| uint64_t dr = 0xFFFF & (dst_premul >> 32); 25705| 305| uint64_t dg = 0xFFFF & (dst_premul >> 16); 25706| 305| uint64_t db = 0xFFFF & (dst_premul >> 0); 25707| 305| uint64_t sa = 0xFFFF & (src_premul >> 48); 25708| 305| uint64_t sr = 0xFFFF & (src_premul >> 32); 25709| 305| uint64_t sg = 0xFFFF & (src_premul >> 16); 25710| 305| uint64_t sb = 0xFFFF & (src_premul >> 0); 25711| | 25712| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 25713| 305| uint64_t ia = 0xFFFF - sa; 25714| | 25715| | // Composite src (premul) over dst (premul). 25716| 305| da = sa + ((da * ia) / 0xFFFF); 25717| 305| dr = sr + ((dr * ia) / 0xFFFF); 25718| 305| dg = sg + ((dg * ia) / 0xFFFF); 25719| 305| db = sb + ((db * ia) / 0xFFFF); 25720| | 25721| | // Combine components. 25722| 305| return (db << 0) | (dg << 16) | (dr << 32) | (da << 48); 25723| 305|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over: 29001| 11| size_t src_len) { 29002| 11| size_t dst_len8 = dst_len / 8; 29003| 11| size_t src_len8 = src_len / 8; 29004| 11| size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8; ------------------ | Branch (29004:16): [True: 3, False: 8] ------------------ 29005| 11| uint8_t* d = dst_ptr; 29006| 11| const uint8_t* s = src_ptr; 29007| | 29008| 11| size_t n = len; 29009| 110| while (n >= 1) { ------------------ | Branch (29009:10): [True: 99, False: 11] ------------------ 29010| 99| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 29011| 99| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 29012| 99| wuffs_base__poke_u64le__no_bounds_check( 29013| 99| d + (0 * 8), 29014| 99| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0)); 29015| | 29016| 99| s += 1 * 8; 29017| 99| d += 1 * 8; 29018| 99| n -= 1; 29019| 99| } 29020| 11| return len; 29021| 11|} 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: 2, False: 9] ------------------ 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| 116| while (n >= 1) { ------------------ | Branch (27466:10): [True: 105, False: 11] ------------------ 27467| 105| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 27468| 105| wuffs_base__color_u64__as__color_u32( 27469| 105| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))); 27470| 105| wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0); 27471| | 27472| 105| s += 1 * 8; 27473| 105| d += 1 * 3; 27474| 105| n -= 1; 27475| 105| } 27476| | 27477| 11| return len; 27478| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over: 27532| 19| size_t src_len) { 27533| 19| size_t dst_len3 = dst_len / 3; 27534| 19| size_t src_len8 = src_len / 8; 27535| 19| size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8; ------------------ | Branch (27535:16): [True: 1, False: 18] ------------------ 27536| 19| uint8_t* d = dst_ptr; 27537| 19| const uint8_t* s = src_ptr; 27538| 19| size_t n = len; 27539| | 27540| | // TODO: unroll. 27541| | 27542| 219| while (n >= 1) { ------------------ | Branch (27542:10): [True: 200, False: 19] ------------------ 27543| | // Extract 16-bit color components. 27544| 200| uint32_t dr = 0x101 * ((uint32_t)d[2]); 27545| 200| uint32_t dg = 0x101 * ((uint32_t)d[1]); 27546| 200| uint32_t db = 0x101 * ((uint32_t)d[0]); 27547| 200| uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); 27548| 200| uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); 27549| 200| uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); 27550| 200| 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| 200| uint32_t ia = 0xFFFF - sa; 27554| | 27555| | // Composite src (premul) over dst (premul). 27556| 200| dr = sr + ((dr * ia) / 0xFFFF); 27557| 200| dg = sg + ((dg * ia) / 0xFFFF); 27558| 200| db = sb + ((db * ia) / 0xFFFF); 27559| | 27560| | // Convert from 16-bit color to 8-bit color. 27561| 200| d[0] = (uint8_t)(db >> 8); 27562| 200| d[1] = (uint8_t)(dg >> 8); 27563| 200| d[2] = (uint8_t)(dr >> 8); 27564| | 27565| 200| s += 1 * 8; 27566| 200| d += 1 * 3; 27567| 200| n -= 1; 27568| 200| } 27569| | 27570| 19| return len; 27571| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src: 29526| 51| size_t src_len) { 29527| 51| size_t dst_len4 = dst_len / 4; 29528| 51| size_t src_len8 = src_len / 8; 29529| 51| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29529:16): [True: 2, False: 49] ------------------ 29530| 51| uint8_t* d = dst_ptr; 29531| 51| const uint8_t* s = src_ptr; 29532| | 29533| 51| size_t n = len; 29534| 405| while (n >= 1) { ------------------ | Branch (29534:10): [True: 354, False: 51] ------------------ 29535| 354| wuffs_base__poke_u32le__no_bounds_check( 29536| 354| d + (0 * 4), 29537| 354| wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr( 29538| 354| wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul( 29539| 354| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))))); 29540| | 29541| 354| s += 1 * 8; 29542| 354| d += 1 * 4; 29543| 354| n -= 1; 29544| 354| } 29545| 51| return len; 29546| 51|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over: 29555| 30| size_t src_len) { 29556| 30| size_t dst_len4 = dst_len / 4; 29557| 30| size_t src_len8 = src_len / 8; 29558| 30| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (29558:16): [True: 1, False: 29] ------------------ 29559| 30| uint8_t* d = dst_ptr; 29560| 30| const uint8_t* s = src_ptr; 29561| 30| size_t n = len; 29562| | 29563| 214| while (n >= 1) { ------------------ | Branch (29563:10): [True: 184, False: 30] ------------------ 29564| 184| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 29565| 184| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 29566| 184| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 29567| 184| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 29568| 184| wuffs_base__poke_u32le__no_bounds_check( 29569| 184| d + (0 * 4), 29570| 184| wuffs_base__color_u64__as__color_u32( 29571| 184| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0))); 29572| | 29573| 184| s += 1 * 8; 29574| 184| d += 1 * 4; 29575| 184| n -= 1; 29576| 184| } 29577| | 29578| 30| return len; 29579| 30|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src: 28870| 18| size_t src_len) { 28871| 18| size_t dst_len4 = dst_len / 4; 28872| 18| size_t src_len8 = src_len / 8; 28873| 18| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28873:16): [True: 1, False: 17] ------------------ 28874| 18| uint8_t* d = dst_ptr; 28875| 18| const uint8_t* s = src_ptr; 28876| 18| size_t n = len; 28877| | 28878| | // TODO: unroll. 28879| | 28880| 205| while (n >= 1) { ------------------ | Branch (28880:10): [True: 187, False: 18] ------------------ 28881| 187| uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)); 28882| 187| wuffs_base__poke_u32le__no_bounds_check( 28883| 187| d + (0 * 4), wuffs_base__color_swap_u32_argb_abgr( 28884| 187| wuffs_base__color_u64__as__color_u32(s0))); 28885| | 28886| 187| s += 1 * 8; 28887| 187| d += 1 * 4; 28888| 187| n -= 1; 28889| 187| } 28890| | 28891| 18| return len; 28892| 18|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src_over: 28901| 11| size_t src_len) { 28902| 11| size_t dst_len4 = dst_len / 4; 28903| 11| size_t src_len8 = src_len / 8; 28904| 11| size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8; ------------------ | Branch (28904:16): [True: 3, False: 8] ------------------ 28905| 11| uint8_t* d = dst_ptr; 28906| 11| const uint8_t* s = src_ptr; 28907| 11| size_t n = len; 28908| | 28909| | // TODO: unroll. 28910| | 28911| 99| while (n >= 1) { ------------------ | Branch (28911:10): [True: 88, False: 11] ------------------ 28912| 88| uint64_t d0 = wuffs_base__color_u32__as__color_u64( 28913| 88| wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4))); 28914| 88| uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr( 28915| 88| wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); 28916| 88| wuffs_base__poke_u32le__no_bounds_check( 28917| 88| d + (0 * 4), 28918| 88| wuffs_base__color_u64__as__color_u32( 28919| 88| wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0))); 28920| | 28921| 88| s += 1 * 8; 28922| 88| d += 1 * 4; 28923| 88| n -= 1; 28924| 88| } 28925| | 28926| 11| return len; 28927| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgrx: 32305| 134| wuffs_base__pixel_blend blend) { 32306| 134| switch (dst_pixfmt.repr) { ------------------ | Branch (32306:11): [True: 118, False: 16] ------------------ 32307| 20| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 20|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32307:5): [True: 20, False: 114] ------------------ 32308| 20| return wuffs_private_impl__swizzle_y__bgrx; 32309| | 32310| 11| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32310:5): [True: 11, False: 123] ------------------ 32311| 11| return wuffs_private_impl__swizzle_bgr_565__bgrx; 32312| | 32313| 10| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 10|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32313:5): [True: 10, False: 124] ------------------ 32314| 10| return wuffs_private_impl__swizzle_xxx__xxxx; 32315| | 32316| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32316:5): [True: 6, False: 128] ------------------ 32317| 21| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 21|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32317:5): [True: 15, False: 119] ------------------ 32318| 21| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 21|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32318:5): [True: 0, False: 134] ------------------ 32319| 21| return wuffs_private_impl__swizzle_bgrw__bgrx; 32320| | 32321| 19| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32321:5): [True: 19, False: 115] ------------------ 32322| 19| return wuffs_private_impl__swizzle_bgrw_4x16le__bgrx; 32323| | 32324| 3| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 3|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32324:5): [True: 3, False: 131] ------------------ 32325| 3| return wuffs_private_impl__swizzle_copy_4_4; 32326| | 32327| 13| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 13|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32327:5): [True: 13, False: 121] ------------------ 32328| 13| return wuffs_private_impl__swizzle_bgr__rgbx; 32329| | 32330| 18| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 18|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32330:5): [True: 18, False: 116] ------------------ 32331| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32331:5): [True: 3, False: 131] ------------------ 32332| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: ------------------ | | 4976| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 ------------------ | Branch (32332:5): [True: 0, False: 134] ------------------ 32333| 21| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 21|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (32333:5): [True: 0, False: 134] ------------------ 32334| 21| return wuffs_private_impl__swizzle_bgrw__rgbx; 32335| 134| } 32336| 16| return NULL; 32337| 134|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgrx: 30689| 20| size_t src_len) { 30690| 20| size_t src_len4 = src_len / 4; 30691| 20| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30691:16): [True: 1, False: 19] ------------------ 30692| 20| uint8_t* d = dst_ptr; 30693| 20| const uint8_t* s = src_ptr; 30694| 20| size_t n = len; 30695| | 30696| | // TODO: unroll. 30697| | 30698| 429| while (n >= 1) { ------------------ | Branch (30698:10): [True: 409, False: 20] ------------------ 30699| 409| uint32_t s0 = 30700| 409| 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); 30701| 409| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30702| | 30703| 409| s += 1 * 4; 30704| 409| d += 1 * 1; 30705| 409| n -= 1; 30706| 409| } 30707| | 30708| 20| return len; 30709| 20|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgrx: 26040| 11| size_t src_len) { 26041| 11| size_t dst_len2 = dst_len / 2; 26042| 11| size_t src_len4 = src_len / 4; 26043| 11| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26043:16): [True: 1, False: 10] ------------------ 26044| 11| uint8_t* d = dst_ptr; 26045| 11| const uint8_t* s = src_ptr; 26046| 11| size_t n = len; 26047| | 26048| | // TODO: unroll. 26049| | 26050| 224| while (n >= 1) { ------------------ | Branch (26050:10): [True: 213, False: 11] ------------------ 26051| 213| uint32_t b5 = (uint32_t)(s[0] >> 3); 26052| 213| uint32_t g6 = (uint32_t)(s[1] >> 2); 26053| 213| uint32_t r5 = (uint32_t)(s[2] >> 3); 26054| 213| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 26055| 213| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26056| | 26057| 213| s += 1 * 4; 26058| 213| d += 1 * 2; 26059| 213| n -= 1; 26060| 213| } 26061| | 26062| 11| return len; 26063| 11|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__xxxx: 29779| 10| size_t src_len) { 29780| 10| size_t dst_len3 = dst_len / 3; 29781| 10| size_t src_len4 = src_len / 4; 29782| 10| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (29782:16): [True: 2, False: 8] ------------------ 29783| 10| uint8_t* d = dst_ptr; 29784| 10| const uint8_t* s = src_ptr; 29785| 10| size_t n = len; 29786| | 29787| | // TODO: unroll. 29788| | 29789| 209| while (n >= 1) { ------------------ | Branch (29789:10): [True: 199, False: 10] ------------------ 29790| 199| wuffs_base__poke_u24le__no_bounds_check( 29791| 199| d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 29792| | 29793| 199| s += 1 * 4; 29794| 199| d += 1 * 3; 29795| 199| n -= 1; 29796| 199| } 29797| | 29798| 10| return len; 29799| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgrx: 29089| 21| size_t src_len) { 29090| 21| size_t dst_len4 = dst_len / 4; 29091| 21| size_t src_len4 = src_len / 4; 29092| 21| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (29092:16): [True: 3, False: 18] ------------------ 29093| 21| uint8_t* d = dst_ptr; 29094| 21| const uint8_t* s = src_ptr; 29095| 21| size_t n = len; 29096| | 29097| | // TODO: unroll. 29098| | 29099| 359| while (n >= 1) { ------------------ | Branch (29099:10): [True: 338, False: 21] ------------------ 29100| 338| wuffs_base__poke_u32le__no_bounds_check( 29101| 338| d + (0 * 4), 29102| 338| 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 29103| | 29104| 338| s += 1 * 4; 29105| 338| d += 1 * 4; 29106| 338| n -= 1; 29107| 338| } 29108| | 29109| 21| return len; 29110| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgrx: 29358| 19| size_t src_len) { 29359| 19| size_t dst_len8 = dst_len / 8; 29360| 19| size_t src_len4 = src_len / 4; 29361| 19| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (29361:16): [True: 11, False: 8] ------------------ 29362| 19| uint8_t* d = dst_ptr; 29363| 19| const uint8_t* s = src_ptr; 29364| 19| size_t n = len; 29365| | 29366| 267| while (n >= 1) { ------------------ | Branch (29366:10): [True: 248, False: 19] ------------------ 29367| 248| uint8_t s0 = s[0]; 29368| 248| uint8_t s1 = s[1]; 29369| 248| uint8_t s2 = s[2]; 29370| 248| d[0] = s0; 29371| 248| d[1] = s0; 29372| 248| d[2] = s1; 29373| 248| d[3] = s1; 29374| 248| d[4] = s2; 29375| 248| d[5] = s2; 29376| 248| d[6] = 0xFF; 29377| 248| d[7] = 0xFF; 29378| | 29379| 248| s += 1 * 4; 29380| 248| d += 1 * 8; 29381| 248| n -= 1; 29382| 248| } 29383| | 29384| 19| return len; 29385| 19|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgbx: 27579| 13| size_t src_len) { 27580| 13| size_t dst_len3 = dst_len / 3; 27581| 13| size_t src_len4 = src_len / 4; 27582| 13| size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4; ------------------ | Branch (27582:16): [True: 2, False: 11] ------------------ 27583| 13| uint8_t* d = dst_ptr; 27584| 13| const uint8_t* s = src_ptr; 27585| 13| size_t n = len; 27586| | 27587| | // TODO: unroll. 27588| | 27589| 215| while (n >= 1) { ------------------ | Branch (27589:10): [True: 202, False: 13] ------------------ 27590| 202| uint8_t b0 = s[0]; 27591| 202| uint8_t b1 = s[1]; 27592| 202| uint8_t b2 = s[2]; 27593| 202| d[0] = b2; 27594| 202| d[1] = b1; 27595| 202| d[2] = b0; 27596| | 27597| 202| s += 1 * 4; 27598| 202| d += 1 * 3; 27599| 202| n -= 1; 27600| 202| } 27601| | 27602| 13| return len; 27603| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgbx: 29259| 21| size_t src_len) { 29260| 21| size_t dst_len4 = dst_len / 4; 29261| 21| size_t src_len4 = src_len / 4; 29262| 21| size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4; ------------------ | Branch (29262:16): [True: 3, False: 18] ------------------ 29263| 21| uint8_t* d = dst_ptr; 29264| 21| const uint8_t* s = src_ptr; 29265| 21| size_t n = len; 29266| | 29267| | // TODO: unroll. 29268| | 29269| 433| while (n >= 1) { ------------------ | Branch (29269:10): [True: 412, False: 21] ------------------ 29270| 412| uint8_t b0 = s[0]; 29271| 412| uint8_t b1 = s[1]; 29272| 412| uint8_t b2 = s[2]; 29273| 412| d[0] = b2; 29274| 412| d[1] = b1; 29275| 412| d[2] = b0; 29276| 412| d[3] = 0xFF; 29277| | 29278| 412| s += 1 * 4; 29279| 412| d += 1 * 4; 29280| 412| n -= 1; 29281| 412| } 29282| | 29283| 21| return len; 29284| 21|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgb: 32345| 111| wuffs_base__pixel_blend blend) { 32346| 111| switch (dst_pixfmt.repr) { ------------------ | Branch (32346:11): [True: 96, False: 15] ------------------ 32347| 19| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 19|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32347:5): [True: 19, False: 92] ------------------ 32348| 19| 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: 98] ------------------ 32351| 13| return wuffs_private_impl__swizzle_bgr_565__rgb; 32352| | 32353| 11| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 11|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32353:5): [True: 11, False: 100] ------------------ 32354| 11| 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: 102] ------------------ 32357| 14| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32357:5): [True: 5, False: 106] ------------------ 32358| 14| case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: ------------------ | | 4968| 14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 ------------------ | Branch (32358:5): [True: 0, False: 111] ------------------ 32359| 19| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 19|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32359:5): [True: 5, False: 106] ------------------ 32360| 19|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32361| 19| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32361:11): [True: 19, False: 0] ------------------ 32362| 19| return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42; 32363| 19| } 32364| 0|#endif 32365| 0| return wuffs_private_impl__swizzle_bgrw__rgb; 32366| | 32367| 14| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32367:5): [True: 14, False: 97] ------------------ 32368| 14| return wuffs_private_impl__swizzle_bgrw_4x16le__rgb; 32369| | 32370| 9| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 9|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32370:5): [True: 9, False: 102] ------------------ 32371| 9| 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: 106] ------------------ 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: 105] ------------------ 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: 111] ------------------ 32376| 11| case WUFFS_BASE__PIXEL_FORMAT__RGBX: ------------------ | | 4977| 11|#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 ------------------ | Branch (32376:5): [True: 0, False: 111] ------------------ 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| 111| } 32384| 15| return NULL; 32385| 111|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgb: 30717| 19| size_t src_len) { 30718| 19| size_t src_len3 = src_len / 3; 30719| 19| size_t len = (dst_len < src_len3) ? dst_len : src_len3; ------------------ | Branch (30719:16): [True: 3, False: 16] ------------------ 30720| 19| uint8_t* d = dst_ptr; 30721| 19| const uint8_t* s = src_ptr; 30722| 19| size_t n = len; 30723| | 30724| | // TODO: unroll. 30725| | 30726| 471| while (n >= 1) { ------------------ | Branch (30726:10): [True: 452, False: 19] ------------------ 30727| 452| uint32_t s0 = 30728| 452| 0xFF000000 | wuffs_base__peek_u24be__no_bounds_check(s + (0 * 3)); 30729| 452| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30730| | 30731| 452| s += 1 * 3; 30732| 452| d += 1 * 1; 30733| 452| n -= 1; 30734| 452| } 30735| | 30736| 19| return len; 30737| 19|} 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: 2, False: 11] ------------------ 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| 229| while (n >= 1) { ------------------ | Branch (26430:10): [True: 216, False: 13] ------------------ 26431| 216| uint32_t r5 = (uint32_t)(s[0] >> 3); 26432| 216| uint32_t g6 = (uint32_t)(s[1] >> 2); 26433| 216| uint32_t b5 = (uint32_t)(s[2] >> 3); 26434| 216| uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0); 26435| 216| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565); 26436| | 26437| 216| s += 1 * 3; 26438| 216| d += 1 * 2; 26439| 216| n -= 1; 26440| 216| } 26441| | 26442| 13| return len; 26443| 13|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__rgb: 29393| 14| size_t src_len) { 29394| 14| size_t dst_len8 = dst_len / 8; 29395| 14| size_t src_len3 = src_len / 3; 29396| 14| size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3; ------------------ | Branch (29396:16): [True: 7, False: 7] ------------------ 29397| 14| uint8_t* d = dst_ptr; 29398| 14| const uint8_t* s = src_ptr; 29399| 14| size_t n = len; 29400| | 29401| 117| while (n >= 1) { ------------------ | Branch (29401:10): [True: 103, False: 14] ------------------ 29402| 103| uint8_t s0 = s[0]; 29403| 103| uint8_t s1 = s[1]; 29404| 103| uint8_t s2 = s[2]; 29405| 103| d[0] = s2; 29406| 103| d[1] = s2; 29407| 103| d[2] = s1; 29408| 103| d[3] = s1; 29409| 103| d[4] = s0; 29410| 103| d[5] = s0; 29411| 103| d[6] = 0xFF; 29412| 103| d[7] = 0xFF; 29413| | 29414| 103| s += 1 * 3; 29415| 103| d += 1 * 8; 29416| 103| n -= 1; 29417| 103| } 29418| | 29419| 14| return len; 29420| 14|} 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: 199, False: 18] ------------------ 32395| 24| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 24|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32395:5): [True: 24, False: 193] ------------------ 32396| 24| switch (blend) { ------------------ | Branch (32396:15): [True: 24, False: 0] ------------------ 32397| 12| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32397:9): [True: 12, False: 12] ------------------ 32398| 12| return wuffs_private_impl__swizzle_y__rgba_nonpremul__src; 32399| 12| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32399:9): [True: 12, False: 12] ------------------ 32400| 12| return wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over; 32401| 24| } 32402| 0| return NULL; 32403| | 32404| 25| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 25|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32404:5): [True: 25, False: 192] ------------------ 32405| 25| switch (blend) { ------------------ | Branch (32405:15): [True: 25, 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: 10] ------------------ 32407| 15| return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src; 32408| 10| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32408:9): [True: 10, False: 15] ------------------ 32409| 10| return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over; 32410| 25| } 32411| 0| return NULL; 32412| | 32413| 7| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 7|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32413:5): [True: 7, False: 210] ------------------ 32414| 7| switch (blend) { ------------------ | Branch (32414:15): [True: 7, False: 0] ------------------ 32415| 0| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32415:9): [True: 0, False: 7] ------------------ 32416| 0| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src; 32417| 7| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 7|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32417:9): [True: 7, False: 0] ------------------ 32418| 7| return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over; 32419| 7| } 32420| 0| return NULL; 32421| | 32422| 34| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: ------------------ | | 4964| 34|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 ------------------ | Branch (32422:5): [True: 34, False: 183] ------------------ 32423| 34| switch (blend) { ------------------ | Branch (32423:15): [True: 34, False: 0] ------------------ 32424| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32424:9): [True: 10, False: 24] ------------------ 32425| 10|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) 32426| 10| if (wuffs_base__cpu_arch__have_x86_sse42()) { ------------------ | Branch (32426:15): [True: 10, False: 0] ------------------ 32427| 10| return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; 32428| 10| } 32429| 0|#endif 32430| 0| return wuffs_private_impl__swizzle_swap_rgbx_bgrx; 32431| 24| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 24|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32431:9): [True: 24, False: 10] ------------------ 32432| 24| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over; 32433| 34| } 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| 9| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32438:9): [True: 9, False: 29] ------------------ 32439| 9| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src; 32440| 29| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 29|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32440:9): [True: 29, False: 9] ------------------ 32441| 29| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over; 32442| 38| } 32443| 0| return NULL; 32444| | 32445| 13| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 13|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32445:5): [True: 13, False: 204] ------------------ 32446| 13| switch (blend) { ------------------ | Branch (32446:15): [True: 13, False: 0] ------------------ 32447| 5| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32447:9): [True: 5, False: 8] ------------------ 32448| 5| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src; 32449| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32449:9): [True: 8, False: 5] ------------------ 32450| 8| return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over; 32451| 13| } 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| 6| case WUFFS_BASE__PIXEL_FORMAT__BGRX: ------------------ | | 4969| 6|#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 ------------------ | Branch (32455:5): [True: 6, False: 211] ------------------ 32456| | // TODO. 32457| 6| break; 32458| | 32459| 12| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 12|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32459:5): [True: 12, False: 205] ------------------ 32460| 12| switch (blend) { ------------------ | Branch (32460:15): [True: 12, False: 0] ------------------ 32461| 10| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32461:9): [True: 10, False: 2] ------------------ 32462| 10| 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: 10] ------------------ 32464| 2| return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over; 32465| 12| } 32466| 0| return NULL; 32467| | 32468| 9| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 9|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32468:5): [True: 9, False: 208] ------------------ 32469| 9| switch (blend) { ------------------ | Branch (32469:15): [True: 9, 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: 9] ------------------ 32471| 0| return wuffs_private_impl__swizzle_copy_4_4; 32472| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32472:9): [True: 9, False: 0] ------------------ 32473| 9| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over; 32474| 9| } 32475| 0| return NULL; 32476| | 32477| 31| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 31|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32477:5): [True: 31, False: 186] ------------------ 32478| 31| switch (blend) { ------------------ | Branch (32478:15): [True: 31, False: 0] ------------------ 32479| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32479:9): [True: 16, False: 15] ------------------ 32480| 16| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src; 32481| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32481:9): [True: 15, False: 16] ------------------ 32482| 15| return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over; 32483| 31| } 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| 24| return NULL; 32492| 217|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src: 30745| 12| size_t src_len) { 30746| 12| size_t src_len4 = src_len / 4; 30747| 12| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30747:16): [True: 1, False: 11] ------------------ 30748| 12| uint8_t* d = dst_ptr; 30749| 12| const uint8_t* s = src_ptr; 30750| 12| size_t n = len; 30751| | 30752| | // TODO: unroll. 30753| | 30754| 199| while (n >= 1) { ------------------ | Branch (30754:10): [True: 187, False: 12] ------------------ 30755| 187| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30756| 187| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 30757| 187| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 30758| 187| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30759| | 30760| 187| s += 1 * 4; 30761| 187| d += 1 * 1; 30762| 187| n -= 1; 30763| 187| } 30764| | 30765| 12| return len; 30766| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over: 30775| 12| size_t src_len) { 30776| 12| size_t src_len4 = src_len / 4; 30777| 12| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30777:16): [True: 3, False: 9] ------------------ 30778| 12| uint8_t* d = dst_ptr; 30779| 12| const uint8_t* s = src_ptr; 30780| 12| size_t n = len; 30781| | 30782| | // TODO: unroll. 30783| | 30784| 168| while (n >= 1) { ------------------ | Branch (30784:10): [True: 156, False: 12] ------------------ 30785| 156| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30786| 156| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30787| 156| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30788| 156| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30789| 156| wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); 30790| | 30791| 156| s += 1 * 4; 30792| 156| d += 1 * 1; 30793| 156| n -= 1; 30794| 156| } 30795| | 30796| 12| return len; 30797| 12|} 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: 1, False: 14] ------------------ 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| 294| while (n >= 1) { ------------------ | Branch (26462:10): [True: 279, False: 15] ------------------ 26463| 279| wuffs_base__poke_u16le__no_bounds_check( 26464| 279| d + (0 * 2), 26465| 279| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26466| 279| wuffs_base__color_swap_u32_argb_abgr( 26467| 279| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( 26468| 279| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))))); 26469| | 26470| 279| s += 1 * 4; 26471| 279| d += 1 * 2; 26472| 279| n -= 1; 26473| 279| } 26474| | 26475| 15| return len; 26476| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over: 26485| 10| size_t src_len) { 26486| 10| size_t dst_len2 = dst_len / 2; 26487| 10| size_t src_len4 = src_len / 4; 26488| 10| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26488:16): [True: 1, False: 9] ------------------ 26489| 10| uint8_t* d = dst_ptr; 26490| 10| const uint8_t* s = src_ptr; 26491| 10| size_t n = len; 26492| | 26493| | // TODO: unroll. 26494| | 26495| 175| while (n >= 1) { ------------------ | Branch (26495:10): [True: 165, False: 10] ------------------ 26496| | // Extract 16-bit color components. 26497| 165| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26498| 165| uint32_t sb = 0x101 * ((uint32_t)s[2]); 26499| 165| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26500| 165| uint32_t sr = 0x101 * ((uint32_t)s[0]); 26501| | 26502| | // Convert from 565 color to 16-bit color. 26503| 165| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26504| 165| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26505| 165| uint32_t dr = (0x8421 * old_r5) >> 4; 26506| 165| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26507| 165| uint32_t dg = (0x1041 * old_g6) >> 2; 26508| 165| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26509| 165| uint32_t db = (0x8421 * old_b5) >> 4; 26510| | 26511| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26512| 165| uint32_t ia = 0xFFFF - sa; 26513| | 26514| | // Composite src (nonpremul) over dst (premul). 26515| 165| dr = ((sr * sa) + (dr * ia)) / 0xFFFF; 26516| 165| dg = ((sg * sa) + (dg * ia)) / 0xFFFF; 26517| 165| db = ((sb * sa) + (db * ia)) / 0xFFFF; 26518| | 26519| | // Convert from 16-bit color to 565 color and combine the components. 26520| 165| uint32_t new_r5 = 0x1F & (dr >> 11); 26521| 165| uint32_t new_g6 = 0x3F & (dg >> 10); 26522| 165| uint32_t new_b5 = 0x1F & (db >> 11); 26523| 165| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26524| 165| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26525| | 26526| 165| s += 1 * 4; 26527| 165| d += 1 * 2; 26528| 165| n -= 1; 26529| 165| } 26530| | 26531| 10| return len; 26532| 10|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src: 28260| 9| size_t src_len) { 28261| 9| size_t dst_len8 = dst_len / 8; 28262| 9| size_t src_len4 = src_len / 4; 28263| 9| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28263:16): [True: 5, False: 4] ------------------ 28264| 9| uint8_t* d = dst_ptr; 28265| 9| const uint8_t* s = src_ptr; 28266| | 28267| 9| size_t n = len; 28268| 68| while (n >= 1) { ------------------ | Branch (28268:10): [True: 59, False: 9] ------------------ 28269| 59| uint8_t s0 = s[0]; 28270| 59| uint8_t s1 = s[1]; 28271| 59| uint8_t s2 = s[2]; 28272| 59| uint8_t s3 = s[3]; 28273| 59| d[0] = s2; 28274| 59| d[1] = s2; 28275| 59| d[2] = s1; 28276| 59| d[3] = s1; 28277| 59| d[4] = s0; 28278| 59| d[5] = s0; 28279| 59| d[6] = s3; 28280| 59| d[7] = s3; 28281| | 28282| 59| s += 1 * 4; 28283| 59| d += 1 * 8; 28284| 59| n -= 1; 28285| 59| } 28286| 9| return len; 28287| 9|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over: 28296| 29| size_t src_len) { 28297| 29| size_t dst_len8 = dst_len / 8; 28298| 29| size_t src_len4 = src_len / 4; 28299| 29| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28299:16): [True: 11, False: 18] ------------------ 28300| 29| uint8_t* d = dst_ptr; 28301| 29| const uint8_t* s = src_ptr; 28302| | 28303| 29| size_t n = len; 28304| 174| while (n >= 1) { ------------------ | Branch (28304:10): [True: 145, False: 29] ------------------ 28305| 145| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28306| 145| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28307| 145| wuffs_base__color_swap_u32_argb_abgr( 28308| 145| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 28309| 145| wuffs_base__poke_u64le__no_bounds_check( 28310| 145| d + (0 * 8), 28311| 145| wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0)); 28312| | 28313| 145| s += 1 * 4; 28314| 145| d += 1 * 8; 28315| 145| n -= 1; 28316| 145| } 28317| 29| return len; 28318| 29|} pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgba_premul: 32500| 238| wuffs_base__pixel_blend blend) { 32501| 238| switch (dst_pixfmt.repr) { ------------------ | Branch (32501:11): [True: 216, False: 22] ------------------ 32502| 31| case WUFFS_BASE__PIXEL_FORMAT__Y: ------------------ | | 4943| 31|#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 ------------------ | Branch (32502:5): [True: 31, False: 207] ------------------ 32503| 31| switch (blend) { ------------------ | Branch (32503:15): [True: 31, False: 0] ------------------ 32504| 16| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32504:9): [True: 16, False: 15] ------------------ 32505| 16| return wuffs_private_impl__swizzle_y__rgba_premul__src; 32506| 15| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32506:9): [True: 15, False: 16] ------------------ 32507| 15| return wuffs_private_impl__swizzle_y__rgba_premul__src_over; 32508| 31| } 32509| 0| return NULL; 32510| | 32511| 24| case WUFFS_BASE__PIXEL_FORMAT__BGR_565: ------------------ | | 4962| 24|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 ------------------ | Branch (32511:5): [True: 24, False: 214] ------------------ 32512| 24| switch (blend) { ------------------ | Branch (32512:15): [True: 24, False: 0] ------------------ 32513| 12| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32513:9): [True: 12, False: 12] ------------------ 32514| 12| return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src; 32515| 12| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32515:9): [True: 12, False: 12] ------------------ 32516| 12| return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over; 32517| 24| } 32518| 0| return NULL; 32519| | 32520| 9| case WUFFS_BASE__PIXEL_FORMAT__BGR: ------------------ | | 4963| 9|#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 ------------------ | Branch (32520:5): [True: 9, False: 229] ------------------ 32521| 9| switch (blend) { ------------------ | Branch (32521:15): [True: 9, False: 0] ------------------ 32522| 1| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32522:9): [True: 1, False: 8] ------------------ 32523| 1| return wuffs_private_impl__swizzle_bgr__rgba_premul__src; 32524| 8| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32524:9): [True: 8, False: 1] ------------------ 32525| 8| return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; 32526| 9| } 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: 221] ------------------ 32530| 17| switch (blend) { ------------------ | Branch (32530:15): [True: 17, False: 0] ------------------ 32531| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32531:9): [True: 8, False: 9] ------------------ 32532| 8| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src; 32533| 9| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32533:9): [True: 9, False: 8] ------------------ 32534| 9| return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; 32535| 17| } 32536| 0| return NULL; 32537| | 32538| 46| case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: ------------------ | | 4965| 46|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB ------------------ | Branch (32538:5): [True: 46, False: 192] ------------------ 32539| 46| switch (blend) { ------------------ | Branch (32539:15): [True: 46, False: 0] ------------------ 32540| 23| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 23|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32540:9): [True: 23, False: 23] ------------------ 32541| 23| 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: 23] ------------------ 32543| 23| return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src_over; 32544| 46| } 32545| 0| return NULL; 32546| | 32547| 17| case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: ------------------ | | 4966| 17|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 ------------------ | Branch (32547:5): [True: 17, False: 221] ------------------ 32548| 17| switch (blend) { ------------------ | Branch (32548:15): [True: 17, 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: 12] ------------------ 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| 12| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32556:9): [True: 12, False: 5] ------------------ 32557| 12| return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; 32558| 17| } 32559| 0| return NULL; 32560| | 32561| 13| case WUFFS_BASE__PIXEL_FORMAT__RGB: ------------------ | | 4971| 13|#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 ------------------ | Branch (32561:5): [True: 13, False: 225] ------------------ 32562| 13| switch (blend) { ------------------ | Branch (32562:15): [True: 13, False: 0] ------------------ 32563| 8| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32563:9): [True: 8, False: 5] ------------------ 32564| 8| 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: 8] ------------------ 32566| 5| return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; 32567| 13| } 32568| 0| return NULL; 32569| | 32570| 43| case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: ------------------ | | 4972| 43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 ------------------ | Branch (32570:5): [True: 43, False: 195] ------------------ 32571| 43| switch (blend) { ------------------ | Branch (32571:15): [True: 43, False: 0] ------------------ 32572| 22| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 22|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32572:9): [True: 22, False: 21] ------------------ 32573| 22| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src; 32574| 21| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 21|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32574:9): [True: 21, False: 22] ------------------ 32575| 21| return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; 32576| 43| } 32577| 0| return NULL; 32578| | 32579| 16| case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: ------------------ | | 4974| 16|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 ------------------ | Branch (32579:5): [True: 16, False: 222] ------------------ 32580| 16| switch (blend) { ------------------ | Branch (32580:15): [True: 16, False: 0] ------------------ 32581| 3| case WUFFS_BASE__PIXEL_BLEND__SRC: ------------------ | | 4855| 3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) ------------------ | Branch (32581:9): [True: 3, False: 13] ------------------ 32582| 3| return wuffs_private_impl__swizzle_copy_4_4; 32583| 13| case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: ------------------ | | 4856| 13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) ------------------ | Branch (32583:9): [True: 13, False: 3] ------------------ 32584| 13| return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; 32585| 16| } 32586| 0| return NULL; 32587| 238| } 32588| 22| return NULL; 32589| 238|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src: 30805| 16| size_t src_len) { 30806| 16| size_t src_len4 = src_len / 4; 30807| 16| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30807:16): [True: 1, False: 15] ------------------ 30808| 16| uint8_t* d = dst_ptr; 30809| 16| const uint8_t* s = src_ptr; 30810| 16| size_t n = len; 30811| | 30812| | // TODO: unroll. 30813| | 30814| 310| while (n >= 1) { ------------------ | Branch (30814:10): [True: 294, False: 16] ------------------ 30815| 294| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30816| 294| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30817| 294| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); 30818| | 30819| 294| s += 1 * 4; 30820| 294| d += 1 * 1; 30821| 294| n -= 1; 30822| 294| } 30823| | 30824| 16| return len; 30825| 16|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src_over: 30833| 15| size_t src_len) { 30834| 15| size_t src_len4 = src_len / 4; 30835| 15| size_t len = (dst_len < src_len4) ? dst_len : src_len4; ------------------ | Branch (30835:16): [True: 1, False: 14] ------------------ 30836| 15| uint8_t* d = dst_ptr; 30837| 15| const uint8_t* s = src_ptr; 30838| 15| size_t n = len; 30839| | 30840| | // TODO: unroll. 30841| | 30842| 223| while (n >= 1) { ------------------ | Branch (30842:10): [True: 208, False: 15] ------------------ 30843| 208| uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); 30844| 208| uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr( 30845| 208| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); 30846| 208| d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( 30847| 208| wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); 30848| | 30849| 208| s += 1 * 4; 30850| 208| d += 1 * 1; 30851| 208| n -= 1; 30852| 208| } 30853| | 30854| 15| return len; 30855| 15|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src: 26540| 12| size_t src_len) { 26541| 12| size_t dst_len2 = dst_len / 2; 26542| 12| size_t src_len4 = src_len / 4; 26543| 12| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26543:16): [True: 1, False: 11] ------------------ 26544| 12| uint8_t* d = dst_ptr; 26545| 12| const uint8_t* s = src_ptr; 26546| 12| size_t n = len; 26547| | 26548| | // TODO: unroll. 26549| | 26550| 188| while (n >= 1) { ------------------ | Branch (26550:10): [True: 176, False: 12] ------------------ 26551| 176| wuffs_base__poke_u16le__no_bounds_check( 26552| 176| d + (0 * 2), 26553| 176| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( 26554| 176| wuffs_base__color_swap_u32_argb_abgr( 26555| 176| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 26556| | 26557| 176| s += 1 * 4; 26558| 176| d += 1 * 2; 26559| 176| n -= 1; 26560| 176| } 26561| | 26562| 12| return len; 26563| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over: 26572| 12| size_t src_len) { 26573| 12| size_t dst_len2 = dst_len / 2; 26574| 12| size_t src_len4 = src_len / 4; 26575| 12| size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4; ------------------ | Branch (26575:16): [True: 2, False: 10] ------------------ 26576| 12| uint8_t* d = dst_ptr; 26577| 12| const uint8_t* s = src_ptr; 26578| 12| size_t n = len; 26579| | 26580| | // TODO: unroll. 26581| | 26582| 192| while (n >= 1) { ------------------ | Branch (26582:10): [True: 180, False: 12] ------------------ 26583| | // Extract 16-bit color components. 26584| 180| uint32_t sa = 0x101 * ((uint32_t)s[3]); 26585| 180| uint32_t sb = 0x101 * ((uint32_t)s[2]); 26586| 180| uint32_t sg = 0x101 * ((uint32_t)s[1]); 26587| 180| uint32_t sr = 0x101 * ((uint32_t)s[0]); 26588| | 26589| | // Convert from 565 color to 16-bit color. 26590| 180| uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)); 26591| 180| uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11); 26592| 180| uint32_t dr = (0x8421 * old_r5) >> 4; 26593| 180| uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5); 26594| 180| uint32_t dg = (0x1041 * old_g6) >> 2; 26595| 180| uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0); 26596| 180| uint32_t db = (0x8421 * old_b5) >> 4; 26597| | 26598| | // Calculate the inverse of the src-alpha: how much of the dst to keep. 26599| 180| uint32_t ia = 0xFFFF - sa; 26600| | 26601| | // Composite src (premul) over dst (premul). 26602| 180| dr = sr + ((dr * ia) / 0xFFFF); 26603| 180| dg = sg + ((dg * ia) / 0xFFFF); 26604| 180| db = sb + ((db * ia) / 0xFFFF); 26605| | 26606| | // Convert from 16-bit color to 565 color and combine the components. 26607| 180| uint32_t new_r5 = 0x1F & (dr >> 11); 26608| 180| uint32_t new_g6 = 0x3F & (dg >> 10); 26609| 180| uint32_t new_b5 = 0x1F & (db >> 11); 26610| 180| uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0); 26611| 180| wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565); 26612| | 26613| 180| s += 1 * 4; 26614| 180| d += 1 * 2; 26615| 180| n -= 1; 26616| 180| } 26617| | 26618| 12| return len; 26619| 12|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src: 28327| 23| size_t src_len) { 28328| 23| size_t dst_len8 = dst_len / 8; 28329| 23| size_t src_len4 = src_len / 4; 28330| 23| size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4; ------------------ | Branch (28330:16): [True: 6, False: 17] ------------------ 28331| 23| uint8_t* d = dst_ptr; 28332| 23| const uint8_t* s = src_ptr; 28333| | 28334| 23| size_t n = len; 28335| 181| while (n >= 1) { ------------------ | Branch (28335:10): [True: 158, False: 23] ------------------ 28336| 158| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28337| 158| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( 28338| 158| wuffs_base__color_swap_u32_argb_abgr( 28339| 158| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))); 28340| 158| wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0); 28341| | 28342| 158| s += 1 * 4; 28343| 158| d += 1 * 8; 28344| 158| n -= 1; 28345| 158| } 28346| 23| return len; 28347| 23|} 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: 9, False: 14] ------------------ 28360| 23| uint8_t* d = dst_ptr; 28361| 23| const uint8_t* s = src_ptr; 28362| | 28363| 23| size_t n = len; 28364| 205| while (n >= 1) { ------------------ | Branch (28364:10): [True: 182, False: 23] ------------------ 28365| 182| uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8)); 28366| 182| uint64_t s0 = wuffs_base__color_u32__as__color_u64( 28367| 182| wuffs_base__color_swap_u32_argb_abgr( 28368| 182| wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); 28369| 182| wuffs_base__poke_u64le__no_bounds_check( 28370| 182| d + (0 * 8), 28371| 182| wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)); 28372| | 28373| 182| s += 1 * 4; 28374| 182| d += 1 * 8; 28375| 182| n -= 1; 28376| 182| } 28377| 23| return len; 28378| 23|} pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__max_of_4: 32935| 6.79k| uint32_t d) { 32936| 6.79k| return wuffs_base__u32__max( // 32937| 6.79k| wuffs_base__u32__max(a, b), // 32938| 6.79k| wuffs_base__u32__max(c, d)); 32939| 6.79k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__width: 5379| 2.20k|wuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) { 5380| 2.20k| return c ? c->private_impl.width : 0; ------------------ | Branch (5380:10): [True: 2.20k, False: 0] ------------------ 5381| 2.20k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__min_of_5: 32946| 4.41k| uint32_t e) { 32947| 4.41k| return wuffs_base__u32__min( // 32948| 4.41k| wuffs_base__u32__min( // 32949| 4.41k| wuffs_base__u32__min(a, b), // 32950| 4.41k| wuffs_base__u32__min(c, d)), // 32951| 4.41k| e); 32952| 4.41k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__height: 5384| 2.20k|wuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) { 5385| 2.20k| return c ? c->private_impl.height : 0; ------------------ | Branch (5385:10): [True: 2.20k, False: 0] ------------------ 5386| 2.20k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_flattened_length: 34251| 7.07k| uint32_t inv_v) { 34252| 7.07k| uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1u)) / inv_h; 34253| 7.07k| uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1u)) / inv_v; 34254| 7.07k| if (scaled_height <= 0u) { ------------------ | Branch (34254:7): [True: 0, False: 7.07k] ------------------ 34255| 0| return 0u; 34256| 0| } 34257| 7.07k| return ((scaled_height - 1u) * stride) + scaled_width; 34258| 7.07k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgb__convert_3_general: 33134| 9.28k| const uint8_t* up2) { 33135| 277k| for (; x < x_end; x++) { ------------------ | Branch (33135:10): [True: 267k, False: 9.28k] ------------------ 33136| 267k| uint32_t color = 0xFF000000u | // 33137| 267k| (((uint32_t)(*up0++)) << 16u) | // 33138| 267k| (((uint32_t)(*up1++)) << 8u) | // 33139| 267k| (((uint32_t)(*up2++)) << 0u); 33140| 267k| wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color); 33141| 267k| } 33142| 9.28k|} pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_avx2: 289| 951|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| 951|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) 295| | // GCC defines these macros but MSVC does not. 296| | // - bit_AVX2 = (1 << 5) 297| 951| 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| 951| const unsigned int avx2_ecx1 = 0x00900002; 303| | 304| | // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). 305| 951|#if defined(__GNUC__) 306| 951| unsigned int eax7 = 0; 307| 951| unsigned int ebx7 = 0; 308| 951| unsigned int ecx7 = 0; 309| 951| unsigned int edx7 = 0; 310| 951| if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) && ------------------ | Branch (310:7): [True: 951, False: 0] ------------------ 311| 951| ((ebx7 & avx2_ebx7) == avx2_ebx7)) { ------------------ | Branch (311:7): [True: 951, False: 0] ------------------ 312| 951| unsigned int eax1 = 0; 313| 951| unsigned int ebx1 = 0; 314| 951| unsigned int ecx1 = 0; 315| 951| unsigned int edx1 = 0; 316| 951| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && ------------------ | Branch (316:9): [True: 951, False: 0] ------------------ 317| 951| ((ecx1 & avx2_ecx1) == avx2_ecx1)) { ------------------ | Branch (317:9): [True: 951, False: 0] ------------------ 318| 951| return true; 319| 951| } 320| 951| } 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| 951|#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) && 337| | // defined(__AVX2__) 338| 951|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx: 33169| 4.37k| const uint8_t* up2) { 33170| 4.37k| size_t dst_stride = dst->private_impl.planes[0].stride; 33171| 4.37k| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 33172| 4.37k| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 33173| | 33174| 65.7k| for (; x < x_end; x++) { ------------------ | Branch (33174:10): [True: 61.3k, False: 4.37k] ------------------ 33175| 61.3k| uint32_t color = // 33176| 61.3k| wuffs_base__color_ycc_bt601fr__as__color_u32( // 33177| 61.3k| *up0++, *up1++, *up2++); 33178| 61.3k| wuffs_base__poke_u32le__no_bounds_check(dst_iter, color); 33179| 61.3k| dst_iter += 4u; 33180| 61.3k| } 33181| 4.37k|} pixel_swizzler_fuzzer.c:wuffs_base__color_ycc_bt601fr__as__color_u32: 4691| 290k| 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| 290k| uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15); 4695| 290k| uint32_t cb32 = (((uint32_t)cb) - 0x80); 4696| 290k| 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| 290k| uint32_t rr32 = yy32 + (0x166E9 * cr32); 4723| 290k| uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32); 4724| 290k| uint32_t bb32 = yy32 + (0x1C5A2 * cb32); 4725| 290k| if (rr32 >> 24) { ------------------ | Branch (4725:7): [True: 97.2k, False: 193k] ------------------ 4726| 97.2k| rr32 = ~((uint32_t)(((int32_t)rr32) >> 31)); 4727| 97.2k| } 4728| 290k| if (gg32 >> 24) { ------------------ | Branch (4728:7): [True: 61.1k, False: 229k] ------------------ 4729| 61.1k| gg32 = ~((uint32_t)(((int32_t)gg32) >> 31)); 4730| 61.1k| } 4731| 290k| if (bb32 >> 24) { ------------------ | Branch (4731:7): [True: 123k, False: 167k] ------------------ 4732| 123k| bb32 = ~((uint32_t)(((int32_t)bb32) >> 31)); 4733| 123k| } 4734| 290k| return 0xFF000000 | // 4735| 290k| ((0x00FF0000 & rr32) >> 0) | // 4736| 290k| ((0x00FF0000 & gg32) >> 8) | // 4737| 290k| ((0x00FF0000 & bb32) >> 16); 4738| 290k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx: 33191| 3.95k| const uint8_t* up2) { 33192| 3.95k| size_t dst_stride = dst->private_impl.planes[0].stride; 33193| 3.95k| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 33194| 3.95k| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 33195| | 33196| 57.9k| for (; x < x_end; x++) { ------------------ | Branch (33196:10): [True: 53.9k, False: 3.95k] ------------------ 33197| 53.9k| uint32_t color = // 33198| 53.9k| wuffs_base__color_ycc_bt601fr__as__color_u32_abgr( // 33199| 53.9k| *up0++, *up1++, *up2++); 33200| 53.9k| wuffs_base__poke_u32le__no_bounds_check(dst_iter, color); 33201| 53.9k| dst_iter += 4u; 33202| 53.9k| } 33203| 3.95k|} pixel_swizzler_fuzzer.c:wuffs_base__color_ycc_bt601fr__as__color_u32_abgr: 4746| 53.9k| uint8_t cr) { 4747| 53.9k| uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15); 4748| 53.9k| uint32_t cb32 = (((uint32_t)cb) - 0x80); 4749| 53.9k| uint32_t cr32 = (((uint32_t)cr) - 0x80); 4750| 53.9k| uint32_t rr32 = yy32 + (0x166E9 * cr32); 4751| 53.9k| uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32); 4752| 53.9k| uint32_t bb32 = yy32 + (0x1C5A2 * cb32); 4753| 53.9k| if (rr32 >> 24) { ------------------ | Branch (4753:7): [True: 20.2k, False: 33.6k] ------------------ 4754| 20.2k| rr32 = ~((uint32_t)(((int32_t)rr32) >> 31)); 4755| 20.2k| } 4756| 53.9k| if (gg32 >> 24) { ------------------ | Branch (4756:7): [True: 10.4k, False: 43.5k] ------------------ 4757| 10.4k| gg32 = ~((uint32_t)(((int32_t)gg32) >> 31)); 4758| 10.4k| } 4759| 53.9k| if (bb32 >> 24) { ------------------ | Branch (4759:7): [True: 25.7k, False: 28.1k] ------------------ 4760| 25.7k| bb32 = ~((uint32_t)(((int32_t)bb32) >> 31)); 4761| 25.7k| } 4762| 53.9k| return 0xFF000000 | // 4763| 53.9k| ((0x00FF0000 & bb32) >> 0) | // 4764| 53.9k| ((0x00FF0000 & gg32) >> 8) | // 4765| 53.9k| ((0x00FF0000 & rr32) >> 16); 4766| 53.9k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general: 33152| 10.8k| const uint8_t* up2) { 33153| 240k| for (; x < x_end; x++) { ------------------ | Branch (33153:10): [True: 229k, False: 10.8k] ------------------ 33154| 229k| uint32_t color = // 33155| 229k| wuffs_base__color_ycc_bt601fr__as__color_u32( // 33156| 229k| *up0++, *up1++, *up2++); 33157| 229k| wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color); 33158| 229k| } 33159| 10.8k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__box_filter: 34092| 1.26k| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 34093| 1.26k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = 34094| 1.26k| (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; 34095| 1.26k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = 34096| 1.26k| (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u]; 34097| 1.26k| wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 = 34098| 1.26k| (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; 34099| | 34100| 1.26k| uint32_t y; 34101| 22.5k| for (y = y_min_incl; y < y_max_excl; y++) { ------------------ | Branch (34101:24): [True: 21.2k, False: 1.26k] ------------------ 34102| 21.2k| const uint8_t* src0_major = 34103| 21.2k| src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0); 34104| 21.2k| const uint8_t* src1_major = 34105| 21.2k| src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1); 34106| 21.2k| const uint8_t* src2_major = 34107| 21.2k| src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2); 34108| | 34109| 21.2k| uint32_t x = x_min_incl; 34110| 42.5k| while (x < x_max_excl) { ------------------ | Branch (34110:12): [True: 21.2k, False: 21.2k] ------------------ 34111| 21.2k| uint32_t end = x + 672u; 34112| 21.2k| if (end > x_max_excl) { ------------------ | Branch (34112:11): [True: 21.2k, False: 0] ------------------ 34113| 21.2k| end = x_max_excl; 34114| 21.2k| } 34115| | 34116| 21.2k| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 34117| 21.2k| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 34118| 21.2k| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 34119| | 34120| 21.2k| const uint8_t* up0 = (*upfunc0)( // 34121| 21.2k| scratch_buffer_2k_ptr + (0u * 672u), // 34122| 21.2k| src0_major + ((x - x_min_incl) / inv_h0), // 34123| 21.2k| src0_major + ((x - x_min_incl) / inv_h0), // 34124| 21.2k| src_len0, // 34125| 21.2k| 0u, false, false); 34126| | 34127| 21.2k| const uint8_t* up1 = (*upfunc1)( // 34128| 21.2k| scratch_buffer_2k_ptr + (1u * 672u), // 34129| 21.2k| src1_major + ((x - x_min_incl) / inv_h1), // 34130| 21.2k| src1_major + ((x - x_min_incl) / inv_h1), // 34131| 21.2k| src_len1, // 34132| 21.2k| 0u, false, false); 34133| | 34134| 21.2k| const uint8_t* up2 = (*upfunc2)( // 34135| 21.2k| scratch_buffer_2k_ptr + (2u * 672u), // 34136| 21.2k| src2_major + ((x - x_min_incl) / inv_h2), // 34137| 21.2k| src2_major + ((x - x_min_incl) / inv_h2), // 34138| 21.2k| src_len2, // 34139| 21.2k| 0u, false, false); 34140| | 34141| 21.2k| (*conv3func)(dst, x, end, y, up0, up1, up2); 34142| 21.2k| x = end; 34143| 21.2k| } 34144| 21.2k| } 34145| 1.26k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box: 33309| 51.1k| bool last_column_ignored) { 33310| 51.1k| return src_ptr_major; 33311| 51.1k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box: 33321| 4.83k| bool last_column_ignored) { 33322| 4.83k| uint8_t* dp = dst_ptr; 33323| 4.83k| const uint8_t* sp = src_ptr_major; 33324| 54.0k| while (src_len--) { ------------------ | Branch (33324:10): [True: 49.2k, False: 4.83k] ------------------ 33325| 49.2k| uint8_t sv = *sp++; 33326| 49.2k| *dp++ = sv; 33327| 49.2k| *dp++ = sv; 33328| 49.2k| } 33329| 4.83k| return dst_ptr; 33330| 4.83k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box: 33340| 10.2k| bool last_column_ignored) { 33341| 10.2k| uint8_t* dp = dst_ptr; 33342| 10.2k| const uint8_t* sp = src_ptr_major; 33343| 95.2k| while (src_len--) { ------------------ | Branch (33343:10): [True: 84.9k, False: 10.2k] ------------------ 33344| 84.9k| uint8_t sv = *sp++; 33345| 84.9k| *dp++ = sv; 33346| 84.9k| *dp++ = sv; 33347| 84.9k| *dp++ = sv; 33348| 84.9k| } 33349| 10.2k| return dst_ptr; 33350| 10.2k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box: 33360| 9.30k| bool last_column_ignored) { 33361| 9.30k| uint8_t* dp = dst_ptr; 33362| 9.30k| const uint8_t* sp = src_ptr_major; 33363| 74.2k| while (src_len--) { ------------------ | Branch (33363:10): [True: 64.9k, False: 9.30k] ------------------ 33364| 64.9k| uint8_t sv = *sp++; 33365| 64.9k| *dp++ = sv; 33366| 64.9k| *dp++ = sv; 33367| 64.9k| *dp++ = sv; 33368| 64.9k| *dp++ = sv; 33369| 64.9k| } 33370| 9.30k| return dst_ptr; 33371| 9.30k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_has_triangle_upsampler: 33575| 2.43k| uint32_t inv_v) { 33576| 2.43k| if (inv_h == 1u) { ------------------ | Branch (33576:7): [True: 1.15k, False: 1.28k] ------------------ 33577| 1.15k| return inv_v == 2u; 33578| 1.28k| } else if (inv_h == 2u) { ------------------ | Branch (33578:14): [True: 261, False: 1.02k] ------------------ 33579| 261| return (inv_v == 1u) || (inv_v == 2u); ------------------ | Branch (33579:12): [True: 152, False: 109] | Branch (33579:29): [True: 54, False: 55] ------------------ 33580| 261| } 33581| 1.02k| return false; 33582| 2.43k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter: 33955| 370| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 33956| 370| if ((x_min_incl != 0) || (y_min_incl != 0)) { ------------------ | Branch (33956:7): [True: 0, False: 370] | Branch (33956:28): [True: 0, False: 370] ------------------ 33957| 0| return; 33958| 0| } 33959| | 33960| 370| wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = 33961| 370| (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; 33962| 370| wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = 33963| 370| (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u]; 33964| 370| wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 = 33965| 370| (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; 33966| | 33967| | // First row. 33968| 370| uint32_t h1v2_bias = 1u; 33969| 370| wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( 33970| 370| dst, x_max_excl, 0u, // 33971| 370| src_ptr0, src_ptr1, src_ptr2, // 33972| 370| stride0, stride1, stride2, // 33973| 370| inv_h0, inv_h1, inv_h2, // 33974| 370| inv_v0, inv_v1, inv_v2, // 33975| 370| half_width_for_2to1, // 33976| 370| h1v2_bias, // 33977| 370| scratch_buffer_2k_ptr, // 33978| 370| upfunc0, upfunc1, upfunc2, conv3func); 33979| 370| h1v2_bias = 2u; 33980| | 33981| | // Middle rows. 33982| 370| bool last_row = y_max_excl == 2u * half_height_for_2to1; 33983| 370| uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl; ------------------ | Branch (33983:32): [True: 238, False: 132] ------------------ 33984| 370| uint32_t y; 33985| 7.96k| for (y = 1u; y < middle_y_max_excl; y++) { ------------------ | Branch (33985:16): [True: 7.59k, False: 370] ------------------ 33986| 7.59k| const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); 33987| 7.59k| const uint8_t* src0_minor = 33988| 7.59k| (inv_v0 != 2u) ------------------ | Branch (33988:9): [True: 4.64k, False: 2.95k] ------------------ 33989| 7.59k| ? src0_major 33990| 7.59k| : ((y & 1u) ? (src0_major + stride0) : (src0_major - stride0)); ------------------ | Branch (33990:16): [True: 1.47k, False: 1.47k] ------------------ 33991| 7.59k| const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); 33992| 7.59k| const uint8_t* src1_minor = 33993| 7.59k| (inv_v1 != 2u) ------------------ | Branch (33993:9): [True: 3.87k, False: 3.72k] ------------------ 33994| 7.59k| ? src1_major 33995| 7.59k| : ((y & 1u) ? (src1_major + stride1) : (src1_major - stride1)); ------------------ | Branch (33995:16): [True: 1.86k, False: 1.86k] ------------------ 33996| 7.59k| const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); 33997| 7.59k| const uint8_t* src2_minor = 33998| 7.59k| (inv_v2 != 2u) ------------------ | Branch (33998:9): [True: 5.71k, False: 1.88k] ------------------ 33999| 7.59k| ? src2_major 34000| 7.59k| : ((y & 1u) ? (src2_major + stride2) : (src2_major - stride2)); ------------------ | Branch (34000:16): [True: 943, False: 943] ------------------ 34001| 7.59k| uint32_t total_src_len0 = 0u; 34002| 7.59k| uint32_t total_src_len1 = 0u; 34003| 7.59k| uint32_t total_src_len2 = 0u; 34004| | 34005| 7.59k| uint32_t x = 0u; 34006| 15.1k| while (x < x_max_excl) { ------------------ | Branch (34006:12): [True: 7.59k, False: 7.59k] ------------------ 34007| 7.59k| bool first_column = x == 0u; 34008| 7.59k| uint32_t end = x + 672u; 34009| 7.59k| if (end > x_max_excl) { ------------------ | Branch (34009:11): [True: 7.59k, False: 0] ------------------ 34010| 7.59k| end = x_max_excl; 34011| 7.59k| } 34012| | 34013| 7.59k| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 34014| 7.59k| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 34015| 7.59k| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 34016| 7.59k| total_src_len0 += src_len0; 34017| 7.59k| total_src_len1 += src_len1; 34018| 7.59k| total_src_len2 += src_len2; 34019| | 34020| 7.59k| const uint8_t* up0 = (*upfunc0)( // 34021| 7.59k| scratch_buffer_2k_ptr + (0u * 672u), // 34022| 7.59k| src0_major + (x / inv_h0), // 34023| 7.59k| src0_minor + (x / inv_h0), // 34024| 7.59k| src_len0, // 34025| 7.59k| h1v2_bias, // 34026| 7.59k| first_column, // 34027| 7.59k| (total_src_len0 >= half_width_for_2to1)); 34028| | 34029| 7.59k| const uint8_t* up1 = (*upfunc1)( // 34030| 7.59k| scratch_buffer_2k_ptr + (1u * 672u), // 34031| 7.59k| src1_major + (x / inv_h1), // 34032| 7.59k| src1_minor + (x / inv_h1), // 34033| 7.59k| src_len1, // 34034| 7.59k| h1v2_bias, // 34035| 7.59k| first_column, // 34036| 7.59k| (total_src_len1 >= half_width_for_2to1)); 34037| | 34038| 7.59k| const uint8_t* up2 = (*upfunc2)( // 34039| 7.59k| scratch_buffer_2k_ptr + (2u * 672u), // 34040| 7.59k| src2_major + (x / inv_h2), // 34041| 7.59k| src2_minor + (x / inv_h2), // 34042| 7.59k| src_len2, // 34043| 7.59k| h1v2_bias, // 34044| 7.59k| first_column, // 34045| 7.59k| (total_src_len2 >= half_width_for_2to1)); 34046| | 34047| 7.59k| (*conv3func)(dst, x, end, y, up0, up1, up2); 34048| 7.59k| x = end; 34049| 7.59k| } 34050| | 34051| 7.59k| h1v2_bias ^= 3u; 34052| 7.59k| } 34053| | 34054| | // Last row. 34055| 370| if (middle_y_max_excl != y_max_excl) { ------------------ | Branch (34055:7): [True: 238, False: 132] ------------------ 34056| 238| wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( 34057| 238| dst, x_max_excl, middle_y_max_excl, // 34058| 238| src_ptr0, src_ptr1, src_ptr2, // 34059| 238| stride0, stride1, stride2, // 34060| 238| inv_h0, inv_h1, inv_h2, // 34061| 238| inv_v0, inv_v1, inv_v2, // 34062| 238| half_width_for_2to1, // 34063| 238| h1v2_bias, // 34064| 238| scratch_buffer_2k_ptr, // 34065| 238| upfunc0, upfunc1, upfunc2, conv3func); 34066| 238| } 34067| 370|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row: 33874| 608| wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { 33875| 608| const uint8_t* src0 = src_ptr0 + ((y / inv_v0) * (size_t)stride0); 33876| 608| const uint8_t* src1 = src_ptr1 + ((y / inv_v1) * (size_t)stride1); 33877| 608| const uint8_t* src2 = src_ptr2 + ((y / inv_v2) * (size_t)stride2); 33878| 608| uint32_t total_src_len0 = 0u; 33879| 608| uint32_t total_src_len1 = 0u; 33880| 608| uint32_t total_src_len2 = 0u; 33881| | 33882| 608| uint32_t x = 0u; 33883| 1.21k| while (x < width) { ------------------ | Branch (33883:10): [True: 608, False: 608] ------------------ 33884| 608| bool first_column = x == 0u; 33885| 608| uint32_t end = x + 672u; 33886| 608| if (end > width) { ------------------ | Branch (33886:9): [True: 608, False: 0] ------------------ 33887| 608| end = width; 33888| 608| } 33889| | 33890| 608| uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; 33891| 608| uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; 33892| 608| uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; 33893| 608| total_src_len0 += src_len0; 33894| 608| total_src_len1 += src_len1; 33895| 608| total_src_len2 += src_len2; 33896| | 33897| 608| const uint8_t* src_ptr_x0 = src0 + (x / inv_h0); 33898| 608| const uint8_t* up0 = (*upfunc0)( // 33899| 608| scratch_buffer_2k_ptr + (0u * 672u), // 33900| 608| src_ptr_x0, // 33901| 608| src_ptr_x0, // 33902| 608| src_len0, // 33903| 608| h1v2_bias, // 33904| 608| first_column, // 33905| 608| (total_src_len0 >= half_width_for_2to1)); 33906| | 33907| 608| const uint8_t* src_ptr_x1 = src1 + (x / inv_h1); 33908| 608| const uint8_t* up1 = (*upfunc1)( // 33909| 608| scratch_buffer_2k_ptr + (1u * 672u), // 33910| 608| src_ptr_x1, // 33911| 608| src_ptr_x1, // 33912| 608| src_len1, // 33913| 608| h1v2_bias, // 33914| 608| first_column, // 33915| 608| (total_src_len1 >= half_width_for_2to1)); 33916| | 33917| 608| const uint8_t* src_ptr_x2 = src2 + (x / inv_h2); 33918| 608| const uint8_t* up2 = (*upfunc2)( // 33919| 608| scratch_buffer_2k_ptr + (2u * 672u), // 33920| 608| src_ptr_x2, // 33921| 608| src_ptr_x2, // 33922| 608| src_len2, // 33923| 608| h1v2_bias, // 33924| 608| first_column, // 33925| 608| (total_src_len2 >= half_width_for_2to1)); 33926| | 33927| 608| (*conv3func)(dst, x, end, y, up0, up1, up2); 33928| 608| x = end; 33929| 608| } 33930| 608|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle: 33381| 5.83k| bool last_column_ignored) { 33382| 5.83k| uint8_t* dp = dst_ptr; 33383| 5.83k| const uint8_t* sp_major = src_ptr_major; 33384| 5.83k| const uint8_t* sp_minor = src_ptr_minor; 33385| 173k| while (src_len--) { ------------------ | Branch (33385:10): [True: 167k, False: 5.83k] ------------------ 33386| 167k| *dp++ = (uint8_t)(((3u * ((uint32_t)(*sp_major++))) + // 33387| 167k| (1u * ((uint32_t)(*sp_minor++))) + // 33388| 167k| h1v2_bias) >> 33389| 167k| 2u); 33390| 167k| } 33391| 5.83k| return dst_ptr; 33392| 5.83k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle: 33402| 4.80k| bool last_column) { 33403| 4.80k| uint8_t* dp = dst_ptr; 33404| 4.80k| const uint8_t* sp = src_ptr_major; 33405| | 33406| 4.80k| if (first_column) { ------------------ | Branch (33406:7): [True: 4.80k, False: 0] ------------------ 33407| 4.80k| src_len--; 33408| 4.80k| if ((src_len <= 0u) && last_column) { ------------------ | Branch (33408:9): [True: 224, False: 4.58k] | Branch (33408:28): [True: 224, False: 0] ------------------ 33409| 224| uint8_t sv = *sp++; 33410| 224| *dp++ = sv; 33411| 224| *dp++ = sv; 33412| 224| return dst_ptr; 33413| 224| } 33414| 4.58k| uint32_t svp1 = sp[+1]; 33415| 4.58k| uint8_t sv = *sp++; 33416| 4.58k| *dp++ = sv; 33417| 4.58k| *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svp1 + 2u) >> 2u); 33418| 4.58k| if (src_len <= 0u) { ------------------ | Branch (33418:9): [True: 0, False: 4.58k] ------------------ 33419| 0| return dst_ptr; 33420| 0| } 33421| 4.58k| } 33422| | 33423| 4.58k| if (last_column) { ------------------ | Branch (33423:7): [True: 4.58k, False: 0] ------------------ 33424| 4.58k| src_len--; 33425| 4.58k| } 33426| | 33427| 51.6k| for (; src_len > 0u; src_len--) { ------------------ | Branch (33427:10): [True: 47.0k, False: 4.58k] ------------------ 33428| 47.0k| uint32_t svm1 = sp[-1]; 33429| 47.0k| uint32_t svp1 = sp[+1]; 33430| 47.0k| uint32_t sv3 = 3u * (uint32_t)(*sp++); 33431| 47.0k| *dp++ = (uint8_t)((sv3 + svm1 + 1u) >> 2u); 33432| 47.0k| *dp++ = (uint8_t)((sv3 + svp1 + 2u) >> 2u); 33433| 47.0k| } 33434| | 33435| 4.58k| if (last_column) { ------------------ | Branch (33435:7): [True: 4.58k, False: 0] ------------------ 33436| 4.58k| uint32_t svm1 = sp[-1]; 33437| 4.58k| uint8_t sv = *sp++; 33438| 4.58k| *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svm1 + 1u) >> 2u); 33439| 4.58k| *dp++ = sv; 33440| 4.58k| } 33441| | 33442| 4.58k| return dst_ptr; 33443| 4.80k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2: 32907| 2.13k| bool last_column) { 32908| 2.13k| return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2( 32909| 2.13k| dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored, 32910| 2.13k| first_column, last_column, 7); 32911| 2.13k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2: 35152| 2.13k| uint8_t odd_column_rounding) { 35153| 2.13k| uint8_t* dp = dst_ptr; 35154| 2.13k| const uint8_t* sp_major = src_ptr_major; 35155| 2.13k| const uint8_t* sp_minor = src_ptr_minor; 35156| 2.13k| const uint8_t oc = odd_column_rounding; 35157| | 35158| 2.13k| if (first_column) { ------------------ | Branch (35158:7): [True: 2.13k, False: 0] ------------------ 35159| 2.13k| src_len--; 35160| 2.13k| if ((src_len <= 0u) && last_column) { ------------------ | Branch (35160:9): [True: 130, False: 2.00k] | Branch (35160:28): [True: 130, False: 0] ------------------ 35161| 130| uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + // 35162| 130| (4u * ((uint32_t)(*sp_minor++))); 35163| 130| *dp++ = (uint8_t)((sv + 8u) >> 4u); 35164| 130| *dp++ = (uint8_t)((sv + oc) >> 4u); 35165| 130| return dst_ptr; 35166| 130| } 35167| | 35168| 2.00k| uint32_t sv_major_m1 = sp_major[-0]; // Clamp offset to zero. 35169| 2.00k| uint32_t sv_minor_m1 = sp_minor[-0]; // Clamp offset to zero. 35170| 2.00k| uint32_t sv_major_p1 = sp_major[+1]; 35171| 2.00k| uint32_t sv_minor_p1 = sp_minor[+1]; 35172| | 35173| 2.00k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 35174| 2.00k| (3u * ((uint32_t)(*sp_minor++))); 35175| 2.00k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 35176| 2.00k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u); 35177| 2.00k| if (src_len <= 0u) { ------------------ | Branch (35177:9): [True: 0, False: 2.00k] ------------------ 35178| 0| return dst_ptr; 35179| 0| } 35180| 2.00k| } 35181| | 35182| 2.00k| if (last_column) { ------------------ | Branch (35182:7): [True: 2.00k, False: 0] ------------------ 35183| 2.00k| src_len--; 35184| 2.00k| } 35185| | 35186| 2.00k| if (src_len < 32) { ------------------ | Branch (35186:7): [True: 2.00k, False: 0] ------------------ 35187| | // This fallback is the same as the non-SIMD-capable code path. 35188| 27.5k| for (; src_len > 0u; src_len--) { ------------------ | Branch (35188:12): [True: 25.5k, False: 2.00k] ------------------ 35189| 25.5k| uint32_t sv_major_m1 = sp_major[-1]; 35190| 25.5k| uint32_t sv_minor_m1 = sp_minor[-1]; 35191| 25.5k| uint32_t sv_major_p1 = sp_major[+1]; 35192| 25.5k| uint32_t sv_minor_p1 = sp_minor[+1]; 35193| | 35194| 25.5k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 35195| 25.5k| (3u * ((uint32_t)(*sp_minor++))); 35196| 25.5k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 35197| 25.5k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u); 35198| 25.5k| } 35199| | 35200| 2.00k| } 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.00k| if (last_column) { ------------------ | Branch (35329:7): [True: 2.00k, False: 0] ------------------ 35330| 2.00k| uint32_t sv_major_m1 = sp_major[-1]; 35331| 2.00k| uint32_t sv_minor_m1 = sp_minor[-1]; 35332| 2.00k| uint32_t sv_major_p1 = sp_major[+0]; // Clamp offset to zero. 35333| 2.00k| uint32_t sv_minor_p1 = sp_minor[+0]; // Clamp offset to zero. 35334| | 35335| 2.00k| uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + // 35336| 2.00k| (3u * ((uint32_t)(*sp_minor++))); 35337| 2.00k| *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u); 35338| 2.00k| *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u); 35339| 2.00k| } 35340| | 35341| 2.00k| return dst_ptr; 35342| 2.13k|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx_x86_avx2: 34727| 4.73k| const uint8_t* up2) { 34728| 4.73k| if ((x + 32u) > x_end) { ------------------ | Branch (34728:7): [True: 4.37k, False: 364] ------------------ 34729| 4.37k| wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx( // 34730| 4.37k| dst, x, x_end, y, up0, up1, up2); 34731| 4.37k| return; 34732| 4.37k| } 34733| | 34734| 364| size_t dst_stride = dst->private_impl.planes[0].stride; 34735| 364| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 34736| 364| (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| 364| const __m256i u0001 = _mm256_set1_epi16(+0x0001); 34743| 364| const __m256i u00FF = _mm256_set1_epi16(+0x00FF); 34744| 364| const __m256i uFF80 = _mm256_set1_epi16(-0x0080); 34745| 364| const __m256i uFFFF = _mm256_set1_epi16(-0x0001); 34746| | 34747| | // p8000_p0000 = u16x16 [0x8000 0x0000 .. 0x8000 0x0000] 34748| 364| const __m256i p8000_p0000 = _mm256_set_epi16( // 34749| 364| +0x0000, -0x8000, +0x0000, -0x8000, // 34750| 364| +0x0000, -0x8000, +0x0000, -0x8000, // 34751| 364| +0x0000, -0x8000, +0x0000, -0x8000, // 34752| 364| +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| 364| const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E); 34776| 364| const __m256i p66E9 = _mm256_set1_epi16(+0x66E9); 34777| 364| const __m256i m581A_p492E = _mm256_set_epi16( // 34778| 364| +0x492E, -0x581A, +0x492E, -0x581A, // 34779| 364| +0x492E, -0x581A, +0x492E, -0x581A, // 34780| 364| +0x492E, -0x581A, +0x492E, -0x581A, // 34781| 364| +0x492E, -0x581A, +0x492E, -0x581A); 34782| | 34783| 1.00k| while (x < x_end) { ------------------ | Branch (34783:10): [True: 640, False: 364] ------------------ 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| 640| __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1); 34793| 640| __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2); 34794| 640| __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF)); 34795| 640| __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF)); 34796| 640| __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8)); 34797| 640| __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| 640| __m256i tmp_by_eve = _mm256_srai_epi16( 34816| 640| _mm256_add_epi16( 34817| 640| _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001), 34818| 640| 1); 34819| 640| __m256i tmp_by_odd = _mm256_srai_epi16( 34820| 640| _mm256_add_epi16( 34821| 640| _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001), 34822| 640| 1); 34823| 640| __m256i tmp_ry_eve = _mm256_srai_epi16( 34824| 640| _mm256_add_epi16( 34825| 640| _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001), 34826| 640| 1); 34827| 640| __m256i tmp_ry_odd = _mm256_srai_epi16( 34828| 640| _mm256_add_epi16( 34829| 640| _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001), 34830| 640| 1); 34831| | 34832| | // Add (2 * Cb) and (1 * Cr). 34833| 640| __m256i by_eve = 34834| 640| _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve)); 34835| 640| __m256i by_odd = 34836| 640| _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd)); 34837| 640| __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve); 34838| 640| __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| 640| __m256i tmp0_gy_eve_lo = _mm256_madd_epi16( // 34855| 640| _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E); 34856| 640| __m256i tmp0_gy_eve_hi = _mm256_madd_epi16( // 34857| 640| _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E); 34858| 640| __m256i tmp0_gy_odd_lo = _mm256_madd_epi16( // 34859| 640| _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E); 34860| 640| __m256i tmp0_gy_odd_hi = _mm256_madd_epi16( // 34861| 640| _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E); 34862| | 34863| | // Divide the i32x8 vectors by (1 << 16), rounding to nearest. 34864| 640| __m256i tmp1_gy_eve_lo = 34865| 640| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16); 34866| 640| __m256i tmp1_gy_eve_hi = 34867| 640| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16); 34868| 640| __m256i tmp1_gy_odd_lo = 34869| 640| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16); 34870| 640| __m256i tmp1_gy_odd_hi = 34871| 640| _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| 640| __m256i gy_eve = _mm256_sub_epi16( 34875| 640| _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve); 34876| 640| __m256i gy_odd = _mm256_sub_epi16( 34877| 640| _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| 640| __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0); 34897| 640| __m256i yy_eve = _mm256_and_si256(yy_all, u00FF); 34898| 640| __m256i yy_odd = _mm256_srli_epi16(yy_all, 8); 34899| | 34900| 640| __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve); 34901| 640| __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd); 34902| 640| __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve); 34903| 640| __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd); 34904| | 34905| 640| __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve); 34906| 640| __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd); 34907| 640| __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve); 34908| 640| __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd); 34909| | 34910| 640| __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve); 34911| 640| __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd); 34912| 640| __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve); 34913| 640| __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| 640| __m256i mix00 = _mm256_unpacklo_epi8(packed_b_eve, packed_g_eve); 34929| 640| __m256i mix01 = _mm256_unpacklo_epi8(packed_b_odd, packed_g_odd); 34930| 640| __m256i mix02 = _mm256_unpacklo_epi8(packed_r_eve, uFFFF); 34931| 640| __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| 640| __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02); 34942| 640| __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03); 34943| 640| __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02); 34944| 640| __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| 640| __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11); 34955| 640| __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11); 34956| 640| __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13); 34957| 640| __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| 640| __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20); 34968| 640| __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20); 34969| 640| __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31); 34970| 640| __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31); 34971| | 34972| | // Write out four u8x32 SIMD registers (128 bytes, 32 BGRX/RGBX pixels). 34973| 640| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30); 34974| 640| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31); 34975| 640| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32); 34976| 640| _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| 640| uint32_t n = 32u - (31u & (x - x_end)); 34981| 640| dst_iter += 4u * n; 34982| 640| up0 += n; 34983| 640| up1 += n; 34984| 640| up2 += n; 34985| 640| x += n; 34986| 640| } 34987| 364|} pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx_x86_avx2: 35000| 4.59k| const uint8_t* up2) { 35001| 4.59k| if ((x + 32u) > x_end) { ------------------ | Branch (35001:7): [True: 3.95k, False: 642] ------------------ 35002| 3.95k| wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx( // 35003| 3.95k| dst, x, x_end, y, up0, up1, up2); 35004| 3.95k| return; 35005| 3.95k| } 35006| | 35007| 642| size_t dst_stride = dst->private_impl.planes[0].stride; 35008| 642| uint8_t* dst_iter = dst->private_impl.planes[0].ptr + 35009| 642| (dst_stride * ((size_t)y)) + (4u * ((size_t)x)); 35010| | 35011| 642| const __m256i u0001 = _mm256_set1_epi16(+0x0001); 35012| 642| const __m256i u00FF = _mm256_set1_epi16(+0x00FF); 35013| 642| const __m256i uFF80 = _mm256_set1_epi16(-0x0080); 35014| 642| const __m256i uFFFF = _mm256_set1_epi16(-0x0001); 35015| | 35016| 642| const __m256i p8000_p0000 = _mm256_set_epi16( // 35017| 642| +0x0000, -0x8000, +0x0000, -0x8000, // 35018| 642| +0x0000, -0x8000, +0x0000, -0x8000, // 35019| 642| +0x0000, -0x8000, +0x0000, -0x8000, // 35020| 642| +0x0000, -0x8000, +0x0000, -0x8000); 35021| | 35022| 642| const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E); 35023| 642| const __m256i p66E9 = _mm256_set1_epi16(+0x66E9); 35024| 642| const __m256i m581A_p492E = _mm256_set_epi16( // 35025| 642| +0x492E, -0x581A, +0x492E, -0x581A, // 35026| 642| +0x492E, -0x581A, +0x492E, -0x581A, // 35027| 642| +0x492E, -0x581A, +0x492E, -0x581A, // 35028| 642| +0x492E, -0x581A, +0x492E, -0x581A); 35029| | 35030| 1.81k| while (x < x_end) { ------------------ | Branch (35030:10): [True: 1.17k, False: 642] ------------------ 35031| 1.17k| __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1); 35032| 1.17k| __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2); 35033| 1.17k| __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF)); 35034| 1.17k| __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF)); 35035| 1.17k| __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8)); 35036| 1.17k| __m256i cr_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cr_all, 8)); 35037| | 35038| 1.17k| __m256i tmp_by_eve = _mm256_srai_epi16( 35039| 1.17k| _mm256_add_epi16( 35040| 1.17k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001), 35041| 1.17k| 1); 35042| 1.17k| __m256i tmp_by_odd = _mm256_srai_epi16( 35043| 1.17k| _mm256_add_epi16( 35044| 1.17k| _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001), 35045| 1.17k| 1); 35046| 1.17k| __m256i tmp_ry_eve = _mm256_srai_epi16( 35047| 1.17k| _mm256_add_epi16( 35048| 1.17k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001), 35049| 1.17k| 1); 35050| 1.17k| __m256i tmp_ry_odd = _mm256_srai_epi16( 35051| 1.17k| _mm256_add_epi16( 35052| 1.17k| _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001), 35053| 1.17k| 1); 35054| | 35055| 1.17k| __m256i by_eve = 35056| 1.17k| _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve)); 35057| 1.17k| __m256i by_odd = 35058| 1.17k| _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd)); 35059| 1.17k| __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve); 35060| 1.17k| __m256i ry_odd = _mm256_add_epi16(tmp_ry_odd, cr_odd); 35061| | 35062| 1.17k| __m256i tmp0_gy_eve_lo = _mm256_madd_epi16( // 35063| 1.17k| _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E); 35064| 1.17k| __m256i tmp0_gy_eve_hi = _mm256_madd_epi16( // 35065| 1.17k| _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E); 35066| 1.17k| __m256i tmp0_gy_odd_lo = _mm256_madd_epi16( // 35067| 1.17k| _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E); 35068| 1.17k| __m256i tmp0_gy_odd_hi = _mm256_madd_epi16( // 35069| 1.17k| _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E); 35070| | 35071| 1.17k| __m256i tmp1_gy_eve_lo = 35072| 1.17k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16); 35073| 1.17k| __m256i tmp1_gy_eve_hi = 35074| 1.17k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16); 35075| 1.17k| __m256i tmp1_gy_odd_lo = 35076| 1.17k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16); 35077| 1.17k| __m256i tmp1_gy_odd_hi = 35078| 1.17k| _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_hi, p8000_p0000), 16); 35079| | 35080| 1.17k| __m256i gy_eve = _mm256_sub_epi16( 35081| 1.17k| _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve); 35082| 1.17k| __m256i gy_odd = _mm256_sub_epi16( 35083| 1.17k| _mm256_packs_epi32(tmp1_gy_odd_lo, tmp1_gy_odd_hi), cr_odd); 35084| | 35085| 1.17k| __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0); 35086| 1.17k| __m256i yy_eve = _mm256_and_si256(yy_all, u00FF); 35087| 1.17k| __m256i yy_odd = _mm256_srli_epi16(yy_all, 8); 35088| | 35089| 1.17k| __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve); 35090| 1.17k| __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd); 35091| 1.17k| __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve); 35092| 1.17k| __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd); 35093| | 35094| 1.17k| __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve); 35095| 1.17k| __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd); 35096| 1.17k| __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve); 35097| 1.17k| __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd); 35098| | 35099| 1.17k| __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve); 35100| 1.17k| __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd); 35101| 1.17k| __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve); 35102| 1.17k| __m256i packed_r_odd = _mm256_packus_epi16(loose_r_odd, loose_r_odd); 35103| | 35104| | // § Note the swapped B and R channels. 35105| 1.17k| __m256i mix00 = _mm256_unpacklo_epi8(packed_r_eve, packed_g_eve); 35106| 1.17k| __m256i mix01 = _mm256_unpacklo_epi8(packed_r_odd, packed_g_odd); 35107| 1.17k| __m256i mix02 = _mm256_unpacklo_epi8(packed_b_eve, uFFFF); 35108| 1.17k| __m256i mix03 = _mm256_unpacklo_epi8(packed_b_odd, uFFFF); 35109| | 35110| 1.17k| __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02); 35111| 1.17k| __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03); 35112| 1.17k| __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02); 35113| 1.17k| __m256i mix13 = _mm256_unpackhi_epi16(mix01, mix03); 35114| | 35115| 1.17k| __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11); 35116| 1.17k| __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11); 35117| 1.17k| __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13); 35118| 1.17k| __m256i mix23 = _mm256_unpackhi_epi32(mix12, mix13); 35119| | 35120| 1.17k| __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20); 35121| 1.17k| __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20); 35122| 1.17k| __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31); 35123| 1.17k| __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31); 35124| | 35125| 1.17k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30); 35126| 1.17k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31); 35127| 1.17k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32); 35128| 1.17k| _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x60), mix33); 35129| | 35130| 1.17k| uint32_t n = 32u - (31u & (x - x_end)); 35131| 1.17k| dst_iter += 4u * n; 35132| 1.17k| up0 += n; 35133| 1.17k| up1 += n; 35134| 1.17k| up2 += n; 35135| 1.17k| x += n; 35136| 1.17k| } 35137| 642|} pixel_swizzler_fuzzer.c:wuffs_base__ptr_u8__reader: 3456| 3.39k|wuffs_base__ptr_u8__reader(uint8_t* ptr, size_t len, bool closed) { 3457| 3.39k| wuffs_base__io_buffer ret; 3458| 3.39k| ret.data.ptr = ptr; 3459| 3.39k| ret.data.len = len; 3460| 3.39k| ret.meta.wi = len; 3461| 3.39k| ret.meta.ri = 0; 3462| 3.39k| ret.meta.pos = 0; 3463| 3.39k| ret.meta.closed = closed; 3464| 3.39k| return ret; 3465| 3.39k|} 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.01k|wuffs_base__status__message(const wuffs_base__status* z) { 675| 2.01k| if (z->repr) { ------------------ | Branch (675:7): [True: 2.01k, False: 0] ------------------ 676| 2.01k| if ((*z->repr == '$') || (*z->repr == '#') || (*z->repr == '@')) { ------------------ | Branch (676:9): [True: 0, False: 2.01k] | Branch (676:30): [True: 2.01k, False: 0] | Branch (676:51): [True: 0, False: 0] ------------------ 677| 2.01k| return z->repr + 1; 678| 2.01k| } 679| 2.01k| } 680| 0| return z->repr; 681| 2.01k|} pixel_swizzler_fuzzer.c:wuffs_base__u32__max: 1062| 40.7k|wuffs_base__u32__max(uint32_t x, uint32_t y) { 1063| 40.7k| return x > y ? x : y; ------------------ | Branch (1063:10): [True: 16.2k, False: 24.5k] ------------------ 1064| 40.7k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__set: 5307| 3.39k| uint32_t height) { 5308| 3.39k| if (!c) { ------------------ | Branch (5308:7): [True: 0, False: 3.39k] ------------------ 5309| 0| return; 5310| 0| } 5311| 3.39k| if (pixfmt_repr) { ------------------ | Branch (5311:7): [True: 3.39k, False: 0] ------------------ 5312| 3.39k| 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.39k| c->private_impl.pixfmt.repr = pixfmt_repr; 5321| 3.39k| c->private_impl.pixsub.repr = pixsub_repr; 5322| 3.39k| c->private_impl.width = width; 5323| 3.39k| c->private_impl.height = height; 5324| 3.39k| return; 5325| 3.39k| } while (0); ------------------ | Branch (5325:14): [Folded, False: 0] ------------------ 5326| 3.39k| } 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.39k|wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { 5393| 3.39k| if (!c) { ------------------ | Branch (5393:7): [True: 0, False: 3.39k] ------------------ 5394| 0| return 0; 5395| 0| } 5396| 3.39k| if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) { ------------------ | Branch (5396:7): [True: 0, False: 3.39k] ------------------ 5397| | // TODO: support planar pixel formats, concious of pixel subsampling. 5398| 0| return 0; 5399| 0| } 5400| 3.39k| uint32_t bits_per_pixel = 5401| 3.39k| wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt); 5402| 3.39k| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { ------------------ | Branch (5402:7): [True: 0, False: 3.39k] | Branch (5402:32): [True: 0, False: 3.39k] ------------------ 5403| | // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? 5404| 0| return 0; 5405| 0| } 5406| 3.39k| uint64_t bytes_per_pixel = bits_per_pixel / 8; 5407| | 5408| 3.39k| uint64_t n = 5409| 3.39k| ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); 5410| 3.39k| if (n > (UINT64_MAX / bytes_per_pixel)) { ------------------ | Branch (5410:7): [True: 0, False: 3.39k] ------------------ 5411| 0| return 0; 5412| 0| } 5413| 3.39k| n *= bytes_per_pixel; 5414| | 5415| 3.39k| if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) { ------------------ | Branch (5415:7): [True: 126, False: 3.27k] ------------------ 5416| 126| if (n > ------------------ | Branch (5416:9): [True: 0, False: 126] ------------------ 5417| 126| (UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) { ------------------ | | 4900| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5418| 0| return 0; 5419| 0| } 5420| 126| n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 5421| 126| } 5422| | 5423| 3.39k| return n; 5424| 3.39k|} pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__set_from_slice: 5978| 3.39k| wuffs_base__slice_u8 pixbuf_memory) { 5979| 3.39k| if (!pb) { ------------------ | Branch (5979:7): [True: 0, False: 3.39k] ------------------ 5980| 0| return wuffs_base__make_status(wuffs_base__error__bad_receiver); 5981| 0| } 5982| 3.39k| memset(pb, 0, sizeof(*pb)); 5983| 3.39k| if (!pixcfg) { ------------------ | Branch (5983:7): [True: 0, False: 3.39k] ------------------ 5984| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 5985| 0| } 5986| 3.39k| if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { ------------------ | Branch (5986:7): [True: 0, False: 3.39k] ------------------ 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.39k| uint32_t bits_per_pixel = 5991| 3.39k| wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); 5992| 3.39k| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { ------------------ | Branch (5992:7): [True: 0, False: 3.39k] | Branch (5992:32): [True: 0, False: 3.39k] ------------------ 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.39k| uint64_t bytes_per_pixel = bits_per_pixel / 8; 5997| | 5998| 3.39k| uint8_t* ptr = pixbuf_memory.ptr; 5999| 3.39k| uint64_t len = pixbuf_memory.len; 6000| 3.39k| if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) { ------------------ | Branch (6000:7): [True: 126, False: 3.27k] ------------------ 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| 126| if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { ------------------ | | 4900| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ | Branch (6006:9): [True: 0, False: 126] ------------------ 6007| 0| return wuffs_base__make_status( 6008| 0| wuffs_base__error__bad_argument_length_too_short); 6009| 0| } 6010| 126| wuffs_base__table_u8* tab = 6011| 126| &pb->private_impl 6012| 126| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; ------------------ | | 4897| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3 ------------------ 6013| 126| tab->ptr = ptr; 6014| 126| tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6015| 126| tab->height = 1; 6016| 126| tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6017| 126| ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6018| 126| len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; ------------------ | | 4900| 126|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 ------------------ 6019| 126| } 6020| | 6021| 3.39k| uint64_t wh = ((uint64_t)pixcfg->private_impl.width) * 6022| 3.39k| ((uint64_t)pixcfg->private_impl.height); 6023| 3.39k| size_t width = (size_t)(pixcfg->private_impl.width); 6024| 3.39k| if ((wh > (UINT64_MAX / bytes_per_pixel)) || ------------------ | Branch (6024:7): [True: 0, False: 3.39k] ------------------ 6025| 3.39k| (width > (SIZE_MAX / bytes_per_pixel))) { ------------------ | Branch (6025:7): [True: 0, False: 3.39k] ------------------ 6026| 0| return wuffs_base__make_status(wuffs_base__error__bad_argument); 6027| 0| } 6028| 3.39k| wh *= bytes_per_pixel; 6029| 3.39k| width = ((size_t)(width * bytes_per_pixel)); 6030| 3.39k| if (wh > len) { ------------------ | Branch (6030:7): [True: 0, False: 3.39k] ------------------ 6031| 0| return wuffs_base__make_status( 6032| 0| wuffs_base__error__bad_argument_length_too_short); 6033| 0| } 6034| | 6035| 3.39k| pb->pixcfg = *pixcfg; 6036| 3.39k| wuffs_base__table_u8* tab = &pb->private_impl.planes[0]; 6037| 3.39k| tab->ptr = ptr; 6038| 3.39k| tab->width = width; 6039| 3.39k| tab->height = pixcfg->private_impl.height; 6040| 3.39k| tab->stride = width; 6041| | return wuffs_base__make_status(NULL); 6042| 3.39k|} pixel_swizzler_fuzzer.c:wuffs_base__empty_slice_u8: 1785| 3.39k|wuffs_base__empty_slice_u8(void) { 1786| 3.39k| wuffs_base__slice_u8 ret; 1787| | ret.ptr = NULL; 1788| 3.39k| ret.len = 0; 1789| 3.39k| return ret; 1790| 3.39k|}