LLVMFuzzerTestOneInput: 11| 15|{ 12| 15| GFWX::Header header; 13| | 14| 15| { 15| 15| ptrdiff_t result = GFWX::decompress((uint8_t*)0, header, data, size, 0, true); 16| 15| if (result != GFWX::ResultOk) { ------------------ | Branch (16:13): [True: 4, False: 11] ------------------ 17| 4| return 0; 18| 4| } 19| 15| } 20| | 21| 11| if ( header.bitDepth > 32 ) { ------------------ | Branch (21:10): [True: 0, False: 11] ------------------ 22| 0| return 0; 23| 0| } 24| 11| if ( header.channels > 10 ) { ------------------ | Branch (24:10): [True: 0, False: 11] ------------------ 25| 0| return 0; 26| 0| } 27| 11| if ( header.layers > 10 ) { ------------------ | Branch (27:10): [True: 0, False: 11] ------------------ 28| 0| return 0; 29| 0| } 30| 11| if ( header.sizex > 10240 ) { ------------------ | Branch (30:10): [True: 0, False: 11] ------------------ 31| 0| return 0; 32| 0| } 33| 11| if ( header.sizey > 10240 ) { ------------------ | Branch (33:10): [True: 0, False: 11] ------------------ 34| 0| return 0; 35| 0| } 36| | 37| 11| { 38| 11| const size_t totalOutSize = (header.bitDepth / 8) * header.channels * header.layers * header.sizex * header.sizey; 39| 11| if ( totalOutSize > (1024*1024) ) { ------------------ | Branch (39:14): [True: 0, False: 11] ------------------ 40| 0| return 0; 41| 0| } 42| 11| std::vector out(totalOutSize); 43| 11| ptrdiff_t result = GFWX::decompress(out.data(), header, data, size, 0, false); 44| 11| if (result != GFWX::ResultOk) { ------------------ | Branch (44:13): [True: 10, False: 1] ------------------ 45| 10| return 0; 46| 10| } 47| 1| fuzzing::memory::memory_test(out); 48| 1| } 49| | 50| 0| return 0; 51| 11|} _ZN7fuzzing6memory11memory_testINSt3__16vectorIhNS2_9allocatorIhEEEEEEvRKT_: 53| 1|{ 54| 1| (void)t; 55| 1|} _ZN4GFWX6HeaderC2Ev: 80| 15| Header() {} _ZN4GFWX10decompressIPhEElRKT_RNS_6HeaderEPKhmib: 807| 26| { 808| 26| typedef typename std::remove_reference::type base; 809| 26| typedef typename std::conditional::type aux; 810| 26| Bits stream(reinterpret_cast(const_cast(data)), reinterpret_cast(const_cast(data)) + size / 4); 811| 26| if (size < 28) // at least load the header ------------------ | Branch (811:7): [True: 0, False: 26] ------------------ 812| 0| return 28; 813| 26| if (stream.getBits(32) != uint32_t('G' | ('F' << 8) | ('W' << 16) | ('X' << 24))) ------------------ | Branch (813:7): [True: 3, False: 23] ------------------ 814| 3| return ErrorMalformed; 815| 23| header.version = stream.getBits(32); 816| 23| header.sizex = stream.getBits(32); 817| 23| header.sizey = stream.getBits(32); 818| 23| header.layers = stream.getBits(16) + 1; 819| 23| header.channels = stream.getBits(16) + 1; 820| 23| header.bitDepth = stream.getBits(8) + 1; 821| 23| header.isSigned = stream.getBits(1); 822| 23| header.quality = stream.getBits(10) + 1; 823| 23| header.chromaScale = stream.getBits(8) + 1; 824| 23| header.blockSize = stream.getBits(5) + 2; 825| 23| header.filter = stream.getBits(8); 826| 23| header.quantization = stream.getBits(8); 827| 23| header.encoder = stream.getBits(8); 828| 23| header.intent = stream.getBits(8); 829| 23| if (header.sizex < 0 || header.sizex > (1 << 30) || header.sizey < 0 || header.sizey > (1 << 30) || header.bufferSize() == 0) ------------------ | Branch (829:9): [True: 0, False: 23] | Branch (829:29): [True: 0, False: 23] | Branch (829:57): [True: 0, False: 23] | Branch (829:77): [True: 0, False: 23] | Branch (829:105): [True: 1, False: 22] ------------------ 830| 1| return ErrorMalformed; // [NOTE] current implementation can't go over 2^30 831| 22| if (!imageData) // just header ------------------ | Branch (831:7): [True: 11, False: 11] ------------------ 832| 11| return ResultOk; 833| 11| if (header.isSigned != (std::numeric_limits::is_signed ? 1 : 0) || header.bitDepth > std::numeric_limits::digits) ------------------ | Branch (833:7): [True: 0, False: 11] | Branch (833:27): [Folded - Ignored] | Branch (833:76): [True: 0, False: 11] ------------------ 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| 11| if ((stream.buffer += stream.getBits(32)) >= stream.bufferEnd) // skip metadata ------------------ | Branch (836:7): [True: 0, False: 11] ------------------ 837| 0| return reinterpret_cast(stream.buffer) - data; // suggest point of interest to skip metadata 838| 11| int const sizexDown = (header.sizex + (1 << downsampling) - 1) >> downsampling, sizeyDown = (header.sizey + (1 << downsampling) - 1) >> downsampling; 839| 11| int const bufferSize = sizexDown * sizeyDown; 840| 11| std::vector auxData((size_t)header.layers * header.channels * bufferSize, 0); 841| 11| std::vector isChroma(header.layers * header.channels, 0), transformProgram, transformSteps; 842| 11| 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: 11, False: 707k] ------------------ 849| 11| 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| 11| stream.flushReadWord(); 867| 11| int const chromaQuality = std::max(1, (header.quality + header.chromaScale / 2) / header.chromaScale); 868| 11| 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: 1, False: 10] ------------------ 869| 11| bool isTruncated = false; 870| 11| int step = 1; 871| 101| while (step * 2 < header.sizex || step * 2 < header.sizey) ------------------ | Branch (871:10): [True: 88, False: 13] | Branch (871:37): [True: 2, False: 11] ------------------ 872| 90| step *= 2; 873| 53| for (bool hasDC = true; (step >> downsampling) >= 1; hasDC = false) // decode just enough coefficients for downsampled image ------------------ | Branch (873:27): [True: 51, False: 2] ------------------ 874| 51| { 875| 51| int64_t const bs = int64_t(step) << header.blockSize; 876| 51| int const blockCountX = int((header.sizex + bs - 1) / bs); 877| 51| int const blockCountY = int((header.sizey + bs - 1) / bs); 878| 51| int const blockCount = blockCountX * blockCountY * header.layers * header.channels; 879| 51| isTruncated = true; 880| 51| if (stream.buffer + 1 + blockCount > stream.bufferEnd) // check for enough buffer to read block sizes ------------------ | Branch (880:8): [True: 7, False: 44] ------------------ 881| 7| break; 882| 44| std::vector streamBlock(blockCount, Bits(0, 0)); 883| 182| for (int block = 0; block < blockCount; ++ block) // first, read sizes into bufferEnd pointers ------------------ | Branch (883:24): [True: 138, False: 44] ------------------ 884| 138| streamBlock[block].bufferEnd = static_cast(0) + *(stream.buffer ++); 885| 182| for (int block = 0; block < blockCount; ++ block) // then convert sizes to true buffer pointers ------------------ | Branch (885:24): [True: 138, False: 44] ------------------ 886| 138| streamBlock[block].bufferEnd = (streamBlock[block].buffer = block ? streamBlock[block - 1].bufferEnd : stream.buffer) ------------------ | Branch (886:65): [True: 94, False: 44] ------------------ 887| 138| + (streamBlock[block].bufferEnd - static_cast(0)); 888| 44| stream.buffer = streamBlock[blockCount - 1].bufferEnd; 889| 44| nextPointOfInterest = reinterpret_cast(stream.buffer + ((step >> downsampling) > 1 ? blockCount * 4 : 0)) - data; ------------------ | Branch (889:71): [True: 42, False: 2] ------------------ 890| 44| if (stream.buffer <= stream.bufferEnd) ------------------ | Branch (890:8): [True: 41, False: 3] ------------------ 891| 41| isTruncated = false; 892| 44| int const stepDown = step >> downsampling; 893| 44| int64_t const bsDown = int64_t(stepDown) << header.blockSize; 894| 44| OMP_PARALLEL_FOR(4) // [MAGIC] for some reason, 4 is by far the best option here 895| 182| for (int block = 0; block < blockCount; ++ block) if (!test && streamBlock[block].bufferEnd <= stream.bufferEnd) ------------------ | Branch (895:24): [True: 138, False: 44] | Branch (895:58): [True: 138, False: 0] | Branch (895:67): [True: 41, False: 97] ------------------ 896| 41| { 897| 41| int const bx = block % blockCountX, by = (block / blockCountX) % blockCountY, c = block / (blockCountX * blockCountY); 898| 41| Image auxImage(&auxData[c * bufferSize], sizexDown, sizeyDown); 899| 41| if (header.intent < IntentBayerRGGB || header.intent > IntentBayerGeneric) ------------------ | Branch (899:9): [True: 0, False: 41] | Branch (899:44): [True: 41, False: 0] ------------------ 900| 41| decode(auxImage, streamBlock[block], int(bx * bsDown), int(by * bsDown), 901| 41| int(std::min((bx + 1) * bsDown, int64_t(sizexDown))), int(std::min((by + 1) * bsDown, int64_t(sizeyDown))), 902| 41| stepDown, header.encoder, isChroma[c] ? chromaQuality : header.quality, hasDC && !bx && !by, isChroma[c] != 0); ------------------ | Branch (902:32): [True: 0, False: 41] | Branch (902:78): [True: 4, False: 37] | Branch (902:87): [True: 4, False: 0] | Branch (902:94): [True: 4, 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| 41| } 908| 180| 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: 138, False: 42] ------------------ 909| 138| if (streamBlock[block].indexBits < 0) ------------------ | Branch (909:9): [True: 2, False: 136] ------------------ 910| 2| return ErrorMalformed; 911| 42| step /= 2; 912| 42| } 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| 70| Bits(uint32_t * buffer, uint32_t * bufferEnd) : buffer(buffer), bufferEnd(bufferEnd), writeCache(0), indexBits(0) {} _ZN4GFWX4Bits7getBitsEi: 109| 9.80M| { 110| 9.80M| int newBits = indexBits + bits; 111| 9.80M| if (buffer == bufferEnd) ------------------ | Branch (111:8): [True: 63.4k, False: 9.73M] ------------------ 112| 63.4k| return indexBits = -1; // signify overflow 113| 9.73M| uint32_t x = *buffer << indexBits; 114| 9.73M| if (newBits >= 32) ------------------ | Branch (114:8): [True: 483k, False: 9.25M] ------------------ 115| 483k| { 116| 483k| ++ buffer; 117| 483k| if ((newBits -= 32) > 0) ------------------ | Branch (117:9): [True: 7.15k, False: 476k] ------------------ 118| 7.15k| { 119| 7.15k| if (buffer == bufferEnd) ------------------ | Branch (119:10): [True: 1, False: 7.15k] ------------------ 120| 1| return indexBits = -1; // signify overflow 121| 7.15k| x |= *buffer >> (32 - indexBits); 122| 7.15k| } 123| 483k| } 124| 9.73M| indexBits = newBits; 125| 9.73M| return x >> (32 - bits); 126| 9.73M| } _ZNK4GFWX6Header10bufferSizeEv: 87| 23| { 88| 23| size_t const part1 = static_cast(sizex) * sizey; 89| 23| size_t const part2 = static_cast(channels) * layers * ((bitDepth + 7) / 8); 90| 23| return std::log(part1) + std::log(part2) > std::log(std::numeric_limits::max() - 1) ? 0 : part1 * part2; ------------------ | Branch (90:14): [True: 0, False: 23] ------------------ 91| 23| } _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.00k, False: 5.03M] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.03M| } _ZN4GFWX4Bits8getZerosEj: 148| 5.33M| { 149| 5.33M| int newBits = indexBits; 150| 5.33M| if (buffer == bufferEnd) ------------------ | Branch (150:8): [True: 99.3k, False: 5.23M] ------------------ 151| 99.3k| return indexBits = -1; // signify overflow 152| 5.23M| uint32_t b = *buffer; 153| 5.23M| uint32_t x = 0; 154| 6.69M| while (true) ------------------ | Branch (154:11): [Folded - Ignored] ------------------ 155| 6.69M| { 156| 6.69M| if (newBits == 31) ------------------ | Branch (156:9): [True: 194k, False: 6.49M] ------------------ 157| 194k| { 158| 194k| ++ buffer; 159| 194k| if ((b & 1u) || (++ x == maxZeros)) ------------------ | Branch (159:10): [True: 147k, False: 47.2k] | Branch (159:22): [True: 7.43k, False: 39.7k] ------------------ 160| 155k| { 161| 155k| indexBits = 0; 162| 155k| return x; 163| 155k| } 164| 39.7k| if (buffer == bufferEnd) ------------------ | Branch (164:10): [True: 0, False: 39.7k] ------------------ 165| 0| return indexBits = -1; // signify overflow 166| 39.7k| b = *buffer; 167| 39.7k| newBits = 0; 168| 39.7k| continue; 169| 39.7k| } 170| 6.49M| if (((b << newBits) & (1u << 31)) || (++ x == maxZeros)) ------------------ | Branch (170:9): [True: 4.97M, False: 1.52M] | Branch (170:42): [True: 108k, False: 1.41M] ------------------ 171| 5.08M| { 172| 5.08M| indexBits = newBits + 1; 173| 5.08M| return x; 174| 5.08M| } 175| 1.41M| ++ newBits; 176| 1.41M| } 177| 5.23M| } _ZN4GFWX14unsignedDecodeILi6EEEjRNS_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: 956, False: 53] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.00k| } _ZN4GFWX14unsignedDecodeILi10EEEjRNS_4BitsE: 204| 956| { 205| 956| uint32_t x = stream.getZeros(12); 206| 956| 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| 956| 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: 926, False: 30] | Branch (207:99): [Folded - Ignored] ------------------ 208| 956| } _ZN4GFWX14unsignedDecodeILi14EEEjRNS_4BitsE: 204| 926| { 205| 926| uint32_t x = stream.getZeros(12); 206| 926| 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| 926| 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: 12] | Branch (207:99): [Folded - Ignored] ------------------ 208| 926| } _ZN4GFWX14unsignedDecodeILi18EEEjRNS_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: 911, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 914| } _ZN4GFWX14unsignedDecodeILi22EEEjRNS_4BitsE: 204| 911| { 205| 911| uint32_t x = stream.getZeros(12); 206| 911| 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| 911| 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: 909, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 911| } _ZN4GFWX14unsignedDecodeILi26EEEjRNS_4BitsE: 204| 909| { 205| 909| uint32_t x = stream.getZeros(12); 206| 909| 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| 909| 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: 907, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 909| } _ZN4GFWX14unsignedDecodeILi30EEEjRNS_4BitsE: 204| 907| { 205| 907| uint32_t x = stream.getZeros(12); 206| 907| 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| 907| 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: 907, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 907| } _ZN4GFWX14unsignedDecodeILi34EEEjRNS_4BitsE: 204| 907| { 205| 907| uint32_t x = stream.getZeros(12); 206| 907| 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| 907| 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: 6] | Branch (207:99): [Folded - Ignored] ------------------ 208| 907| } _ZN4GFWX14unsignedDecodeILi38EEEjRNS_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| } _ZN4GFWX14unsignedDecodeILi42EEEjRNS_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: 898, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 899| } _ZN4GFWX14unsignedDecodeILi46EEEjRNS_4BitsE: 204| 898| { 205| 898| uint32_t x = stream.getZeros(12); 206| 898| 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| 898| 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: 895, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 898| } _ZN4GFWX14unsignedDecodeILi50EEEjRNS_4BitsE: 204| 895| { 205| 895| uint32_t x = stream.getZeros(12); 206| 895| 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| 895| 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: 895, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 895| } _ZN4GFWX14unsignedDecodeILi54EEEjRNS_4BitsE: 204| 895| { 205| 895| uint32_t x = stream.getZeros(12); 206| 895| 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| 895| 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: 895, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 895| } _ZN4GFWX14unsignedDecodeILi58EEEjRNS_4BitsE: 204| 895| { 205| 895| uint32_t x = stream.getZeros(12); 206| 895| 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| 895| 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: 893, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 895| } _ZN4GFWX14unsignedDecodeILi62EEEjRNS_4BitsE: 204| 893| { 205| 893| uint32_t x = stream.getZeros(12); 206| 893| 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| 893| 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: 18] | Branch (207:99): [Folded - Ignored] ------------------ 208| 893| } _ZN4GFWX14unsignedDecodeILi66EEEjRNS_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: 874, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 875| } _ZN4GFWX14unsignedDecodeILi70EEEjRNS_4BitsE: 204| 874| { 205| 874| uint32_t x = stream.getZeros(12); 206| 874| 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| 874| 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: 871, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 874| } _ZN4GFWX14unsignedDecodeILi74EEEjRNS_4BitsE: 204| 871| { 205| 871| uint32_t x = stream.getZeros(12); 206| 871| 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| 871| 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: 871, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 871| } _ZN4GFWX14unsignedDecodeILi78EEEjRNS_4BitsE: 204| 871| { 205| 871| uint32_t x = stream.getZeros(12); 206| 871| 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| 871| 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: 871, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 871| } _ZN4GFWX14unsignedDecodeILi82EEEjRNS_4BitsE: 204| 871| { 205| 871| uint32_t x = stream.getZeros(12); 206| 871| 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| 871| 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: 869, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 871| } _ZN4GFWX14unsignedDecodeILi86EEEjRNS_4BitsE: 204| 869| { 205| 869| uint32_t x = stream.getZeros(12); 206| 869| 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| 869| 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: 869, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 869| } _ZN4GFWX14unsignedDecodeILi90EEEjRNS_4BitsE: 204| 869| { 205| 869| uint32_t x = stream.getZeros(12); 206| 869| 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| 869| 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: 6] | Branch (207:99): [Folded - Ignored] ------------------ 208| 869| } _ZN4GFWX14unsignedDecodeILi94EEEjRNS_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| } _ZN4GFWX14unsignedDecodeILi98EEEjRNS_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| } _ZN4GFWX14unsignedDecodeILi102EEEjRNS_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: 862, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 863| } _ZN4GFWX14unsignedDecodeILi106EEEjRNS_4BitsE: 204| 862| { 205| 862| uint32_t x = stream.getZeros(12); 206| 862| 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| 862| 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: 862, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 862| } _ZN4GFWX14unsignedDecodeILi110EEEjRNS_4BitsE: 204| 862| { 205| 862| uint32_t x = stream.getZeros(12); 206| 862| 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| 862| 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| 862| } _ZN4GFWX4Bits13flushReadWordEv: 183| 11| { 184| 11| if (indexBits <= 0) ------------------ | Branch (184:8): [True: 5, False: 6] ------------------ 185| 5| return; 186| 6| ++ buffer; 187| 6| indexBits = 0; 188| 6| } _ZN4GFWX5ImageIsEC2EPsii: 98| 523| Image(T * data, int sizex, int sizey) : data(data), sizex(sizex), sizey(sizey) {} _ZN4GFWX6decodeIsEEvRNS_5ImageIT_EERNS_4BitsEiiiiiiibb: 562| 41| { 563| 41| int const sizex = x1 - x0; 564| 41| int const sizey = y1 - y0; 565| 41| if (hasDC && sizex > 0 && sizey > 0) ------------------ | Branch (565:7): [True: 4, False: 37] | Branch (565:16): [True: 4, False: 0] | Branch (565:29): [True: 4, False: 0] ------------------ 566| 4| image[y0][x0] = signedDecode<4>(stream); 567| 41| std::pair context(0, 0); 568| 41| 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: 7, False: 34] | Branch (568:55): [True: 0, False: 7] | Branch (568:62): [True: 7, False: 0] | Branch (568:77): [True: 0, False: 7] ------------------ 569| 750| for (int y = 0; y < sizey; y += step) ------------------ | Branch (569:19): [True: 709, False: 41] ------------------ 570| 709| { 571| 709| T * base = &image[y0 + y][x0]; 572| 709| int const xStep = (y & step) ? step : step * 2; ------------------ | Branch (572:22): [True: 344, False: 365] ------------------ 573| 499k| for (int x = xStep - step; x < sizex; x += xStep) // [NOTE] arranged so that (x | y) & step == 1 ------------------ | Branch (573:31): [True: 499k, False: 709] ------------------ 574| 499k| { 575| 499k| T s = 0; 576| 499k| if (runCoder && run == -1) ------------------ | Branch (576:9): [True: 387k, False: 112k] | Branch (576:21): [True: 50.1k, False: 336k] ------------------ 577| 50.1k| run = runCoder == 1 ? unsignedDecode<1>(stream) : runCoder == 2 ? unsignedDecode<2>(stream) ------------------ | Branch (577:12): [True: 1.66k, False: 48.5k] | Branch (577:56): [True: 4.53k, False: 43.9k] ------------------ 578| 48.5k| : runCoder == 3 ? unsignedDecode<3>(stream) : unsignedDecode<4>(stream); ------------------ | Branch (578:9): [True: 1.38k, False: 42.5k] ------------------ 579| 499k| if (run > 0) ------------------ | Branch (579:9): [True: 336k, False: 162k] ------------------ 580| 336k| -- run; // consume a zero 581| 162k| else 582| 162k| { 583| 162k| if (scheme == EncoderTurbo) ------------------ | Branch (583:10): [True: 16.3k, False: 145k] ------------------ 584| 16.3k| s = interleavedDecode<1>(stream); 585| 145k| else 586| 145k| { 587| 145k| if (scheme == EncoderContextual) ------------------ | Branch (587:11): [True: 145k, False: 0] ------------------ 588| 145k| context = getContext(image, x0, y0, x1, y1, x, y, step); 589| 145k| uint32_t const sumSq = square(context.first); 590| 145k| if (sumSq < 2u * context.second + (isChroma ? 250u : 100u)) ------------------ | Branch (590:11): [True: 54.5k, False: 91.2k] | Branch (590:42): [True: 0, False: 145k] ------------------ 591| 54.5k| s = interleavedDecode<0>(stream); 592| 91.2k| else if (sumSq < 2u * context.second + 950u) ------------------ | Branch (592:16): [True: 28.7k, False: 62.4k] ------------------ 593| 28.7k| s = interleavedDecode<1>(stream); 594| 62.4k| else if (sumSq < 3u * context.second + 3000u) ------------------ | Branch (594:16): [True: 18.2k, False: 44.2k] ------------------ 595| 18.2k| { 596| 18.2k| if (sumSq < 5u * context.second + 400u) ------------------ | Branch (596:12): [True: 4.30k, False: 13.8k] ------------------ 597| 4.30k| s = signedDecode<1>(stream); 598| 13.8k| else 599| 13.8k| s = interleavedDecode<2>(stream); 600| 18.2k| } 601| 44.2k| else if (sumSq < 3u * context.second + 12000u) ------------------ | Branch (601:16): [True: 17.7k, False: 26.5k] ------------------ 602| 17.7k| { 603| 17.7k| if (sumSq < 5u * context.second + 3000u) ------------------ | Branch (603:12): [True: 6.29k, False: 11.4k] ------------------ 604| 6.29k| s = signedDecode<2>(stream); 605| 11.4k| else 606| 11.4k| s = interleavedDecode<3>(stream); 607| 17.7k| } 608| 26.5k| else if (sumSq < 4u * context.second + 44000u) ------------------ | Branch (608:16): [True: 13.1k, False: 13.3k] ------------------ 609| 13.1k| { 610| 13.1k| if (sumSq < 6u * context.second + 12000u) ------------------ | Branch (610:12): [True: 8.22k, False: 4.95k] ------------------ 611| 8.22k| s = signedDecode<3>(stream); 612| 4.95k| else 613| 4.95k| s = interleavedDecode<4>(stream); 614| 13.1k| } 615| 13.3k| else 616| 13.3k| s = signedDecode<4>(stream); 617| 145k| if (scheme == EncoderFast) // use decaying first and second moment ------------------ | Branch (617:11): [True: 0, False: 145k] ------------------ 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| 145k| else if (!s == !runCoder) ------------------ | Branch (624:16): [True: 17.2k, False: 128k] ------------------ 625| 17.2k| runCoder = q == 1024 ? context.first < 2u ? 1 : 0 : (context.first < 4u && context.second < 2u) ? 4 : (context.first < 8u ------------------ | Branch (625:19): [True: 0, False: 17.2k] | Branch (625:31): [True: 0, False: 0] | Branch (625:61): [True: 4.23k, False: 12.9k] | Branch (625:83): [True: 3.39k, False: 846] | Branch (625:111): [True: 2.21k, False: 11.6k] ------------------ 626| 13.8k| && context.second < 4u) ? 3 : (2u * sumSq < 3u * context.second + 48u) ? 2 : (2u * sumSq < 5u * context.second + 32u) ? 1 : 0; ------------------ | Branch (626:11): [True: 606, False: 1.61k] | Branch (626:38): [True: 1.42k, False: 11.7k] | Branch (626:85): [True: 1.06k, False: 10.7k] ------------------ 627| 145k| } 628| 162k| if (run == 0 && s <= 0) ------------------ | Branch (628:10): [True: 11.4k, False: 150k] | Branch (628:22): [True: 7.37k, False: 4.08k] ------------------ 629| 7.37k| -- s; // s can't be zero, so shift negatives by 1 630| 162k| run = -1; 631| 162k| } 632| 499k| base[x] = s; 633| 499k| } 634| 709| } 635| 41| } _ZN4GFWX12signedDecodeILi4EEEiRNS_4BitsE: 229| 13.3k| { 230| 13.3k| int x = unsignedDecode(stream); 231| 13.3k| return x ? stream.getBits(1) ? x : -x : 0; ------------------ | Branch (231:10): [True: 12.9k, False: 336] | Branch (231:14): [True: 6.22k, False: 6.76k] ------------------ 232| 13.3k| } _ZN4GFWX14unsignedDecodeILi1EEEjRNS_4BitsE: 204| 51.1k| { 205| 51.1k| uint32_t x = stream.getZeros(12); 206| 51.1k| 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| 51.1k| 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.23k, False: 45.9k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 51.1k| } _ZN4GFWX14unsignedDecodeILi5EEEjRNS_4BitsE: 204| 5.23k| { 205| 5.23k| uint32_t x = stream.getZeros(12); 206| 5.23k| 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.23k| 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.48k, False: 745] | Branch (207:99): [Folded - Ignored] ------------------ 208| 5.23k| } _ZN4GFWX14unsignedDecodeILi9EEEjRNS_4BitsE: 204| 4.48k| { 205| 4.48k| uint32_t x = stream.getZeros(12); 206| 4.48k| 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.48k| 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.80k, False: 687] | Branch (207:99): [Folded - Ignored] ------------------ 208| 4.48k| } _ZN4GFWX14unsignedDecodeILi13EEEjRNS_4BitsE: 204| 3.80k| { 205| 3.80k| uint32_t x = stream.getZeros(12); 206| 3.80k| 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.80k| 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.61k, False: 183] | Branch (207:99): [Folded - Ignored] ------------------ 208| 3.80k| } _ZN4GFWX14unsignedDecodeILi17EEEjRNS_4BitsE: 204| 3.61k| { 205| 3.61k| uint32_t x = stream.getZeros(12); 206| 3.61k| 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.61k| 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.11k, False: 504] | Branch (207:99): [Folded - Ignored] ------------------ 208| 3.61k| } _ZN4GFWX14unsignedDecodeILi21EEEjRNS_4BitsE: 204| 3.11k| { 205| 3.11k| uint32_t x = stream.getZeros(12); 206| 3.11k| 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.11k| 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.97k, False: 141] | Branch (207:99): [Folded - Ignored] ------------------ 208| 3.11k| } _ZN4GFWX14unsignedDecodeILi25EEEjRNS_4BitsE: 204| 2.97k| { 205| 2.97k| uint32_t x = stream.getZeros(12); 206| 2.97k| 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.97k| 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.88k, False: 88] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.97k| } _ZN4GFWX14unsignedDecodeILi29EEEjRNS_4BitsE: 204| 2.88k| { 205| 2.88k| uint32_t x = stream.getZeros(12); 206| 2.88k| 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.88k| 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.80k, False: 84] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.88k| } _ZN4GFWX14unsignedDecodeILi33EEEjRNS_4BitsE: 204| 2.80k| { 205| 2.80k| uint32_t x = stream.getZeros(12); 206| 2.80k| 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.80k| 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.71k, False: 85] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.80k| } _ZN4GFWX14unsignedDecodeILi37EEEjRNS_4BitsE: 204| 2.71k| { 205| 2.71k| uint32_t x = stream.getZeros(12); 206| 2.71k| 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.71k| 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.63k, False: 80] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.71k| } _ZN4GFWX14unsignedDecodeILi41EEEjRNS_4BitsE: 204| 2.63k| { 205| 2.63k| uint32_t x = stream.getZeros(12); 206| 2.63k| 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.63k| 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.59k, False: 41] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.63k| } _ZN4GFWX14unsignedDecodeILi45EEEjRNS_4BitsE: 204| 2.59k| { 205| 2.59k| uint32_t x = stream.getZeros(12); 206| 2.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| 2.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: 2.52k, False: 70] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.59k| } _ZN4GFWX14unsignedDecodeILi49EEEjRNS_4BitsE: 204| 2.52k| { 205| 2.52k| uint32_t x = stream.getZeros(12); 206| 2.52k| 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.52k| 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.46k, False: 59] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.52k| } _ZN4GFWX14unsignedDecodeILi53EEEjRNS_4BitsE: 204| 2.46k| { 205| 2.46k| uint32_t x = stream.getZeros(12); 206| 2.46k| 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.46k| 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.40k, False: 64] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.46k| } _ZN4GFWX14unsignedDecodeILi57EEEjRNS_4BitsE: 204| 2.40k| { 205| 2.40k| uint32_t x = stream.getZeros(12); 206| 2.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| 2.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: 2.35k, False: 48] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.40k| } _ZN4GFWX14unsignedDecodeILi61EEEjRNS_4BitsE: 204| 2.35k| { 205| 2.35k| uint32_t x = stream.getZeros(12); 206| 2.35k| 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.35k| 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.30k, False: 49] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.35k| } _ZN4GFWX14unsignedDecodeILi65EEEjRNS_4BitsE: 204| 2.30k| { 205| 2.30k| uint32_t x = stream.getZeros(12); 206| 2.30k| 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.30k| 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.24k, False: 59] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.30k| } _ZN4GFWX14unsignedDecodeILi69EEEjRNS_4BitsE: 204| 2.24k| { 205| 2.24k| uint32_t x = stream.getZeros(12); 206| 2.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| 2.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.85k, False: 394] | Branch (207:99): [Folded - Ignored] ------------------ 208| 2.24k| } _ZN4GFWX14unsignedDecodeILi73EEEjRNS_4BitsE: 204| 1.85k| { 205| 1.85k| uint32_t x = stream.getZeros(12); 206| 1.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| 1.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: 1.81k, False: 37] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.85k| } _ZN4GFWX14unsignedDecodeILi77EEEjRNS_4BitsE: 204| 1.81k| { 205| 1.81k| uint32_t x = stream.getZeros(12); 206| 1.81k| 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.81k| 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.56k, False: 248] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.81k| } _ZN4GFWX14unsignedDecodeILi81EEEjRNS_4BitsE: 204| 1.56k| { 205| 1.56k| uint32_t x = stream.getZeros(12); 206| 1.56k| 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.56k| 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.54k, False: 26] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.56k| } _ZN4GFWX14unsignedDecodeILi85EEEjRNS_4BitsE: 204| 1.54k| { 205| 1.54k| uint32_t x = stream.getZeros(12); 206| 1.54k| 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.54k| 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.48k, False: 51] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.54k| } _ZN4GFWX14unsignedDecodeILi89EEEjRNS_4BitsE: 204| 1.48k| { 205| 1.48k| uint32_t x = stream.getZeros(12); 206| 1.48k| 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.48k| 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.13k, False: 350] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.48k| } _ZN4GFWX14unsignedDecodeILi93EEEjRNS_4BitsE: 204| 1.13k| { 205| 1.13k| uint32_t x = stream.getZeros(12); 206| 1.13k| 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.13k| 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: 769, False: 370] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.13k| } _ZN4GFWX14unsignedDecodeILi97EEEjRNS_4BitsE: 204| 769| { 205| 769| uint32_t x = stream.getZeros(12); 206| 769| 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| 769| 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: 620, False: 149] | Branch (207:99): [Folded - Ignored] ------------------ 208| 769| } _ZN4GFWX14unsignedDecodeILi101EEEjRNS_4BitsE: 204| 620| { 205| 620| uint32_t x = stream.getZeros(12); 206| 620| 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| 620| 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: 456, False: 164] | Branch (207:99): [Folded - Ignored] ------------------ 208| 620| } _ZN4GFWX14unsignedDecodeILi105EEEjRNS_4BitsE: 204| 456| { 205| 456| uint32_t x = stream.getZeros(12); 206| 456| 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| 456| 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: 421, False: 35] | Branch (207:99): [Folded - Ignored] ------------------ 208| 456| } _ZN4GFWX14unsignedDecodeILi109EEEjRNS_4BitsE: 204| 421| { 205| 421| uint32_t x = stream.getZeros(12); 206| 421| 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| 421| 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| 421| } _ZN4GFWX14unsignedDecodeILi3EEEjRNS_4BitsE: 204| 21.0k| { 205| 21.0k| uint32_t x = stream.getZeros(12); 206| 21.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| 21.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: 160, False: 20.9k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 21.0k| } _ZN4GFWX14unsignedDecodeILi7EEEjRNS_4BitsE: 204| 160| { 205| 160| uint32_t x = stream.getZeros(12); 206| 160| 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| 160| 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: 121, False: 39] | Branch (207:99): [Folded - Ignored] ------------------ 208| 160| } _ZN4GFWX14unsignedDecodeILi11EEEjRNS_4BitsE: 204| 121| { 205| 121| uint32_t x = stream.getZeros(12); 206| 121| 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| 121| 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: 99, False: 22] | Branch (207:99): [Folded - Ignored] ------------------ 208| 121| } _ZN4GFWX14unsignedDecodeILi15EEEjRNS_4BitsE: 204| 99| { 205| 99| uint32_t x = stream.getZeros(12); 206| 99| 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| 99| 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: 8] | Branch (207:99): [Folded - Ignored] ------------------ 208| 99| } _ZN4GFWX14unsignedDecodeILi19EEEjRNS_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: 87, False: 4] | Branch (207:99): [Folded - Ignored] ------------------ 208| 91| } _ZN4GFWX14unsignedDecodeILi23EEEjRNS_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: 84, False: 3] | Branch (207:99): [Folded - Ignored] ------------------ 208| 87| } _ZN4GFWX14unsignedDecodeILi27EEEjRNS_4BitsE: 204| 84| { 205| 84| uint32_t x = stream.getZeros(12); 206| 84| 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| 84| 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: 83, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 84| } _ZN4GFWX14unsignedDecodeILi31EEEjRNS_4BitsE: 204| 83| { 205| 83| uint32_t x = stream.getZeros(12); 206| 83| 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| 83| 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: 83, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 83| } _ZN4GFWX14unsignedDecodeILi35EEEjRNS_4BitsE: 204| 83| { 205| 83| uint32_t x = stream.getZeros(12); 206| 83| 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| 83| 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: 75, False: 8] | Branch (207:99): [Folded - Ignored] ------------------ 208| 83| } _ZN4GFWX14unsignedDecodeILi39EEEjRNS_4BitsE: 204| 75| { 205| 75| uint32_t x = stream.getZeros(12); 206| 75| 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| 75| 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: 75, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 75| } _ZN4GFWX14unsignedDecodeILi43EEEjRNS_4BitsE: 204| 75| { 205| 75| uint32_t x = stream.getZeros(12); 206| 75| 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| 75| 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: 4] | Branch (207:99): [Folded - Ignored] ------------------ 208| 75| } _ZN4GFWX14unsignedDecodeILi47EEEjRNS_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| } _ZN4GFWX14unsignedDecodeILi51EEEjRNS_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: 69, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 70| } _ZN4GFWX14unsignedDecodeILi55EEEjRNS_4BitsE: 204| 69| { 205| 69| uint32_t x = stream.getZeros(12); 206| 69| 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| 69| 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: 68, False: 1] | Branch (207:99): [Folded - Ignored] ------------------ 208| 69| } _ZN4GFWX14unsignedDecodeILi59EEEjRNS_4BitsE: 204| 68| { 205| 68| uint32_t x = stream.getZeros(12); 206| 68| 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| 68| 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: 68, False: 0] | Branch (207:99): [Folded - Ignored] ------------------ 208| 68| } _ZN4GFWX14unsignedDecodeILi63EEEjRNS_4BitsE: 204| 68| { 205| 68| uint32_t x = stream.getZeros(12); 206| 68| 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| 68| 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: 6] | Branch (207:99): [Folded - Ignored] ------------------ 208| 68| } _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.0k| { 205| 61.0k| uint32_t x = stream.getZeros(12); 206| 61.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| 61.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: 1.72k, False: 59.3k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 61.0k| } _ZN4GFWX14unsignedDecodeILi8EEEjRNS_4BitsE: 204| 1.72k| { 205| 1.72k| uint32_t x = stream.getZeros(12); 206| 1.72k| 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.72k| 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.32k, False: 404] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.72k| } _ZN4GFWX14unsignedDecodeILi12EEEjRNS_4BitsE: 204| 1.32k| { 205| 1.32k| uint32_t x = stream.getZeros(12); 206| 1.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| 1.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.17k, False: 153] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.32k| } _ZN4GFWX14unsignedDecodeILi16EEEjRNS_4BitsE: 204| 1.17k| { 205| 1.17k| uint32_t x = stream.getZeros(12); 206| 1.17k| 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.17k| 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: 43] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.17k| } _ZN4GFWX14unsignedDecodeILi20EEEjRNS_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.08k, False: 43] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.12k| } _ZN4GFWX14unsignedDecodeILi24EEEjRNS_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.06k, False: 23] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.08k| } _ZN4GFWX14unsignedDecodeILi28EEEjRNS_4BitsE: 204| 1.06k| { 205| 1.06k| uint32_t x = stream.getZeros(12); 206| 1.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| 1.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: 1.04k, False: 19] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.06k| } _ZN4GFWX14unsignedDecodeILi32EEEjRNS_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.04k, False: 4] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.04k| } _ZN4GFWX14unsignedDecodeILi36EEEjRNS_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.01k, False: 23] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.04k| } _ZN4GFWX14unsignedDecodeILi40EEEjRNS_4BitsE: 204| 1.01k| { 205| 1.01k| uint32_t x = stream.getZeros(12); 206| 1.01k| 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.01k| 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: 986, False: 31] | Branch (207:99): [Folded - Ignored] ------------------ 208| 1.01k| } _ZN4GFWX14unsignedDecodeILi44EEEjRNS_4BitsE: 204| 986| { 205| 986| uint32_t x = stream.getZeros(12); 206| 986| 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| 986| 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: 968, False: 18] | Branch (207:99): [Folded - Ignored] ------------------ 208| 986| } _ZN4GFWX14unsignedDecodeILi48EEEjRNS_4BitsE: 204| 968| { 205| 968| uint32_t x = stream.getZeros(12); 206| 968| 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| 968| 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: 946, False: 22] | Branch (207:99): [Folded - Ignored] ------------------ 208| 968| } _ZN4GFWX14unsignedDecodeILi52EEEjRNS_4BitsE: 204| 946| { 205| 946| uint32_t x = stream.getZeros(12); 206| 946| 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| 946| 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: 938, False: 8] | Branch (207:99): [Folded - Ignored] ------------------ 208| 946| } _ZN4GFWX14unsignedDecodeILi56EEEjRNS_4BitsE: 204| 938| { 205| 938| uint32_t x = stream.getZeros(12); 206| 938| 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| 938| 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: 926, False: 12] | Branch (207:99): [Folded - Ignored] ------------------ 208| 938| } _ZN4GFWX14unsignedDecodeILi60EEEjRNS_4BitsE: 204| 926| { 205| 926| uint32_t x = stream.getZeros(12); 206| 926| 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| 926| 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: 924, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 926| } _ZN4GFWX14unsignedDecodeILi64EEEjRNS_4BitsE: 204| 924| { 205| 924| uint32_t x = stream.getZeros(12); 206| 924| 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| 924| 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: 909, False: 15] | Branch (207:99): [Folded - Ignored] ------------------ 208| 924| } _ZN4GFWX14unsignedDecodeILi68EEEjRNS_4BitsE: 204| 909| { 205| 909| uint32_t x = stream.getZeros(12); 206| 909| 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| 909| 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: 831, False: 78] | Branch (207:99): [Folded - Ignored] ------------------ 208| 909| } _ZN4GFWX14unsignedDecodeILi72EEEjRNS_4BitsE: 204| 831| { 205| 831| uint32_t x = stream.getZeros(12); 206| 831| 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| 831| 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: 826, False: 5] | Branch (207:99): [Folded - Ignored] ------------------ 208| 831| } _ZN4GFWX14unsignedDecodeILi76EEEjRNS_4BitsE: 204| 826| { 205| 826| uint32_t x = stream.getZeros(12); 206| 826| 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| 826| 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: 821, False: 5] | Branch (207:99): [Folded - Ignored] ------------------ 208| 826| } _ZN4GFWX14unsignedDecodeILi80EEEjRNS_4BitsE: 204| 821| { 205| 821| uint32_t x = stream.getZeros(12); 206| 821| 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| 821| 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: 806, False: 15] | Branch (207:99): [Folded - Ignored] ------------------ 208| 821| } _ZN4GFWX14unsignedDecodeILi84EEEjRNS_4BitsE: 204| 806| { 205| 806| uint32_t x = stream.getZeros(12); 206| 806| 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| 806| 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: 793, False: 13] | Branch (207:99): [Folded - Ignored] ------------------ 208| 806| } _ZN4GFWX14unsignedDecodeILi88EEEjRNS_4BitsE: 204| 793| { 205| 793| uint32_t x = stream.getZeros(12); 206| 793| 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| 793| 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: 788, False: 5] | Branch (207:99): [Folded - Ignored] ------------------ 208| 793| } _ZN4GFWX14unsignedDecodeILi92EEEjRNS_4BitsE: 204| 788| { 205| 788| uint32_t x = stream.getZeros(12); 206| 788| 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| 788| 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: 770, False: 18] | Branch (207:99): [Folded - Ignored] ------------------ 208| 788| } _ZN4GFWX14unsignedDecodeILi96EEEjRNS_4BitsE: 204| 770| { 205| 770| uint32_t x = stream.getZeros(12); 206| 770| 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| 770| 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: 768, False: 2] | Branch (207:99): [Folded - Ignored] ------------------ 208| 770| } _ZN4GFWX14unsignedDecodeILi100EEEjRNS_4BitsE: 204| 768| { 205| 768| uint32_t x = stream.getZeros(12); 206| 768| 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| 768| 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: 750, False: 18] | Branch (207:99): [Folded - Ignored] ------------------ 208| 768| } _ZN4GFWX14unsignedDecodeILi104EEEjRNS_4BitsE: 204| 750| { 205| 750| uint32_t x = stream.getZeros(12); 206| 750| 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| 750| 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: 711, False: 39] | Branch (207:99): [Folded - Ignored] ------------------ 208| 750| } _ZN4GFWX14unsignedDecodeILi108EEEjRNS_4BitsE: 204| 711| { 205| 711| uint32_t x = stream.getZeros(12); 206| 711| 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| 711| 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| 711| } _ZN4GFWX17interleavedDecodeILi1EEEiRNS_4BitsE: 216| 45.1k| { 217| 45.1k| int const x = unsignedDecode(stream); 218| 45.1k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 27.6k, False: 17.5k] ------------------ 219| 45.1k| } _ZN4GFWX10getContextIsEENSt3__14pairIjjEERNS_5ImageIT_EEiiiiiii: 440| 145k| { 441| 145k| int px = x0 + (x & ~(skip * 2)) + (x & skip); 442| 145k| if (px >= x1) ------------------ | Branch (442:7): [True: 44, False: 145k] ------------------ 443| 44| px -= skip * 2; 444| 145k| int py = y0 + (y & ~(skip * 2)) + (y & skip); 445| 145k| if (py >= y1) ------------------ | Branch (445:7): [True: 172, False: 145k] ------------------ 446| 172| py -= skip * 2; 447| 145k| uint32_t count = 0, sum = 0, sum2 = 0; 448| 145k| addContext(abs(image[py][px]), 2, sum, sum2, count); // ancestor 449| 145k| if ((y & skip) && (x | skip) < x1 - x0) ------------------ | Branch (449:7): [True: 93.2k, False: 52.5k] | Branch (449:21): [True: 93.2k, False: 29] ------------------ 450| 93.2k| { 451| 93.2k| addContext(image[y0 + y - skip][x0 + (x | skip)], 2, sum, sum2, count); // upper sibling 452| 93.2k| if (x & skip) ------------------ | Branch (452:8): [True: 46.7k, False: 46.5k] ------------------ 453| 46.7k| addContext(image[y0 + y][x0 + x - skip], 2, sum, sum2, count); // left sibling 454| 93.2k| } 455| 145k| if (y >= skip * 2 && x >= skip * 2) // neighbors ------------------ | Branch (455:7): [True: 133k, False: 12.6k] | Branch (455:24): [True: 133k, False: 168] ------------------ 456| 133k| { 457| 133k| addContext(image[y0 + y - skip * 2][x0 + x], 4, sum, sum2, count); 458| 133k| addContext(image[y0 + y][x0 + x - skip * 2], 4, sum, sum2, count); 459| 133k| addContext(image[y0 + y - skip * 2][x0 + x - skip * 2], 2, sum, sum2, count); 460| 133k| if (x + skip * 2 < x1 - x0) ------------------ | Branch (460:8): [True: 132k, False: 170] ------------------ 461| 132k| addContext(image[y0 + y - skip * 2][x0 + x + skip * 2], 2, sum, sum2, count); 462| 133k| if (y >= skip * 4 && x >= skip * 4) ------------------ | Branch (462:8): [True: 120k, False: 12.2k] | Branch (462:25): [True: 120k, False: 123] ------------------ 463| 120k| { 464| 120k| addContext(image[y0 + y - skip * 4][x0 + x], 2, sum, sum2, count); 465| 120k| addContext(image[y0 + y][x0 + x - skip * 4], 2, sum, sum2, count); 466| 120k| addContext(image[y0 + y - skip * 4][x0 + x - skip * 4], 1, sum, sum2, count); 467| 120k| if (x + skip * 4 < x1 - x0) ------------------ | Branch (467:9): [True: 120k, False: 302] ------------------ 468| 120k| addContext(image[y0 + y - skip * 4][x0 + x + skip * 4], 1, sum, sum2, count); 469| 120k| } 470| 133k| } 471| 145k| return std::make_pair((sum * 16u + count / 2u) / count, (sum2 * 16u + count / 2u) / count); // set sums relative to 16 count 472| 145k| } _ZN4GFWX10addContextEiiRjS0_S0_: 433| 1.29M| { 434| 1.29M| sum += uint32_t(x = abs(x)) * w; 435| 1.29M| sum2 += square(std::min(uint32_t(x), 4096u)) * w; // [MAGIC] avoid overflow in last line of getContext 436| 1.29M| count += w; 437| 1.29M| } _ZN4GFWX6squareIjEET_S1_: 428| 1.44M| { 429| 1.44M| return t * t; 430| 1.44M| } _ZN4GFWX17interleavedDecodeILi0EEEiRNS_4BitsE: 216| 54.5k| { 217| 54.5k| int const x = unsignedDecode(stream); 218| 54.5k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 44.3k, False: 10.2k] ------------------ 219| 54.5k| } _ZN4GFWX14unsignedDecodeILi0EEEjRNS_4BitsE: 204| 54.5k| { 205| 54.5k| uint32_t x = stream.getZeros(12); 206| 54.5k| 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.5k| 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: 187, False: 54.3k] | Branch (207:99): [Folded - Ignored] ------------------ 208| 54.5k| } _ZN4GFWX12signedDecodeILi1EEEiRNS_4BitsE: 229| 4.30k| { 230| 4.30k| int x = unsignedDecode(stream); 231| 4.30k| return x ? stream.getBits(1) ? x : -x : 0; ------------------ | Branch (231:10): [True: 3.36k, False: 937] | Branch (231:14): [True: 1.61k, False: 1.75k] ------------------ 232| 4.30k| } _ZN4GFWX17interleavedDecodeILi2EEEiRNS_4BitsE: 216| 13.8k| { 217| 13.8k| int const x = unsignedDecode(stream); 218| 13.8k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 7.19k, False: 6.69k] ------------------ 219| 13.8k| } _ZN4GFWX17interleavedDecodeILi3EEEiRNS_4BitsE: 216| 11.4k| { 217| 11.4k| int const x = unsignedDecode(stream); 218| 11.4k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 8.01k, False: 3.47k] ------------------ 219| 11.4k| } _ZN4GFWX12signedDecodeILi3EEEiRNS_4BitsE: 229| 8.22k| { 230| 8.22k| int x = unsignedDecode(stream); 231| 8.22k| return x ? stream.getBits(1) ? x : -x : 0; ------------------ | Branch (231:10): [True: 7.83k, False: 386] | Branch (231:14): [True: 4.14k, False: 3.69k] ------------------ 232| 8.22k| } _ZN4GFWX17interleavedDecodeILi4EEEiRNS_4BitsE: 216| 4.95k| { 217| 4.95k| int const x = unsignedDecode(stream); 218| 4.95k| return (x & 1) ? (x + 1) / 2 : -x / 2; ------------------ | Branch (218:10): [True: 2.74k, False: 2.21k] ------------------ 219| 4.95k| } _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: 35.1k, False: 2.77M] | Branch (420:79): [True: 37.4k, 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.46M| T * operator[] (int y) { return data + static_cast(y) * sizex; }