LLVMFuzzerTestOneInput: 11| 16|{ 12| 16| GFWX::Header header; 13| | 14| 16| { 15| 16| ptrdiff_t result = GFWX::decompress((uint8_t*)0, header, data, size, 0, true); 16| 16| if (result != GFWX::ResultOk) { ------------------ | Branch (16:13): [True: 4, False: 12] ------------------ 17| 4| return 0; 18| 4| } 19| 16| } 20| | 21| 12| if ( header.bitDepth > 32 ) { ------------------ | Branch (21:10): [True: 0, False: 12] ------------------ 22| 0| return 0; 23| 0| } 24| 12| if ( header.channels > 10 ) { ------------------ | Branch (24:10): [True: 0, False: 12] ------------------ 25| 0| return 0; 26| 0| } 27| 12| if ( header.layers > 10 ) { ------------------ | Branch (27:10): [True: 0, False: 12] ------------------ 28| 0| return 0; 29| 0| } 30| 12| if ( header.sizex > 10240 ) { ------------------ | Branch (30:10): [True: 0, False: 12] ------------------ 31| 0| return 0; 32| 0| } 33| 12| if ( header.sizey > 10240 ) { ------------------ | Branch (33:10): [True: 0, False: 12] ------------------ 34| 0| return 0; 35| 0| } 36| | 37| 12| { 38| 12| const size_t totalOutSize = (header.bitDepth / 8) * header.channels * header.layers * header.sizex * header.sizey; 39| 12| if ( totalOutSize > (1024*1024) ) { ------------------ | Branch (39:14): [True: 0, False: 12] ------------------ 40| 0| return 0; 41| 0| } 42| 12| std::vector out(totalOutSize); 43| 12| ptrdiff_t result = GFWX::decompress(out.data(), header, data, size, 0, false); 44| 12| if (result != GFWX::ResultOk) { ------------------ | Branch (44:13): [True: 11, False: 1] ------------------ 45| 11| return 0; 46| 11| } 47| 1| fuzzing::memory::memory_test(out); 48| 1| } 49| | 50| 0| return 0; 51| 12|} _ZN7fuzzing6memory11memory_testINSt3__16vectorIhNS2_9allocatorIhEEEEEEvRKT_: 53| 1|{ 54| 1| (void)t; 55| 1|} _ZN4GFWX6HeaderC2Ev: 80| 16| Header() {} _ZN4GFWX10decompressIPhEElRKT_RNS_6HeaderEPKhmib: 807| 28| { 808| 28| typedef typename std::remove_reference::type base; 809| 28| typedef typename std::conditional::type aux; 810| 28| Bits stream(reinterpret_cast(const_cast(data)), reinterpret_cast(const_cast(data)) + size / 4); 811| 28| if (size < 28) // at least load the header ------------------ | Branch (811:7): [True: 0, False: 28] ------------------ 812| 0| return 28; 813| 28| if (stream.getBits(32) != uint32_t('G' | ('F' << 8) | ('W' << 16) | ('X' << 24))) ------------------ | Branch (813:7): [True: 3, False: 25] ------------------ 814| 3| return ErrorMalformed; 815| 25| header.version = stream.getBits(32); 816| 25| header.sizex = stream.getBits(32); 817| 25| header.sizey = stream.getBits(32); 818| 25| header.layers = stream.getBits(16) + 1; 819| 25| header.channels = stream.getBits(16) + 1; 820| 25| header.bitDepth = stream.getBits(8) + 1; 821| 25| header.isSigned = stream.getBits(1); 822| 25| header.quality = stream.getBits(10) + 1; 823| 25| header.chromaScale = stream.getBits(8) + 1; 824| 25| header.blockSize = stream.getBits(5) + 2; 825| 25| header.filter = stream.getBits(8); 826| 25| header.quantization = stream.getBits(8); 827| 25| header.encoder = stream.getBits(8); 828| 25| header.intent = stream.getBits(8); 829| 25| if (header.sizex < 0 || header.sizex > (1 << 30) || header.sizey < 0 || header.sizey > (1 << 30) || header.bufferSize() == 0) ------------------ | Branch (829:9): [True: 0, False: 25] | Branch (829:29): [True: 0, False: 25] | Branch (829:57): [True: 0, False: 25] | Branch (829:77): [True: 0, False: 25] | Branch (829:105): [True: 1, False: 24] ------------------ 830| 1| return ErrorMalformed; // [NOTE] current implementation can't go over 2^30 831| 24| if (!imageData) // just header ------------------ | Branch (831:7): [True: 12, False: 12] ------------------ 832| 12| return ResultOk; 833| 12| if (header.isSigned != (std::numeric_limits::is_signed ? 1 : 0) || header.bitDepth > std::numeric_limits::digits) ------------------ | Branch (833:7): [True: 0, False: 12] | Branch (833:27): [Folded - Ignored] | Branch (833:76): [True: 0, False: 12] ------------------ 834| 0| return ErrorTypeMismatch; // check for correct buffer type (though doesn't test the buffer size) 835| | // [NOTE] clients can read metadata themselves by accessing the size (in words) at word[7] and the metadata at word[8+] 836| 12| if ((stream.buffer += stream.getBits(32)) >= stream.bufferEnd) // skip metadata ------------------ | Branch (836:7): [True: 0, False: 12] ------------------ 837| 0| return reinterpret_cast(stream.buffer) - data; // suggest point of interest to skip metadata 838| 12| int const sizexDown = (header.sizex + (1 << downsampling) - 1) >> downsampling, sizeyDown = (header.sizey + (1 << downsampling) - 1) >> downsampling; 839| 12| int const bufferSize = sizexDown * sizeyDown; 840| 12| std::vector auxData((size_t)header.layers * header.channels * bufferSize, 0); 841| 12| std::vector isChroma(header.layers * header.channels, 0), transformProgram, transformSteps; 842| 12| size_t nextPointOfInterest = size + 1024; // guess next point of interest [NOTE] may be larger than the complete file 843| 707k| while (true) // decode color transform program (including isChroma flags) ------------------ | Branch (843:10): [Folded - Ignored] ------------------ 844| 707k| { 845| 707k| transformProgram.push_back(signedDecode<2>(stream)); // channel 846| 707k| if (transformProgram.back() >= static_cast(isChroma.size())) ------------------ | Branch (846:8): [True: 0, False: 707k] ------------------ 847| 0| return ErrorMalformed; 848| 707k| if (transformProgram.back() < 0) ------------------ | Branch (848:8): [True: 12, False: 707k] ------------------ 849| 12| break; 850| 707k| transformSteps.push_back(int(transformProgram.size()) - 1); 851| 1.79M| while (true) ------------------ | Branch (851:11): [Folded - Ignored] ------------------ 852| 1.79M| { 853| 1.79M| if (stream.indexBits < 0) // test for truncation ------------------ | Branch (853:9): [True: 0, False: 1.79M] ------------------ 854| 0| return nextPointOfInterest; // need more data 855| 1.79M| transformProgram.push_back(signedDecode<2>(stream)); // other channel 856| 1.79M| if (transformProgram.back() >= static_cast(isChroma.size())) ------------------ | Branch (856:13): [True: 0, False: 1.79M] ------------------ 857| 0| return ErrorMalformed; 858| 1.79M| if (transformProgram.back() < 0) ------------------ | Branch (858:9): [True: 707k, False: 1.09M] ------------------ 859| 707k| break; 860| 1.09M| transformProgram.push_back(signedDecode<2>(stream)); // factor 861| 1.09M| } 862| 707k| transformProgram.push_back(signedDecode<2>(stream)); // denominator 863| 707k| transformProgram.push_back(signedDecode<2>(stream)); // chroma flag 864| 707k| isChroma[transformProgram[transformSteps.back()]] = transformProgram.back(); 865| 707k| } 866| 12| stream.flushReadWord(); 867| 12| int const chromaQuality = std::max(1, (header.quality + header.chromaScale / 2) / header.chromaScale); 868| 12| int const boost = header.quality == QualityMax ? 1 : 8; // [NOTE] due to Cubic lifting max multiplier of 20, boost * 20 must be less than 256 ------------------ | Branch (868:21): [True: 2, False: 10] ------------------ 869| 12| bool isTruncated = false; 870| 12| int step = 1; 871| 109| while (step * 2 < header.sizex || step * 2 < header.sizey) ------------------ | Branch (871:10): [True: 95, False: 14] | Branch (871:37): [True: 2, False: 12] ------------------ 872| 97| step *= 2; 873| 60| for (bool hasDC = true; (step >> downsampling) >= 1; hasDC = false) // decode just enough coefficients for downsampled image ------------------ | Branch (873:27): [True: 58, False: 2] ------------------ 874| 58| { 875| 58| int64_t const bs = int64_t(step) << header.blockSize; 876| 58| int const blockCountX = int((header.sizex + bs - 1) / bs); 877| 58| int const blockCountY = int((header.sizey + bs - 1) / bs); 878| 58| int const blockCount = blockCountX * blockCountY * header.layers * header.channels; 879| 58| isTruncated = true; 880| 58| if (stream.buffer + 1 + blockCount > stream.bufferEnd) // check for enough buffer to read block sizes ------------------ | Branch (880:8): [True: 7, False: 51] ------------------ 881| 7| break; 882| 51| std::vector streamBlock(blockCount, Bits(0, 0)); 883| 196| for (int block = 0; block < blockCount; ++ block) // first, read sizes into bufferEnd pointers ------------------ | Branch (883:24): [True: 145, False: 51] ------------------ 884| 145| streamBlock[block].bufferEnd = static_cast(0) + *(stream.buffer ++); 885| 196| for (int block = 0; block < blockCount; ++ block) // then convert sizes to true buffer pointers ------------------ | Branch (885:24): [True: 145, False: 51] ------------------ 886| 145| streamBlock[block].bufferEnd = (streamBlock[block].buffer = block ? streamBlock[block - 1].bufferEnd : stream.buffer) ------------------ | Branch (886:65): [True: 94, False: 51] ------------------ 887| 145| + (streamBlock[block].bufferEnd - static_cast(0)); 888| 51| stream.buffer = streamBlock[blockCount - 1].bufferEnd; 889| 51| nextPointOfInterest = reinterpret_cast(stream.buffer + ((step >> downsampling) > 1 ? blockCount * 4 : 0)) - data; ------------------ | Branch (889:71): [True: 49, False: 2] ------------------ 890| 51| if (stream.buffer <= stream.bufferEnd) ------------------ | Branch (890:8): [True: 48, False: 3] ------------------ 891| 48| isTruncated = false; 892| 51| int const stepDown = step >> downsampling; 893| 51| int64_t const bsDown = int64_t(stepDown) << header.blockSize; 894| 51| OMP_PARALLEL_FOR(4) // [MAGIC] for some reason, 4 is by far the best option here 895| 196| for (int block = 0; block < blockCount; ++ block) if (!test && streamBlock[block].bufferEnd <= stream.bufferEnd) ------------------ | Branch (895:24): [True: 145, False: 51] | Branch (895:58): [True: 145, False: 0] | Branch (895:67): [True: 48, False: 97] ------------------ 896| 48| { 897| 48| int const bx = block % blockCountX, by = (block / blockCountX) % blockCountY, c = block / (blockCountX * blockCountY); 898| 48| Image auxImage(&auxData[c * bufferSize], sizexDown, sizeyDown); 899| 48| if (header.intent < IntentBayerRGGB || header.intent > IntentBayerGeneric) ------------------ | Branch (899:9): [True: 0, False: 48] | Branch (899:44): [True: 48, False: 0] ------------------ 900| 48| decode(auxImage, streamBlock[block], int(bx * bsDown), int(by * bsDown), 901| 48| int(std::min((bx + 1) * bsDown, int64_t(sizexDown))), int(std::min((by + 1) * bsDown, int64_t(sizeyDown))), 902| 48| stepDown, header.encoder, isChroma[c] ? chromaQuality : header.quality, hasDC && !bx && !by, isChroma[c] != 0); ------------------ | Branch (902:32): [True: 0, False: 48] | Branch (902:78): [True: 5, False: 43] | Branch (902:87): [True: 5, False: 0] | Branch (902:94): [True: 5, False: 0] ------------------ 903| 0| else for (int ox = 0; ox <= 1; ++ ox) for (int oy = 0; oy <= 1; ++ oy) ------------------ | Branch (903:27): [True: 0, False: 0] | Branch (903:60): [True: 0, False: 0] ------------------ 904| 0| decode(auxImage, streamBlock[block], int(bx * bsDown + ox), int(by * bsDown + oy), 905| 0| int(std::min((bx + 1) * bsDown, int64_t(sizexDown))), int(std::min((by + 1) * bsDown, int64_t(sizeyDown))), 906| 0| 2 * stepDown, header.encoder, (ox || oy) ? chromaQuality : header.quality, hasDC && !bx && !by, ox || oy); ------------------ | Branch (906:37): [True: 0, False: 0] | Branch (906:43): [True: 0, False: 0] | Branch (906:81): [True: 0, False: 0] | Branch (906:90): [True: 0, False: 0] | Branch (906:97): [True: 0, False: 0] | Branch (906:102): [True: 0, False: 0] | Branch (906:108): [True: 0, False: 0] ------------------ 907| 48| } 908| 193| for (int block = 0; block < blockCount; ++ block) // check if any blocks ran out of buffer, which should not happen on valid files ------------------ | Branch (908:24): [True: 145, False: 48] ------------------ 909| 145| if (streamBlock[block].indexBits < 0) ------------------ | Branch (909:9): [True: 3, False: 142] ------------------ 910| 3| return ErrorMalformed; 911| 48| step /= 2; 912| 48| } 913| 9| if (test) ------------------ | Branch (913:7): [True: 0, False: 9] ------------------ 914| 0| return isTruncated ? nextPointOfInterest : ResultOk; // return next point of interest if the data was truncated prior to completing request ------------------ | Branch (914:11): [True: 0, False: 0] ------------------ 915| 461| for (int c = 0; c < header.layers * header.channels; ++ c) // dequantize and unlift the channels ------------------ | Branch (915:19): [True: 452, False: 9] ------------------ 916| 452| { 917| 452| Image auxImage(&auxData[c * bufferSize], sizexDown, sizeyDown); 918| 452| if (header.intent >= IntentBayerRGGB && header.intent <= IntentBayerGeneric) ------------------ | Branch (918:8): [True: 452, False: 0] | Branch (918:44): [True: 30, False: 422] ------------------ 919| 30| { 920| 180| for (int ox = 0; ox <= 1; ++ ox) for (int oy = 0; oy <= 1; ++ oy) ------------------ | Branch (920:22): [True: 60, False: 30] | Branch (920:55): [True: 120, False: 60] ------------------ 921| 120| quantize(auxImage, ox, oy, sizexDown, sizeyDown, 2, 922| 120| ((ox | oy) ? chromaQuality : header.quality) << downsampling, header.quality, QualityMax * boost); ------------------ | Branch (922:8): [True: 90, False: 30] ------------------ 923| 150| for (int ox = 0; ox <= 1; ++ ox) for (int oy = 1 - ox; oy <= 1; ++ oy) ------------------ | Branch (923:22): [True: 60, False: 30] | Branch (923:60): [True: 90, False: 60] ------------------ 924| 90| unlift(auxImage, ox, oy, sizexDown, sizeyDown, 2, header.filter); 925| 30| } 926| 422| else 927| 422| quantize(auxImage, 0, 0, sizexDown, sizeyDown, 1, 928| 422| (isChroma[c] ? chromaQuality : header.quality) << downsampling, 0, QualityMax * boost); ------------------ | Branch (928:7): [True: 48, False: 374] ------------------ 929| 452| unlift(auxImage, 0, 0, sizexDown, sizeyDown, 1, header.filter); 930| 452| } 931| 707k| for (int s = (int)transformSteps.size() - 1; s >= 0; -- s) // run color transform program in reverse ------------------ | Branch (931:48): [True: 707k, False: 9] ------------------ 932| 707k| { 933| 707k| int const * pc = &transformProgram[transformSteps[s]]; 934| 707k| int const c = *(pc ++); 935| 707k| std::vector transformTemp(bufferSize, 0); 936| 707k| transformTerm(pc, &transformTemp[0], &auxData[0], bufferSize, imageData, header, isChroma, boost); 937| 707k| aux * destination = &auxData[c * bufferSize]; 938| 707k| OMP_PARALLEL_FOR(ThreadIterations * ThreadIterations) 939| 4.68G| for (int i = 0; i < bufferSize; ++ i) ------------------ | Branch (939:20): [True: 4.68G, False: 707k] ------------------ 940| 4.68G| destination[i] -= transformTemp[i]; 941| 707k| } 942| 461| for (int c = 0; c < header.layers * header.channels; ++ c) // copy the channels to the destination buffer ------------------ | Branch (942:19): [True: 452, False: 9] ------------------ 943| 452| { 944| 452| aux * destination = &auxData[c * bufferSize]; 945| 452| auto layer = imageData + ((c / header.channels) * bufferSize * header.channels + c % header.channels); 946| 452| if (boost == 1) ------------------ | Branch (946:8): [True: 0, False: 452] ------------------ 947| 0| { 948| 0| OMP_PARALLEL_FOR(ThreadIterations * ThreadIterations) 949| 0| for (int i = 0; i < bufferSize; ++ i) ------------------ | Branch (949:21): [True: 0, False: 0] ------------------ 950| 0| layer[i * header.channels] = static_cast(std::max(static_cast(std::numeric_limits::lowest()), 951| 0| std::min(static_cast(std::numeric_limits::max()), static_cast(destination[i])))); 952| 0| } 953| 452| else 954| 452| { 955| 452| OMP_PARALLEL_FOR(ThreadIterations * ThreadIterations) 956| 2.89M| for (int i = 0; i < bufferSize; ++ i) ------------------ | Branch (956:21): [True: 2.89M, False: 452] ------------------ 957| 2.89M| layer[i * header.channels] = static_cast(std::max(static_cast(std::numeric_limits::lowest()), 958| 2.89M| std::min(static_cast(std::numeric_limits::max()), static_cast(destination[i] / boost)))); 959| 452| } 960| 452| if (header.quality < QualityMax && header.intent >= IntentBayerRGGB && header.intent <= IntentBayerGBRG) // check if Bayer cleanup is required ------------------ | Branch (960:8): [True: 452, False: 0] | Branch (960:39): [True: 452, False: 0] | Branch (960:75): [True: 30, False: 422] ------------------ 961| 30| { 962| 30| int const bayerNoiseThresh = ((QualityMax + header.quality / 2) / header.quality + (QualityMax + chromaQuality / 2) / chromaQuality) * 2; 963| 30| Image auxImage(&auxData[c * bufferSize], sizexDown, sizeyDown); 964| 30| OMP_PARALLEL_FOR(ThreadIterations) 965| 30| for (int y = 1; y < sizeyDown - 1; ++ y) ------------------ | Branch (965:21): [True: 0, False: 30] ------------------ 966| 0| for (int x = 1 + (y + (header.intent == IntentBayerGBRG || header.intent == IntentBayerGRBG ? 1 : 0)) % 2; x < sizexDown - 1; x += 2) ------------------ | Branch (966:29): [True: 0, False: 0] | Branch (966:65): [True: 0, False: 0] | Branch (966:113): [True: 0, False: 0] ------------------ 967| 0| { 968| 0| aux s = auxImage[y][x]; 969| 0| aux sum = s * 4; 970| 0| int count = 4; 971| 0| for (int oy = -1; oy <= 1; oy += 2) for (int ox = -1; ox <= 1; ox += 2) ------------------ | Branch (971:25): [True: 0, False: 0] | Branch (971:61): [True: 0, False: 0] ------------------ 972| 0| { 973| 0| aux t = auxImage[y + oy][x + ox]; 974| 0| if (abs(s - t) > bayerNoiseThresh) ------------------ | Branch (974:12): [True: 0, False: 0] ------------------ 975| 0| continue; 976| 0| sum += t; 977| 0| ++ count; 978| 0| } 979| 0| layer[(y * sizexDown + x) * header.channels] 980| 0| = static_cast(std::max(static_cast(std::numeric_limits::lowest()), 981| 0| std::min(static_cast(std::numeric_limits::max()), aux((sum + count / 2) / (count * boost))))); 982| 0| } 983| 30| } 984| 452| } 985| 9| return isTruncated ? nextPointOfInterest : ResultOk; // return next point of interest if the data was truncated prior to completing request ------------------ | Branch (985:10): [True: 8, False: 1] ------------------ 986| 9| } _ZN4GFWX4BitsC2EPjS1_: 107| 79| Bits(uint32_t * buffer, uint32_t * bufferEnd) : buffer(buffer), bufferEnd(bufferEnd), writeCache(0), indexBits(0) {} _ZN4GFWX4Bits7getBitsEi: 109| 9.81M| { 110| 9.81M| int newBits = indexBits + bits; 111| 9.81M| if (buffer == bufferEnd) ------------------ | Branch (111:8): [True: 67.8k, False: 9.74M] ------------------ 112| 67.8k| return indexBits = -1; // signify overflow 113| 9.74M| uint32_t x = *buffer << indexBits; 114| 9.74M| if (newBits >= 32) ------------------ | Branch (114:8): [True: 486k, False: 9.26M] ------------------ 115| 486k| { 116| 486k| ++ buffer; 117| 486k| if ((newBits -= 32) > 0) ------------------ | Branch (117:9): [True: 9.12k, False: 476k] ------------------ 118| 9.12k| { 119| 9.12k| if (buffer == bufferEnd) ------------------ | Branch (119:10): [True: 1, False: 9.12k] ------------------ 120| 1| return indexBits = -1; // signify overflow 121| 9.12k| x |= *buffer >> (32 - indexBits); 122| 9.12k| } 123| 486k| } 124| 9.74M| indexBits = newBits; 125| 9.74M| return x >> (32 - bits); 126| 9.74M| } _ZNK4GFWX6Header10bufferSizeEv: 87| 25| { 88| 25| size_t const part1 = static_cast(sizex) * sizey; 89| 25| size_t const part2 = static_cast(channels) * layers * ((bitDepth + 7) / 8); 90| 25| return std::log(part1) + std::log(part2) > std::log(std::numeric_limits::max() - 1) ? 0 : part1 * part2; ------------------ | Branch (90:14): [True: 0, False: 25] ------------------ 91| 25| } _ZN4GFWX12signedDecodeILi2EEEiRNS_4BitsE: 229| 5.01M| { 230| 5.01M| int x = unsignedDecode(stream); 231| 5.01M| return x ? stream.getBits(1) ? x : -x : 0; ------------------ | Branch (231:10): [True: 4.61M, False: 405k] | Branch (231:14): [True: 2.26M, False: 2.34M] ------------------ 232| 5.01M| } _ZN4GFWX14unsignedDecodeILi2EEEjRNS_4BitsE: 204| 5.03M| { 205| 5.03M| uint32_t x = stream.getZeros(12); 206| 5.03M| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 5.03M| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.02k, False: 5.03M] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.03M| } _ZN4GFWX4Bits8getZerosEj: 148| 5.40M| { 149| 5.40M| int newBits = indexBits; 150| 5.40M| if (buffer == bufferEnd) ------------------ | Branch (150:8): [True: 103k, False: 5.30M] ------------------ 151| 103k| return indexBits = -1; // signify overflow 152| 5.30M| uint32_t b = *buffer; 153| 5.30M| uint32_t x = 0; 154| 7.40M| while (true) ------------------ | Branch (154:11): [Folded - Ignored] ------------------ 155| 7.40M| { 156| 7.40M| if (newBits == 31) ------------------ | Branch (156:9): [True: 217k, False: 7.19M] ------------------ 157| 217k| { 158| 217k| ++ buffer; 159| 217k| if ((b & 1u) || (++ x == maxZeros)) ------------------ | Branch (159:10): [True: 148k, False: 69.0k] | Branch (159:22): [True: 13.0k, False: 55.9k] ------------------ 160| 161k| { 161| 161k| indexBits = 0; 162| 161k| return x; 163| 161k| } 164| 55.9k| if (buffer == bufferEnd) ------------------ | Branch (164:10): [True: 1, False: 55.9k] ------------------ 165| 1| return indexBits = -1; // signify overflow 166| 55.9k| b = *buffer; 167| 55.9k| newBits = 0; 168| 55.9k| continue; 169| 55.9k| } 170| 7.19M| if (((b << newBits) & (1u << 31)) || (++ x == maxZeros)) ------------------ | Branch (170:9): [True: 4.98M, False: 2.21M] | Branch (170:42): [True: 160k, False: 2.04M] ------------------ 171| 5.14M| { 172| 5.14M| indexBits = newBits + 1; 173| 5.14M| return x; 174| 5.14M| } 175| 2.04M| ++ newBits; 176| 2.04M| } 177| 5.30M| } _ZN4GFWX14unsignedDecodeILi6EEEjRNS_4BitsE: 204| 1.02k| { 205| 1.02k| uint32_t x = stream.getZeros(12); 206| 1.02k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.02k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 967, False: 54] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.02k| } _ZN4GFWX14unsignedDecodeILi10EEEjRNS_4BitsE: 204| 967| { 205| 967| uint32_t x = stream.getZeros(12); 206| 967| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 967| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 935, False: 32] | Branch (207:99): [Folded - Ignored] ------------------ 208| 967| } _ZN4GFWX14unsignedDecodeILi14EEEjRNS_4BitsE: 204| 935| { 205| 935| uint32_t x = stream.getZeros(12); 206| 935| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 935| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 923, False: 12] | Branch (207:99): [Folded - Ignored] ------------------ 208| 935| } _ZN4GFWX14unsignedDecodeILi18EEEjRNS_4BitsE: 204| 923| { 205| 923| uint32_t x = stream.getZeros(12); 206| 923| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 923| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 918, False: 5] | Branch (207:99): [Folded - Ignored] ------------------ 208| 923| } _ZN4GFWX14unsignedDecodeILi22EEEjRNS_4BitsE: 204| 918| { 205| 918| uint32_t x = stream.getZeros(12); 206| 918| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 918| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 916, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 918| } _ZN4GFWX14unsignedDecodeILi26EEEjRNS_4BitsE: 204| 916| { 205| 916| uint32_t x = stream.getZeros(12); 206| 916| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 916| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 914, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 916| } _ZN4GFWX14unsignedDecodeILi30EEEjRNS_4BitsE: 204| 914| { 205| 914| uint32_t x = stream.getZeros(12); 206| 914| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 914| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 914, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 914| } _ZN4GFWX14unsignedDecodeILi34EEEjRNS_4BitsE: 204| 914| { 205| 914| uint32_t x = stream.getZeros(12); 206| 914| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 914| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 908, False: 6] | Branch (207:99): [Folded - Ignored] ------------------ 208| 914| } _ZN4GFWX14unsignedDecodeILi38EEEjRNS_4BitsE: 204| 908| { 205| 908| uint32_t x = stream.getZeros(12); 206| 908| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 908| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 906, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 908| } _ZN4GFWX14unsignedDecodeILi42EEEjRNS_4BitsE: 204| 906| { 205| 906| uint32_t x = stream.getZeros(12); 206| 906| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 906| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 904, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 906| } _ZN4GFWX14unsignedDecodeILi46EEEjRNS_4BitsE: 204| 904| { 205| 904| uint32_t x = stream.getZeros(12); 206| 904| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 904| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 901, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 904| } _ZN4GFWX14unsignedDecodeILi50EEEjRNS_4BitsE: 204| 901| { 205| 901| uint32_t x = stream.getZeros(12); 206| 901| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 901| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 901, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 901| } _ZN4GFWX14unsignedDecodeILi54EEEjRNS_4BitsE: 204| 901| { 205| 901| uint32_t x = stream.getZeros(12); 206| 901| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 901| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 901, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 901| } _ZN4GFWX14unsignedDecodeILi58EEEjRNS_4BitsE: 204| 901| { 205| 901| uint32_t x = stream.getZeros(12); 206| 901| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 901| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 899, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 901| } _ZN4GFWX14unsignedDecodeILi62EEEjRNS_4BitsE: 204| 899| { 205| 899| uint32_t x = stream.getZeros(12); 206| 899| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 899| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 877, False: 22] | Branch (207:99): [Folded - Ignored] ------------------ 208| 899| } _ZN4GFWX14unsignedDecodeILi66EEEjRNS_4BitsE: 204| 877| { 205| 877| uint32_t x = stream.getZeros(12); 206| 877| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 877| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 875, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 877| } _ZN4GFWX14unsignedDecodeILi70EEEjRNS_4BitsE: 204| 875| { 205| 875| uint32_t x = stream.getZeros(12); 206| 875| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 875| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 872, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 875| } _ZN4GFWX14unsignedDecodeILi74EEEjRNS_4BitsE: 204| 872| { 205| 872| uint32_t x = stream.getZeros(12); 206| 872| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 872| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 872, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 872| } _ZN4GFWX14unsignedDecodeILi78EEEjRNS_4BitsE: 204| 872| { 205| 872| uint32_t x = stream.getZeros(12); 206| 872| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 872| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 872, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 872| } _ZN4GFWX14unsignedDecodeILi82EEEjRNS_4BitsE: 204| 872| { 205| 872| uint32_t x = stream.getZeros(12); 206| 872| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 872| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 870, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 872| } _ZN4GFWX14unsignedDecodeILi86EEEjRNS_4BitsE: 204| 870| { 205| 870| uint32_t x = stream.getZeros(12); 206| 870| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 870| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 870, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 870| } _ZN4GFWX14unsignedDecodeILi90EEEjRNS_4BitsE: 204| 870| { 205| 870| uint32_t x = stream.getZeros(12); 206| 870| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 870| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 864, False: 6] | Branch (207:99): [Folded - Ignored] ------------------ 208| 870| } _ZN4GFWX14unsignedDecodeILi94EEEjRNS_4BitsE: 204| 864| { 205| 864| uint32_t x = stream.getZeros(12); 206| 864| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 864| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 864, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 864| } _ZN4GFWX14unsignedDecodeILi98EEEjRNS_4BitsE: 204| 864| { 205| 864| uint32_t x = stream.getZeros(12); 206| 864| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 864| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 864, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 864| } _ZN4GFWX14unsignedDecodeILi102EEEjRNS_4BitsE: 204| 864| { 205| 864| uint32_t x = stream.getZeros(12); 206| 864| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 864| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 863, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 864| } _ZN4GFWX14unsignedDecodeILi106EEEjRNS_4BitsE: 204| 863| { 205| 863| uint32_t x = stream.getZeros(12); 206| 863| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 863| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 863, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 863| } _ZN4GFWX14unsignedDecodeILi110EEEjRNS_4BitsE: 204| 863| { 205| 863| uint32_t x = stream.getZeros(12); 206| 863| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 863| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 0, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 863| } _ZN4GFWX4Bits13flushReadWordEv: 183| 12| { 184| 12| if (indexBits <= 0) ------------------ | Branch (184:8): [True: 5, False: 7] ------------------ 185| 5| return; 186| 7| ++ buffer; 187| 7| indexBits = 0; 188| 7| } _ZN4GFWX5ImageIsEC2EPsii: 98| 530| Image(T * data, int sizex, int sizey) : data(data), sizex(sizex), sizey(sizey) {} _ZN4GFWX6decodeIsEEvRNS_5ImageIT_EERNS_4BitsEiiiiiiibb: 562| 48| { 563| 48| int const sizex = x1 - x0; 564| 48| int const sizey = y1 - y0; 565| 48| if (hasDC && sizex > 0 && sizey > 0) ------------------ | Branch (565:7): [True: 5, False: 43] | Branch (565:16): [True: 5, False: 0] | Branch (565:29): [True: 5, False: 0] ------------------ 566| 5| image[y0][x0] = signedDecode<4>(stream); 567| 48| std::pair context(0, 0); 568| 48| int run = -1, runCoder = (scheme == EncoderTurbo ? (!q || (step < 2048 && q * step < 2048)) ? 1 : 0 : 0); // avoid overflow checking q * step < 2048 ------------------ | Branch (568:29): [True: 14, False: 34] | Branch (568:55): [True: 0, False: 14] | Branch (568:62): [True: 14, False: 0] | Branch (568:77): [True: 0, False: 14] ------------------ 569| 1.01k| for (int y = 0; y < sizey; y += step) ------------------ | Branch (569:19): [True: 963, False: 48] ------------------ 570| 963| { 571| 963| T * base = &image[y0 + y][x0]; 572| 963| int const xStep = (y & step) ? step : step * 2; ------------------ | Branch (572:22): [True: 471, False: 492] ------------------ 573| 516k| for (int x = xStep - step; x < sizex; x += xStep) // [NOTE] arranged so that (x | y) & step == 1 ------------------ | Branch (573:31): [True: 515k, False: 963] ------------------ 574| 515k| { 575| 515k| T s = 0; 576| 515k| if (runCoder && run == -1) ------------------ | Branch (576:9): [True: 390k, False: 125k] | Branch (576:21): [True: 50.2k, False: 340k] ------------------ 577| 50.2k| run = runCoder == 1 ? unsignedDecode<1>(stream) : runCoder == 2 ? unsignedDecode<2>(stream) ------------------ | Branch (577:12): [True: 1.59k, False: 48.6k] | Branch (577:56): [True: 4.39k, False: 44.2k] ------------------ 578| 48.6k| : runCoder == 3 ? unsignedDecode<3>(stream) : unsignedDecode<4>(stream); ------------------ | Branch (578:9): [True: 1.43k, False: 42.7k] ------------------ 579| 515k| if (run > 0) ------------------ | Branch (579:9): [True: 340k, False: 175k] ------------------ 580| 340k| -- run; // consume a zero 581| 175k| else 582| 175k| { 583| 175k| if (scheme == EncoderTurbo) ------------------ | Branch (583:10): [True: 32.7k, False: 142k] ------------------ 584| 32.7k| s = interleavedDecode<1>(stream); 585| 142k| else 586| 142k| { 587| 142k| if (scheme == EncoderContextual) ------------------ | Branch (587:11): [True: 142k, False: 0] ------------------ 588| 142k| context = getContext(image, x0, y0, x1, y1, x, y, step); 589| 142k| uint32_t const sumSq = square(context.first); 590| 142k| if (sumSq < 2u * context.second + (isChroma ? 250u : 100u)) ------------------ | Branch (590:11): [True: 54.0k, False: 88.4k] | Branch (590:42): [True: 0, False: 142k] ------------------ 591| 54.0k| s = interleavedDecode<0>(stream); 592| 88.4k| else if (sumSq < 2u * context.second + 950u) ------------------ | Branch (592:16): [True: 27.6k, False: 60.7k] ------------------ 593| 27.6k| s = interleavedDecode<1>(stream); 594| 60.7k| else if (sumSq < 3u * context.second + 3000u) ------------------ | Branch (594:16): [True: 17.1k, False: 43.5k] ------------------ 595| 17.1k| { 596| 17.1k| if (sumSq < 5u * context.second + 400u) ------------------ | Branch (596:12): [True: 4.26k, False: 12.9k] ------------------ 597| 4.26k| s = signedDecode<1>(stream); 598| 12.9k| else 599| 12.9k| s = interleavedDecode<2>(stream); 600| 17.1k| } 601| 43.5k| else if (sumSq < 3u * context.second + 12000u) ------------------ | Branch (601:16): [True: 17.2k, False: 26.3k] ------------------ 602| 17.2k| { 603| 17.2k| if (sumSq < 5u * context.second + 3000u) ------------------ | Branch (603:12): [True: 6.26k, False: 10.9k] ------------------ 604| 6.26k| s = signedDecode<2>(stream); 605| 10.9k| else 606| 10.9k| s = interleavedDecode<3>(stream); 607| 17.2k| } 608| 26.3k| else if (sumSq < 4u * context.second + 44000u) ------------------ | Branch (608:16): [True: 12.7k, False: 13.5k] ------------------ 609| 12.7k| { 610| 12.7k| if (sumSq < 6u * context.second + 12000u) ------------------ | Branch (610:12): [True: 7.98k, False: 4.77k] ------------------ 611| 7.98k| s = signedDecode<3>(stream); 612| 4.77k| else 613| 4.77k| s = interleavedDecode<4>(stream); 614| 12.7k| } 615| 13.5k| else 616| 13.5k| s = signedDecode<4>(stream); 617| 142k| if (scheme == EncoderFast) // use decaying first and second moment ------------------ | Branch (617:11): [True: 0, False: 142k] ------------------ 618| 0| { 619| 0| uint32_t const t = abs(s); 620| 0| context = std::make_pair(((context.first * 15u + 7u) >> 4) + t, ((context.second * 15u + 7u) >> 4) + square(std::min(t, 4096u))); 621| 0| if (!s == !runCoder) ------------------ | Branch (621:12): [True: 0, False: 0] ------------------ 622| 0| runCoder = context.first < 1 ? 4 : context.first < 2 ? 3 : context.first < 4 ? 2 : context.first < 8 ? 1 : 0; ------------------ | Branch (622:20): [True: 0, False: 0] | Branch (622:44): [True: 0, False: 0] | Branch (622:68): [True: 0, False: 0] | Branch (622:92): [True: 0, False: 0] ------------------ 623| 0| } 624| 142k| else if (!s == !runCoder) ------------------ | Branch (624:16): [True: 16.7k, False: 125k] ------------------ 625| 16.7k| runCoder = q == 1024 ? context.first < 2u ? 1 : 0 : (context.first < 4u && context.second < 2u) ? 4 : (context.first < 8u ------------------ | Branch (625:19): [True: 0, False: 16.7k] | Branch (625:31): [True: 0, False: 0] | Branch (625:61): [True: 4.32k, False: 12.4k] | Branch (625:83): [True: 3.46k, False: 861] | Branch (625:111): [True: 2.11k, False: 11.1k] ------------------ 626| 13.2k| && context.second < 4u) ? 3 : (2u * sumSq < 3u * context.second + 48u) ? 2 : (2u * sumSq < 5u * context.second + 32u) ? 1 : 0; ------------------ | Branch (626:11): [True: 643, False: 1.47k] | Branch (626:38): [True: 1.39k, False: 11.2k] | Branch (626:85): [True: 1.01k, False: 10.2k] ------------------ 627| 142k| } 628| 175k| if (run == 0 && s <= 0) ------------------ | Branch (628:10): [True: 11.4k, False: 163k] | Branch (628:22): [True: 7.36k, False: 4.12k] ------------------ 629| 7.36k| -- s; // s can't be zero, so shift negatives by 1 630| 175k| run = -1; 631| 175k| } 632| 515k| base[x] = s; 633| 515k| } 634| 963| } 635| 48| } _ZN4GFWX12signedDecodeILi4EEEiRNS_4BitsE: 229| 13.5k| { 230| 13.5k| int x = unsignedDecode(stream); 231| 13.5k| return x ? stream.getBits(1) ? x : -x : 0; ------------------ | Branch (231:10): [True: 13.2k, False: 381] | Branch (231:14): [True: 6.30k, False: 6.91k] ------------------ 232| 13.5k| } _ZN4GFWX14unsignedDecodeILi1EEEjRNS_4BitsE: 204| 66.2k| { 205| 66.2k| uint32_t x = stream.getZeros(12); 206| 66.2k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 66.2k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 9.02k, False: 57.2k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 66.2k| } _ZN4GFWX14unsignedDecodeILi5EEEjRNS_4BitsE: 204| 9.02k| { 205| 9.02k| uint32_t x = stream.getZeros(12); 206| 9.02k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 9.02k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 7.86k, False: 1.15k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 9.02k| } _ZN4GFWX14unsignedDecodeILi9EEEjRNS_4BitsE: 204| 7.86k| { 205| 7.86k| uint32_t x = stream.getZeros(12); 206| 7.86k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 7.86k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 6.92k, False: 934] | Branch (207:99): [Folded - Ignored] ------------------ 208| 7.86k| } _ZN4GFWX14unsignedDecodeILi13EEEjRNS_4BitsE: 204| 6.92k| { 205| 6.92k| uint32_t x = stream.getZeros(12); 206| 6.92k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 6.92k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 6.66k, False: 267] | Branch (207:99): [Folded - Ignored] ------------------ 208| 6.92k| } _ZN4GFWX14unsignedDecodeILi17EEEjRNS_4BitsE: 204| 6.66k| { 205| 6.66k| uint32_t x = stream.getZeros(12); 206| 6.66k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 6.66k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 5.91k, False: 744] | Branch (207:99): [Folded - Ignored] ------------------ 208| 6.66k| } _ZN4GFWX14unsignedDecodeILi21EEEjRNS_4BitsE: 204| 5.91k| { 205| 5.91k| uint32_t x = stream.getZeros(12); 206| 5.91k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 5.91k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 5.69k, False: 225] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.91k| } _ZN4GFWX14unsignedDecodeILi25EEEjRNS_4BitsE: 204| 5.69k| { 205| 5.69k| uint32_t x = stream.getZeros(12); 206| 5.69k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 5.69k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 5.53k, False: 155] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.69k| } _ZN4GFWX14unsignedDecodeILi29EEEjRNS_4BitsE: 204| 5.53k| { 205| 5.53k| uint32_t x = stream.getZeros(12); 206| 5.53k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 5.53k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 5.40k, False: 131] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.53k| } _ZN4GFWX14unsignedDecodeILi33EEEjRNS_4BitsE: 204| 5.40k| { 205| 5.40k| uint32_t x = stream.getZeros(12); 206| 5.40k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 5.40k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 5.06k, False: 340] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.40k| } _ZN4GFWX14unsignedDecodeILi37EEEjRNS_4BitsE: 204| 5.06k| { 205| 5.06k| uint32_t x = stream.getZeros(12); 206| 5.06k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 5.06k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.93k, False: 128] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.06k| } _ZN4GFWX14unsignedDecodeILi41EEEjRNS_4BitsE: 204| 4.93k| { 205| 4.93k| uint32_t x = stream.getZeros(12); 206| 4.93k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.93k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.87k, False: 63] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.93k| } _ZN4GFWX14unsignedDecodeILi45EEEjRNS_4BitsE: 204| 4.87k| { 205| 4.87k| uint32_t x = stream.getZeros(12); 206| 4.87k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.87k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.77k, False: 99] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.87k| } _ZN4GFWX14unsignedDecodeILi49EEEjRNS_4BitsE: 204| 4.77k| { 205| 4.77k| uint32_t x = stream.getZeros(12); 206| 4.77k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.77k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.68k, False: 94] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.77k| } _ZN4GFWX14unsignedDecodeILi53EEEjRNS_4BitsE: 204| 4.68k| { 205| 4.68k| uint32_t x = stream.getZeros(12); 206| 4.68k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.68k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.59k, False: 90] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.68k| } _ZN4GFWX14unsignedDecodeILi57EEEjRNS_4BitsE: 204| 4.59k| { 205| 4.59k| uint32_t x = stream.getZeros(12); 206| 4.59k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.59k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.51k, False: 80] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.59k| } _ZN4GFWX14unsignedDecodeILi61EEEjRNS_4BitsE: 204| 4.51k| { 205| 4.51k| uint32_t x = stream.getZeros(12); 206| 4.51k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.51k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.43k, False: 79] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.51k| } _ZN4GFWX14unsignedDecodeILi65EEEjRNS_4BitsE: 204| 4.43k| { 205| 4.43k| uint32_t x = stream.getZeros(12); 206| 4.43k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.43k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 4.12k, False: 305] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.43k| } _ZN4GFWX14unsignedDecodeILi69EEEjRNS_4BitsE: 204| 4.12k| { 205| 4.12k| uint32_t x = stream.getZeros(12); 206| 4.12k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 4.12k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 3.34k, False: 788] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.12k| } _ZN4GFWX14unsignedDecodeILi73EEEjRNS_4BitsE: 204| 3.34k| { 205| 3.34k| uint32_t x = stream.getZeros(12); 206| 3.34k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 3.34k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 3.26k, False: 74] | Branch (207:99): [Folded - Ignored] ------------------ 208| 3.34k| } _ZN4GFWX14unsignedDecodeILi77EEEjRNS_4BitsE: 204| 3.26k| { 205| 3.26k| uint32_t x = stream.getZeros(12); 206| 3.26k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 3.26k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 2.98k, False: 279] | Branch (207:99): [Folded - Ignored] ------------------ 208| 3.26k| } _ZN4GFWX14unsignedDecodeILi81EEEjRNS_4BitsE: 204| 2.98k| { 205| 2.98k| uint32_t x = stream.getZeros(12); 206| 2.98k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 2.98k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 2.92k, False: 61] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.98k| } _ZN4GFWX14unsignedDecodeILi85EEEjRNS_4BitsE: 204| 2.92k| { 205| 2.92k| uint32_t x = stream.getZeros(12); 206| 2.92k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 2.92k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 2.85k, False: 73] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.92k| } _ZN4GFWX14unsignedDecodeILi89EEEjRNS_4BitsE: 204| 2.85k| { 205| 2.85k| uint32_t x = stream.getZeros(12); 206| 2.85k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 2.85k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 2.32k, False: 532] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.85k| } _ZN4GFWX14unsignedDecodeILi93EEEjRNS_4BitsE: 204| 2.32k| { 205| 2.32k| uint32_t x = stream.getZeros(12); 206| 2.32k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 2.32k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.79k, False: 523] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.32k| } _ZN4GFWX14unsignedDecodeILi97EEEjRNS_4BitsE: 204| 1.79k| { 205| 1.79k| uint32_t x = stream.getZeros(12); 206| 1.79k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.79k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.59k, False: 201] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.79k| } _ZN4GFWX14unsignedDecodeILi101EEEjRNS_4BitsE: 204| 1.59k| { 205| 1.59k| uint32_t x = stream.getZeros(12); 206| 1.59k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.59k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.20k, False: 389] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.59k| } _ZN4GFWX14unsignedDecodeILi105EEEjRNS_4BitsE: 204| 1.20k| { 205| 1.20k| uint32_t x = stream.getZeros(12); 206| 1.20k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.20k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.14k, False: 62] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.20k| } _ZN4GFWX14unsignedDecodeILi109EEEjRNS_4BitsE: 204| 1.14k| { 205| 1.14k| uint32_t x = stream.getZeros(12); 206| 1.14k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.14k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 0, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.14k| } _ZN4GFWX14unsignedDecodeILi3EEEjRNS_4BitsE: 204| 20.3k| { 205| 20.3k| uint32_t x = stream.getZeros(12); 206| 20.3k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 20.3k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 170, False: 20.2k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 20.3k| } _ZN4GFWX14unsignedDecodeILi7EEEjRNS_4BitsE: 204| 170| { 205| 170| uint32_t x = stream.getZeros(12); 206| 170| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 170| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 128, False: 42] | Branch (207:99): [Folded - Ignored] ------------------ 208| 170| } _ZN4GFWX14unsignedDecodeILi11EEEjRNS_4BitsE: 204| 128| { 205| 128| uint32_t x = stream.getZeros(12); 206| 128| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 128| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 103, False: 25] | Branch (207:99): [Folded - Ignored] ------------------ 208| 128| } _ZN4GFWX14unsignedDecodeILi15EEEjRNS_4BitsE: 204| 103| { 205| 103| uint32_t x = stream.getZeros(12); 206| 103| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 103| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 95, False: 8] | Branch (207:99): [Folded - Ignored] ------------------ 208| 103| } _ZN4GFWX14unsignedDecodeILi19EEEjRNS_4BitsE: 204| 95| { 205| 95| uint32_t x = stream.getZeros(12); 206| 95| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 95| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 91, False: 4] | Branch (207:99): [Folded - Ignored] ------------------ 208| 95| } _ZN4GFWX14unsignedDecodeILi23EEEjRNS_4BitsE: 204| 91| { 205| 91| uint32_t x = stream.getZeros(12); 206| 91| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 91| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 88, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 91| } _ZN4GFWX14unsignedDecodeILi27EEEjRNS_4BitsE: 204| 88| { 205| 88| uint32_t x = stream.getZeros(12); 206| 88| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 88| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 87, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 88| } _ZN4GFWX14unsignedDecodeILi31EEEjRNS_4BitsE: 204| 87| { 205| 87| uint32_t x = stream.getZeros(12); 206| 87| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 87| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 87, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 87| } _ZN4GFWX14unsignedDecodeILi35EEEjRNS_4BitsE: 204| 87| { 205| 87| uint32_t x = stream.getZeros(12); 206| 87| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 87| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 79, False: 8] | Branch (207:99): [Folded - Ignored] ------------------ 208| 87| } _ZN4GFWX14unsignedDecodeILi39EEEjRNS_4BitsE: 204| 79| { 205| 79| uint32_t x = stream.getZeros(12); 206| 79| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 79| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 79, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 79| } _ZN4GFWX14unsignedDecodeILi43EEEjRNS_4BitsE: 204| 79| { 205| 79| uint32_t x = stream.getZeros(12); 206| 79| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 79| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 74, False: 5] | Branch (207:99): [Folded - Ignored] ------------------ 208| 79| } _ZN4GFWX14unsignedDecodeILi47EEEjRNS_4BitsE: 204| 74| { 205| 74| uint32_t x = stream.getZeros(12); 206| 74| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 74| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 72, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 74| } _ZN4GFWX14unsignedDecodeILi51EEEjRNS_4BitsE: 204| 72| { 205| 72| uint32_t x = stream.getZeros(12); 206| 72| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 72| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 71, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 72| } _ZN4GFWX14unsignedDecodeILi55EEEjRNS_4BitsE: 204| 71| { 205| 71| uint32_t x = stream.getZeros(12); 206| 71| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 71| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 70, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 71| } _ZN4GFWX14unsignedDecodeILi59EEEjRNS_4BitsE: 204| 70| { 205| 70| uint32_t x = stream.getZeros(12); 206| 70| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 70| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 70, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 70| } _ZN4GFWX14unsignedDecodeILi63EEEjRNS_4BitsE: 204| 70| { 205| 70| uint32_t x = stream.getZeros(12); 206| 70| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 70| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 62, False: 8] | Branch (207:99): [Folded - Ignored] ------------------ 208| 70| } _ZN4GFWX14unsignedDecodeILi67EEEjRNS_4BitsE: 204| 62| { 205| 62| uint32_t x = stream.getZeros(12); 206| 62| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 62| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 62, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 62| } _ZN4GFWX14unsignedDecodeILi71EEEjRNS_4BitsE: 204| 62| { 205| 62| uint32_t x = stream.getZeros(12); 206| 62| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 62| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 57, False: 5] | Branch (207:99): [Folded - Ignored] ------------------ 208| 62| } _ZN4GFWX14unsignedDecodeILi75EEEjRNS_4BitsE: 204| 57| { 205| 57| uint32_t x = stream.getZeros(12); 206| 57| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 57| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 57, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 57| } _ZN4GFWX14unsignedDecodeILi79EEEjRNS_4BitsE: 204| 57| { 205| 57| uint32_t x = stream.getZeros(12); 206| 57| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 57| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 55, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 57| } _ZN4GFWX14unsignedDecodeILi83EEEjRNS_4BitsE: 204| 55| { 205| 55| uint32_t x = stream.getZeros(12); 206| 55| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 55| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 55, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 55| } _ZN4GFWX14unsignedDecodeILi87EEEjRNS_4BitsE: 204| 55| { 205| 55| uint32_t x = stream.getZeros(12); 206| 55| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 55| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 55, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 55| } _ZN4GFWX14unsignedDecodeILi91EEEjRNS_4BitsE: 204| 55| { 205| 55| uint32_t x = stream.getZeros(12); 206| 55| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 55| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 53, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 55| } _ZN4GFWX14unsignedDecodeILi95EEEjRNS_4BitsE: 204| 53| { 205| 53| uint32_t x = stream.getZeros(12); 206| 53| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 53| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 53, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 53| } _ZN4GFWX14unsignedDecodeILi99EEEjRNS_4BitsE: 204| 53| { 205| 53| uint32_t x = stream.getZeros(12); 206| 53| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 53| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 53, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 53| } _ZN4GFWX14unsignedDecodeILi103EEEjRNS_4BitsE: 204| 53| { 205| 53| uint32_t x = stream.getZeros(12); 206| 53| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 53| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 53, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 53| } _ZN4GFWX14unsignedDecodeILi107EEEjRNS_4BitsE: 204| 53| { 205| 53| uint32_t x = stream.getZeros(12); 206| 53| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 53| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 53, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 53| } _ZN4GFWX14unsignedDecodeILi111EEEjRNS_4BitsE: 204| 53| { 205| 53| uint32_t x = stream.getZeros(12); 206| 53| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 53| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 0, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 53| } _ZN4GFWX14unsignedDecodeILi4EEEjRNS_4BitsE: 204| 61.3k| { 205| 61.3k| uint32_t x = stream.getZeros(12); 206| 61.3k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 61.3k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.82k, False: 59.5k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 61.3k| } _ZN4GFWX14unsignedDecodeILi8EEEjRNS_4BitsE: 204| 1.82k| { 205| 1.82k| uint32_t x = stream.getZeros(12); 206| 1.82k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.82k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.40k, False: 416] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.82k| } _ZN4GFWX14unsignedDecodeILi12EEEjRNS_4BitsE: 204| 1.40k| { 205| 1.40k| uint32_t x = stream.getZeros(12); 206| 1.40k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.40k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.24k, False: 164] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.40k| } _ZN4GFWX14unsignedDecodeILi16EEEjRNS_4BitsE: 204| 1.24k| { 205| 1.24k| uint32_t x = stream.getZeros(12); 206| 1.24k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.24k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.19k, False: 45] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.24k| } _ZN4GFWX14unsignedDecodeILi20EEEjRNS_4BitsE: 204| 1.19k| { 205| 1.19k| uint32_t x = stream.getZeros(12); 206| 1.19k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.19k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.15k, False: 45] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.19k| } _ZN4GFWX14unsignedDecodeILi24EEEjRNS_4BitsE: 204| 1.15k| { 205| 1.15k| uint32_t x = stream.getZeros(12); 206| 1.15k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.15k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.12k, False: 24] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.15k| } _ZN4GFWX14unsignedDecodeILi28EEEjRNS_4BitsE: 204| 1.12k| { 205| 1.12k| uint32_t x = stream.getZeros(12); 206| 1.12k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.12k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.10k, False: 19] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.12k| } _ZN4GFWX14unsignedDecodeILi32EEEjRNS_4BitsE: 204| 1.10k| { 205| 1.10k| uint32_t x = stream.getZeros(12); 206| 1.10k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.10k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.10k, False: 4] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.10k| } _ZN4GFWX14unsignedDecodeILi36EEEjRNS_4BitsE: 204| 1.10k| { 205| 1.10k| uint32_t x = stream.getZeros(12); 206| 1.10k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.10k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.08k, False: 24] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.10k| } _ZN4GFWX14unsignedDecodeILi40EEEjRNS_4BitsE: 204| 1.08k| { 205| 1.08k| uint32_t x = stream.getZeros(12); 206| 1.08k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.08k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.04k, False: 31] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.08k| } _ZN4GFWX14unsignedDecodeILi44EEEjRNS_4BitsE: 204| 1.04k| { 205| 1.04k| uint32_t x = stream.getZeros(12); 206| 1.04k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.04k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.03k, False: 19] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.04k| } _ZN4GFWX14unsignedDecodeILi48EEEjRNS_4BitsE: 204| 1.03k| { 205| 1.03k| uint32_t x = stream.getZeros(12); 206| 1.03k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.03k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 1.00k, False: 30] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.03k| } _ZN4GFWX14unsignedDecodeILi52EEEjRNS_4BitsE: 204| 1.00k| { 205| 1.00k| uint32_t x = stream.getZeros(12); 206| 1.00k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 1.00k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 992, False: 8] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.00k| } _ZN4GFWX14unsignedDecodeILi56EEEjRNS_4BitsE: 204| 992| { 205| 992| uint32_t x = stream.getZeros(12); 206| 992| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 992| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 979, False: 13] | Branch (207:99): [Folded - Ignored] ------------------ 208| 992| } _ZN4GFWX14unsignedDecodeILi60EEEjRNS_4BitsE: 204| 979| { 205| 979| uint32_t x = stream.getZeros(12); 206| 979| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 979| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 976, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 979| } _ZN4GFWX14unsignedDecodeILi64EEEjRNS_4BitsE: 204| 976| { 205| 976| uint32_t x = stream.getZeros(12); 206| 976| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 976| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 960, False: 16] | Branch (207:99): [Folded - Ignored] ------------------ 208| 976| } _ZN4GFWX14unsignedDecodeILi68EEEjRNS_4BitsE: 204| 960| { 205| 960| uint32_t x = stream.getZeros(12); 206| 960| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 960| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 848, False: 112] | Branch (207:99): [Folded - Ignored] ------------------ 208| 960| } _ZN4GFWX14unsignedDecodeILi72EEEjRNS_4BitsE: 204| 848| { 205| 848| uint32_t x = stream.getZeros(12); 206| 848| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 848| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 842, False: 6] | Branch (207:99): [Folded - Ignored] ------------------ 208| 848| } _ZN4GFWX14unsignedDecodeILi76EEEjRNS_4BitsE: 204| 842| { 205| 842| uint32_t x = stream.getZeros(12); 206| 842| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 842| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 837, False: 5] | Branch (207:99): [Folded - Ignored] ------------------ 208| 842| } _ZN4GFWX14unsignedDecodeILi80EEEjRNS_4BitsE: 204| 837| { 205| 837| uint32_t x = stream.getZeros(12); 206| 837| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 837| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 822, False: 15] | Branch (207:99): [Folded - Ignored] ------------------ 208| 837| } _ZN4GFWX14unsignedDecodeILi84EEEjRNS_4BitsE: 204| 822| { 205| 822| uint32_t x = stream.getZeros(12); 206| 822| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 822| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 807, False: 15] | Branch (207:99): [Folded - Ignored] ------------------ 208| 822| } _ZN4GFWX14unsignedDecodeILi88EEEjRNS_4BitsE: 204| 807| { 205| 807| uint32_t x = stream.getZeros(12); 206| 807| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 807| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 801, False: 6] | Branch (207:99): [Folded - Ignored] ------------------ 208| 807| } _ZN4GFWX14unsignedDecodeILi92EEEjRNS_4BitsE: 204| 801| { 205| 801| uint32_t x = stream.getZeros(12); 206| 801| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 801| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 783, False: 18] | Branch (207:99): [Folded - Ignored] ------------------ 208| 801| } _ZN4GFWX14unsignedDecodeILi96EEEjRNS_4BitsE: 204| 783| { 205| 783| uint32_t x = stream.getZeros(12); 206| 783| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 783| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 781, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 783| } _ZN4GFWX14unsignedDecodeILi100EEEjRNS_4BitsE: 204| 781| { 205| 781| uint32_t x = stream.getZeros(12); 206| 781| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 781| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 753, False: 28] | Branch (207:99): [Folded - Ignored] ------------------ 208| 781| } _ZN4GFWX14unsignedDecodeILi104EEEjRNS_4BitsE: 204| 753| { 205| 753| uint32_t x = stream.getZeros(12); 206| 753| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 753| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 713, False: 40] | Branch (207:99): [Folded - Ignored] ------------------ 208| 753| } _ZN4GFWX14unsignedDecodeILi108EEEjRNS_4BitsE: 204| 713| { 205| 713| uint32_t x = stream.getZeros(12); 206| 713| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 713| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 0, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 713| } _ZN4GFWX17interleavedDecodeILi1EEEiRNS_4BitsE: 216| 60.4k| { 217| 60.4k| int const x = unsignedDecode(stream); 218| 60.4k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 37.3k, False: 23.0k] ------------------ 219| 60.4k| } _ZN4GFWX10getContextIsEENSt3__14pairIjjEERNS_5ImageIT_EEiiiiiii: 440| 142k| { 441| 142k| int px = x0 + (x & ~(skip * 2)) + (x & skip); 442| 142k| if (px >= x1) ------------------ | Branch (442:7): [True: 37, False: 142k] ------------------ 443| 37| px -= skip * 2; 444| 142k| int py = y0 + (y & ~(skip * 2)) + (y & skip); 445| 142k| if (py >= y1) ------------------ | Branch (445:7): [True: 149, False: 142k] ------------------ 446| 149| py -= skip * 2; 447| 142k| uint32_t count = 0, sum = 0, sum2 = 0; 448| 142k| addContext(abs(image[py][px]), 2, sum, sum2, count); // ancestor 449| 142k| if ((y & skip) && (x | skip) < x1 - x0) ------------------ | Branch (449:7): [True: 91.8k, False: 50.6k] | Branch (449:21): [True: 91.7k, False: 29] ------------------ 450| 91.7k| { 451| 91.7k| addContext(image[y0 + y - skip][x0 + (x | skip)], 2, sum, sum2, count); // upper sibling 452| 91.7k| if (x & skip) ------------------ | Branch (452:8): [True: 45.9k, False: 45.8k] ------------------ 453| 45.9k| addContext(image[y0 + y][x0 + x - skip], 2, sum, sum2, count); // left sibling 454| 91.7k| } 455| 142k| if (y >= skip * 2 && x >= skip * 2) // neighbors ------------------ | Branch (455:7): [True: 129k, False: 12.6k] | Branch (455:24): [True: 129k, False: 156] ------------------ 456| 129k| { 457| 129k| addContext(image[y0 + y - skip * 2][x0 + x], 4, sum, sum2, count); 458| 129k| addContext(image[y0 + y][x0 + x - skip * 2], 4, sum, sum2, count); 459| 129k| addContext(image[y0 + y - skip * 2][x0 + x - skip * 2], 2, sum, sum2, count); 460| 129k| if (x + skip * 2 < x1 - x0) ------------------ | Branch (460:8): [True: 129k, False: 162] ------------------ 461| 129k| addContext(image[y0 + y - skip * 2][x0 + x + skip * 2], 2, sum, sum2, count); 462| 129k| if (y >= skip * 4 && x >= skip * 4) ------------------ | Branch (462:8): [True: 117k, False: 12.5k] | Branch (462:25): [True: 116k, False: 124] ------------------ 463| 116k| { 464| 116k| addContext(image[y0 + y - skip * 4][x0 + x], 2, sum, sum2, count); 465| 116k| addContext(image[y0 + y][x0 + x - skip * 4], 2, sum, sum2, count); 466| 116k| addContext(image[y0 + y - skip * 4][x0 + x - skip * 4], 1, sum, sum2, count); 467| 116k| if (x + skip * 4 < x1 - x0) ------------------ | Branch (467:9): [True: 116k, False: 284] ------------------ 468| 116k| addContext(image[y0 + y - skip * 4][x0 + x + skip * 4], 1, sum, sum2, count); 469| 116k| } 470| 129k| } 471| 142k| return std::make_pair((sum * 16u + count / 2u) / count, (sum2 * 16u + count / 2u) / count); // set sums relative to 16 count 472| 142k| } _ZN4GFWX10addContextEiiRjS0_S0_: 433| 1.26M| { 434| 1.26M| sum += uint32_t(x = abs(x)) * w; 435| 1.26M| sum2 += square(std::min(uint32_t(x), 4096u)) * w; // [MAGIC] avoid overflow in last line of getContext 436| 1.26M| count += w; 437| 1.26M| } _ZN4GFWX6squareIjEET_S1_: 428| 1.40M| { 429| 1.40M| return t * t; 430| 1.40M| } _ZN4GFWX17interleavedDecodeILi0EEEiRNS_4BitsE: 216| 54.0k| { 217| 54.0k| int const x = unsignedDecode(stream); 218| 54.0k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 44.2k, False: 9.86k] ------------------ 219| 54.0k| } _ZN4GFWX14unsignedDecodeILi0EEEjRNS_4BitsE: 204| 54.0k| { 205| 54.0k| uint32_t x = stream.getZeros(12); 206| 54.0k| int const p = pot < 24 ? pot : 24; // actual pot. The max 108 below is to prevent unlimited recursion in malformed files, yet admit 2^32 - 1. ------------------ | Branch (206:19): [Folded - Ignored] ------------------ 207| 54.0k| return (pot < 108 && x == 12) ? (12 << p) + unsignedDecode(stream) : p ? (x << p) + stream.getBits(p) : x; ------------------ | Branch (207:11): [Folded - Ignored] | Branch (207:24): [True: 188, False: 53.8k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 54.0k| } _ZN4GFWX12signedDecodeILi1EEEiRNS_4BitsE: 229| 4.26k| { 230| 4.26k| int x = unsignedDecode(stream); 231| 4.26k| return x ? stream.getBits(1) ? x : -x : 0; ------------------ | Branch (231:10): [True: 3.32k, False: 942] | Branch (231:14): [True: 1.60k, False: 1.72k] ------------------ 232| 4.26k| } _ZN4GFWX17interleavedDecodeILi2EEEiRNS_4BitsE: 216| 12.9k| { 217| 12.9k| int const x = unsignedDecode(stream); 218| 12.9k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 6.65k, False: 6.24k] ------------------ 219| 12.9k| } _ZN4GFWX17interleavedDecodeILi3EEEiRNS_4BitsE: 216| 10.9k| { 217| 10.9k| int const x = unsignedDecode(stream); 218| 10.9k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 7.78k, False: 3.18k] ------------------ 219| 10.9k| } _ZN4GFWX12signedDecodeILi3EEEiRNS_4BitsE: 229| 7.98k| { 230| 7.98k| int x = unsignedDecode(stream); 231| 7.98k| return x ? stream.getBits(1) ? x : -x : 0; ------------------ | Branch (231:10): [True: 7.61k, False: 376] | Branch (231:14): [True: 4.09k, False: 3.51k] ------------------ 232| 7.98k| } _ZN4GFWX17interleavedDecodeILi4EEEiRNS_4BitsE: 216| 4.77k| { 217| 4.77k| int const x = unsignedDecode(stream); 218| 4.77k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 2.66k, False: 2.11k] ------------------ 219| 4.77k| } _ZN4GFWX8quantizeIsLb1EEEvRNS_5ImageIT_EEiiiiiiii: 405| 542| { 406| 542| typedef typename std::conditional::type aux; 407| 542| int const sizex = x1 - x0; 408| 542| int const sizey = y1 - y0; 409| 542| int skip = step; 410| 1.30k| while (skip < sizex && skip < sizey) ------------------ | Branch (410:10): [True: 1.29k, False: 11] | Branch (410:26): [True: 917, False: 375] ------------------ 411| 917| { 412| 917| int const q = std::max(std::max(1, minQ), quality); 413| 917| if (q >= maxQ) break; ------------------ | Branch (413:8): [True: 156, False: 761] ------------------ 414| 761| OMP_PARALLEL_FOR(ThreadIterations) 415| 28.9k| for (int y = 0; y < sizey; y += skip) ------------------ | Branch (415:20): [True: 28.2k, False: 761] ------------------ 416| 28.2k| { 417| 28.2k| T * base = &image[y0 + y][x0]; 418| 28.2k| int const xStep = (y & skip) ? skip : skip * 2; ------------------ | Branch (418:23): [True: 13.8k, False: 14.3k] ------------------ 419| 2.83M| for (int x = xStep - skip; x < sizex; x += xStep) // [NOTE] arranged so that (x | y) & skip == 1 ------------------ | Branch (419:32): [True: 2.80M, False: 28.2k] ------------------ 420| 2.80M| base[x] = dequantize ? (aux(base[x]) * maxQ + (base[x] < 0 ? -maxQ / 2 : base[x] > 0 ? maxQ / 2 : 0)) / q : aux(base[x]) * q / maxQ; ------------------ | Branch (420:16): [Folded - Ignored] | Branch (420:53): [True: 33.8k, False: 2.77M] | Branch (420:79): [True: 35.8k, False: 2.73M] ------------------ 421| 28.2k| } 422| 761| skip *= 2; 423| 761| quality = std::min(maxQ, quality * 2); // [MAGIC] This approximates the JPEG 2000 baseline quantizer 424| 761| } 425| 542| } _ZN4GFWX6unliftIsEEvRNS_5ImageIT_EEiiiiii: 326| 542| { 327| 542| int const sizex = x1 - x0; 328| 542| int const sizey = y1 - y0; 329| 542| int step = minStep; 330| 4.38k| while (step * 2 < sizex || step * 2 < sizey) ------------------ | Branch (330:10): [True: 3.81k, False: 572] | Branch (330:30): [True: 30, False: 542] ------------------ 331| 3.84k| step *= 2; 332| 4.92k| while (step >= minStep) ------------------ | Branch (332:10): [True: 4.38k, False: 542] ------------------ 333| 4.38k| { 334| 4.38k| if (step < sizey) // vertical unlifting ------------------ | Branch (334:8): [True: 1.12k, False: 3.26k] ------------------ 335| 1.12k| { 336| 1.12k| OMP_PARALLEL_FOR(ThreadIterations) 337| 15.1k| for (int y = step * 2; y < sizey; y += step * 2) ------------------ | Branch (337:28): [True: 14.0k, False: 1.12k] ------------------ 338| 14.0k| { 339| 14.0k| T * const base = &image[y0 + y][x0]; 340| 14.0k| T const * const g1base = &image[y0 + y - step][x0], * const g2base = y + step < sizey ? &image[y0 + y + step][x0] : g1base; ------------------ | Branch (340:75): [True: 13.4k, False: 520] ------------------ 341| 14.0k| if (filter == FilterCubic) ------------------ | Branch (341:10): [True: 5.62k, False: 8.38k] ------------------ 342| 5.62k| { 343| 5.62k| T const * const g0base = y - step * 3 >= 0 ? &image[y0 + y - step * 3][x0] : g1base; ------------------ | Branch (343:32): [True: 5.50k, False: 120] ------------------ 344| 5.62k| T const * const g3base = y + step * 3 < sizey ? &image[y0 + y + step * 3][x0] : g2base; ------------------ | Branch (344:32): [True: 5.49k, False: 135] ------------------ 345| 425k| for (int x = 0; x < sizex; x += step) ------------------ | Branch (345:23): [True: 419k, False: 5.62k] ------------------ 346| 419k| base[x] -= cubic(g0base[x], g1base[x], g2base[x], g3base[x]) / 2; 347| 5.62k| } 348| 1.39M| else for (int x = 0; x < sizex; x += step) ------------------ | Branch (348:27): [True: 1.39M, False: 8.38k] ------------------ 349| 1.39M| base[x] -= (g1base[x] + g2base[x]) / 4; 350| 14.0k| } 351| 1.12k| OMP_PARALLEL_FOR(ThreadIterations) 352| 15.7k| for (int y = step; y < sizey; y += step * 2) ------------------ | Branch (352:24): [True: 14.6k, False: 1.12k] ------------------ 353| 14.6k| { 354| 14.6k| T * const base = &image[y0 + y][x0]; 355| 14.6k| T const * const c1base = &image[y0 + y - step][x0], * const c2base = y + step < sizey ? &image[y0 + y + step][x0] : c1base; ------------------ | Branch (355:75): [True: 14.0k, False: 601] ------------------ 356| 14.6k| if (filter == FilterCubic) ------------------ | Branch (356:10): [True: 5.73k, False: 8.88k] ------------------ 357| 5.73k| { 358| 5.73k| T const * const c0base = y - step * 3 >= 0 ? &image[y0 + y - step * 3][x0] : c1base; ------------------ | Branch (358:32): [True: 5.59k, False: 135] ------------------ 359| 5.73k| T const * const c3base = y + step * 3 < sizey ? &image[y0 + y + step * 3][x0] : c2base; ------------------ | Branch (359:32): [True: 5.50k, False: 225] ------------------ 360| 427k| for (int x = 0; x < sizex; x += step) ------------------ | Branch (360:23): [True: 421k, False: 5.73k] ------------------ 361| 421k| base[x] += cubic(c0base[x], c1base[x], c2base[x], c3base[x]); 362| 5.73k| } 363| 1.45M| else for (int x = 0; x < sizex; x += step) ------------------ | Branch (363:27): [True: 1.45M, False: 8.88k] ------------------ 364| 1.45M| base[x] += (c1base[x] + c2base[x]) / 2; 365| 14.6k| } 366| 1.12k| } 367| 4.38k| if (step < sizex) // horizontal unlifting ------------------ | Branch (367:8): [True: 4.35k, False: 30] ------------------ 368| 4.35k| { 369| 4.35k| OMP_PARALLEL_FOR(ThreadIterations) 370| 36.6k| for (int y = 0; y < sizey; y += step) ------------------ | Branch (370:21): [True: 32.3k, False: 4.35k] ------------------ 371| 32.3k| { 372| 32.3k| int x; 373| 32.3k| T * base = &image[y0 + y][x0], * base1 = base - step, * base2 = base + step, * base3 = base + step * 3; 374| 32.3k| if (filter == FilterCubic) ------------------ | Branch (374:10): [True: 11.4k, False: 20.9k] ------------------ 375| 11.4k| { 376| 11.4k| T g0 = base[step], g1 = base[step], g2 = step * 3 < sizex ? base[step * 3] : base[step], g3; ------------------ | Branch (376:48): [True: 11.3k, False: 90] ------------------ 377| 409k| for (x = step * 2; x < sizex - step * 3; x += step * 2, g0 = g1, g1 = g2, g2 = g3) ------------------ | Branch (377:26): [True: 397k, False: 11.4k] ------------------ 378| 397k| base[x] -= cubic(g0, g1, g2, g3 = base3[x]) / 2; 379| 25.9k| for (; x < sizex; x += step * 2, g0 = g1, g1 = g2) ------------------ | Branch (379:14): [True: 14.5k, False: 11.4k] ------------------ 380| 14.5k| base[x] -= cubic(g0, g1, g2, g2) / 2; 381| 11.4k| T c0 = *base, c1 = *base, c2 = step * 2 < sizex ? base[step * 2] : *base, c3; ------------------ | Branch (381:38): [True: 11.3k, False: 90] ------------------ 382| 412k| for (x = step; x < sizex - step * 3; x += step * 2, c0 = c1, c1 = c2, c2 = c3) ------------------ | Branch (382:22): [True: 400k, False: 11.4k] ------------------ 383| 400k| base[x] += cubic(c0, c1, c2, c3 = base3[x]); 384| 30.9k| for (; x < sizex; x += step * 2, c0 = c1, c1 = c2) ------------------ | Branch (384:14): [True: 19.5k, False: 11.4k] ------------------ 385| 19.5k| base[x] += cubic(c0, c1, c2, c2); 386| 11.4k| } 387| 20.9k| else 388| 20.9k| { 389| 1.56M| for (x = step * 2; x < sizex - step; x += step * 2) ------------------ | Branch (389:26): [True: 1.54M, False: 20.9k] ------------------ 390| 1.54M| base[x] -= (base1[x] + base2[x]) / 4; 391| 20.9k| if (x < sizex) ------------------ | Branch (391:11): [True: 15.2k, False: 5.63k] ------------------ 392| 15.2k| base[x] -= base1[x] / 2; 393| 1.58M| for (x = step; x < sizex - step; x += step * 2) ------------------ | Branch (393:22): [True: 1.55M, False: 20.9k] ------------------ 394| 1.55M| base[x] += (base1[x] + base2[x]) / 2; 395| 20.9k| if (x < sizex) ------------------ | Branch (395:11): [True: 5.63k, False: 15.2k] ------------------ 396| 5.63k| base[x] += base1[x]; 397| 20.9k| } 398| 32.3k| } 399| 4.35k| } 400| 4.38k| step /= 2; 401| 4.38k| } 402| 542| } _ZN4GFWX5cubicIsEET_S1_S1_S1_S1_: 245| 1.67M| { 246| 1.67M| return median(T(roundFraction((-c0 + 9 * (c1 + c2) - c3), 16)), c1, c2); 247| 1.67M| } _ZN4GFWX6medianIsEET_S1_S1_S1_: 235| 1.67M| { 236| 1.67M| return a < b ? c > b ? b : c < a ? a : c : c > a ? a : c < b ? b : c; ------------------ | Branch (236:10): [True: 0, False: 1.67M] | Branch (236:18): [True: 0, False: 0] | Branch (236:30): [True: 0, False: 0] | Branch (236:46): [True: 0, False: 1.67M] | Branch (236:58): [True: 0, False: 1.67M] ------------------ 237| 1.67M| } _ZN4GFWX13roundFractionIiEET_S1_S1_: 240| 1.67M| { 241| 1.67M| return num < 0 ? (num - denom / 2) / denom : (num + denom / 2) / denom; ------------------ | Branch (241:10): [True: 0, False: 1.67M] ------------------ 242| 1.67M| } _ZN4GFWX13transformTermIPhsEEvRPKiPT0_PKS5_iRKT_RKNS_6HeaderERKNSt3__16vectorIiNSF_9allocatorIiEEEEi: 646| 707k| { 647| 1.79M| while (*pc >= 0) ------------------ | Branch (647:10): [True: 1.09M, False: 707k] ------------------ 648| 1.09M| { 649| 1.09M| int const c = *(pc ++); 650| 1.09M| A const factor = *(pc ++); 651| 1.09M| if (isChroma[c] == -1) ------------------ | Branch (651:8): [True: 299k, False: 790k] ------------------ 652| 299k| { 653| 299k| auto layer = imageData + ((c / header.channels) * bufferSize * header.channels + c % header.channels); 654| 299k| A const boostFactor = boost * factor; 655| 299k| OMP_PARALLEL_FOR(ThreadIterations * ThreadIterations) 656| 2.93G| for (int i = 0; i < bufferSize; ++ i) ------------------ | Branch (656:21): [True: 2.93G, False: 299k] ------------------ 657| 2.93G| destination[i] += layer[i * header.channels] * boostFactor; 658| 299k| } 659| 790k| else 660| 790k| { 661| 790k| A const * auxDataC = auxData + c * bufferSize; 662| 790k| OMP_PARALLEL_FOR(ThreadIterations * ThreadIterations) 663| 5.71G| for (int i = 0; i < bufferSize; ++ i) ------------------ | Branch (663:21): [True: 5.71G, False: 790k] ------------------ 664| 5.71G| destination[i] += auxDataC[i] * factor; 665| 790k| } 666| 1.09M| } 667| 707k| A const denom = *((++ pc) ++); 668| 707k| if (denom == 2) ------------------ | Branch (668:7): [True: 95, False: 707k] ------------------ 669| 95| shiftVector(destination, 1, bufferSize); 670| 707k| else if (denom == 4) ------------------ | Branch (670:12): [True: 74, False: 707k] ------------------ 671| 74| shiftVector(destination, 2, bufferSize); 672| 707k| else if (denom == 8) ------------------ | Branch (672:12): [True: 0, False: 707k] ------------------ 673| 0| shiftVector(destination, 3, bufferSize); 674| 707k| else if (denom > 1) // [NOTE] disallow non-positive denominators ------------------ | Branch (674:12): [True: 457k, False: 249k] ------------------ 675| 457k| { 676| 457k| OMP_PARALLEL_FOR(ThreadIterations * ThreadIterations) 677| 1.86G| for (int i = 0; i < bufferSize; ++ i) ------------------ | Branch (677:20): [True: 1.86G, False: 457k] ------------------ 678| 1.86G| destination[i] /= denom; 679| 457k| } 680| 707k| } _ZN4GFWX11shiftVectorIsEEvPT_ii: 638| 169| { 639| 169| OMP_PARALLEL_FOR(ThreadIterations * ThreadIterations) 640| 1.27M| for (int i = 0; i < count; ++ i) ------------------ | Branch (640:19): [True: 1.27M, False: 169] ------------------ 641| 1.27M| data[i] >>= shift; 642| 169| } _ZN4GFWX5ImageIsEixEi: 99| 1.43M| T * operator[] (int y) { return data + static_cast(y) * sizex; }