LLVMFuzzerTestOneInput: 39| 1.55k|int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 40| 1.55k| size_t preamble = 2 + 2 + 1 + sizeof(NeAACDecConfiguration); 41| 1.55k| NeAACDecConfiguration config; 42| 1.55k| uint64_t sample_rate; 43| 1.55k| unsigned char num_channels; 44| 1.55k| NeAACDecConfigurationPtr config_ptr; 45| | /* feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW); */ 46| | 47| 1.55k| if (size < preamble) return 0; ------------------ | Branch (47:7): [True: 0, False: 1.55k] ------------------ 48| 1.55k| size_t len1 = data[0] | (data[1] << 8); 49| 1.55k| data += 2; 50| 1.55k| size_t len2 = data[0] | (data[1] << 8); 51| 1.55k| data += 2; 52| 1.55k| uint8_t flags = data[0]; 53| 1.55k| data += 1; 54| 1.55k| memcpy(&config, data, sizeof(NeAACDecConfiguration)); 55| 1.55k| data += sizeof(NeAACDecConfiguration); 56| 1.55k| size -= preamble; 57| | 58| 1.55k| if (len1 + len2 > size) return 0; ------------------ | Branch (58:7): [True: 0, False: 1.55k] ------------------ 59| 1.55k| size_t len3 = size - len1 - len2; 60| 1.55k| int use_init2 = flags & 1; 61| 1.55k| int seek_before = flags & 2; 62| 1.55k| int seek_between = flags & 4; 63| 1.55k| size_t buffer_op = (flags >> 3) & 3; 64| 1.55k| int use_drm = flags & 32; 65| 1.55k| int drm_channels = (flags >> 5) & 7; 66| 1.55k| unsigned long drm_sample_rate = config.defSampleRate; 67| 1.55k| int res, ok; 68| 1.55k| const size_t kBufferSize[4] = {0, 0, 16, 16384}; 69| 1.55k| size_t buffer_size = kBufferSize[buffer_op]; 70| 1.55k| void* buffer = buffer_size > 0 ? (unsigned char *)malloc(buffer_size) : NULL; ------------------ | Branch (70:18): [True: 321, False: 1.22k] ------------------ 71| | 72| 1.55k| unsigned char* part1 = (unsigned char *)malloc(len1); 73| 1.55k| unsigned char* part2 = (unsigned char *)malloc(len2); 74| 1.55k| unsigned char* part3 = (unsigned char *)malloc(len3); 75| 1.55k| memcpy(part1, data, len1); 76| 1.55k| data += len1; 77| 1.55k| memcpy(part2, data, len2); 78| 1.55k| data += len2; 79| 1.55k| memcpy(part3, data, len3); 80| 1.55k| data += len3; 81| | 82| 1.55k| NeAACDecHandle decoder = NeAACDecOpen(); 83| 1.55k| ok = NeAACDecSetConfiguration(decoder, &config); 84| 1.55k| if (!ok) goto cleanup; ------------------ | Branch (84:7): [True: 4, False: 1.54k] ------------------ 85| 1.54k| config_ptr = NeAACDecGetCurrentConfiguration(decoder); 86| 1.54k| if (!config_ptr) __builtin_trap(); ------------------ | Branch (86:7): [True: 0, False: 1.54k] ------------------ 87| 1.54k| if (use_init2) { ------------------ | Branch (87:7): [True: 474, False: 1.07k] ------------------ 88| 474| res = NeAACDecInit2(decoder, part1, len1, &sample_rate, &num_channels); 89| 1.07k| } else { 90| 1.07k| res = NeAACDecInit(decoder, part1, len1, &sample_rate, &num_channels); 91| 1.07k| } 92| 1.54k| if (use_drm) { ------------------ | Branch (92:7): [True: 132, False: 1.41k] ------------------ 93| 132|#ifdef DRM_SUPPORT 94| 132| NeAACDecInitDRM(&decoder, drm_channels, drm_sample_rate); 95| |#else 96| | (void)drm_channels; 97| | (void)drm_sample_rate; 98| |#endif 99| 132| } 100| | 101| 1.54k| if (res != 0) goto cleanup; ------------------ | Branch (101:7): [True: 53, False: 1.49k] ------------------ 102| 1.49k| NeAACDecFrameInfo faad_info; 103| 1.49k| if (seek_before) { ------------------ | Branch (103:7): [True: 385, False: 1.10k] ------------------ 104| 385| NeAACDecPostSeekReset(decoder, 0x1234567); 105| 385| } 106| 1.49k| NeAACDecDecode(decoder, &faad_info, part2, len2); 107| 1.49k| if (seek_between) { ------------------ | Branch (107:7): [True: 430, False: 1.06k] ------------------ 108| 430| NeAACDecPostSeekReset(decoder, -0x1234567); 109| 430| } 110| 1.49k| if (buffer_op == 0) { ------------------ | Branch (110:7): [True: 1.18k, False: 305] ------------------ 111| 1.18k| NeAACDecDecode(decoder, &faad_info, part3, len3); 112| 1.18k| } else { 113| 305| NeAACDecDecode2(decoder, &faad_info, part3, len3, &buffer, buffer_size); 114| 305| } 115| | 116| 1.55k|cleanup: 117| 1.55k| NeAACDecClose(decoder); 118| 1.55k| free(part1); 119| 1.55k| free(part2); 120| 1.55k| free(part3); 121| 1.55k| if (buffer) free(buffer); ------------------ | Branch (121:7): [True: 321, False: 1.22k] ------------------ 122| | 123| 1.55k| return 0; 124| 1.49k|} faad_initbits: 56| 5.69k|{ 57| 5.69k| uint32_t tmp; 58| | 59| 5.69k| if (ld == NULL) ------------------ | Branch (59:9): [True: 0, False: 5.69k] ------------------ 60| 0| return; 61| | 62| 5.69k| if (buffer_size == 0 || _buffer == NULL) ------------------ | Branch (62:9): [True: 1.18k, False: 4.50k] | Branch (62:29): [True: 0, False: 4.50k] ------------------ 63| 1.18k| { 64| 1.18k| ld->error = 1; 65| 1.18k| return; 66| 1.18k| } 67| | 68| 4.50k| ld->buffer = _buffer; 69| | 70| 4.50k| ld->buffer_size = buffer_size; 71| 4.50k| ld->bytes_left = buffer_size; 72| | 73| 4.50k| if (ld->bytes_left >= 4) ------------------ | Branch (73:9): [True: 3.04k, False: 1.46k] ------------------ 74| 3.04k| { 75| 3.04k| tmp = getdword((uint32_t*)ld->buffer); 76| 3.04k| ld->bytes_left -= 4; 77| 3.04k| } else { 78| 1.46k| tmp = getdword_n((uint32_t*)ld->buffer, ld->bytes_left); 79| 1.46k| ld->bytes_left = 0; 80| 1.46k| } 81| 4.50k| ld->bufa = tmp; 82| | 83| 4.50k| if (ld->bytes_left >= 4) ------------------ | Branch (83:9): [True: 2.62k, False: 1.88k] ------------------ 84| 2.62k| { 85| 2.62k| tmp = getdword((uint32_t*)ld->buffer + 1); 86| 2.62k| ld->bytes_left -= 4; 87| 2.62k| } else { 88| 1.88k| tmp = getdword_n((uint32_t*)ld->buffer + 1, ld->bytes_left); 89| 1.88k| ld->bytes_left = 0; 90| 1.88k| } 91| 4.50k| ld->bufb = tmp; 92| | 93| 4.50k| ld->start = (uint32_t*)ld->buffer; 94| 4.50k| ld->tail = ((uint32_t*)ld->buffer + 2); 95| | 96| 4.50k| ld->bits_left = 32; 97| | 98| 4.50k| ld->error = 0; 99| 4.50k|} faad_endbits: 102| 5.21k|{ 103| 5.21k| (void)ld; 104| 5.21k|} faad_get_processed_bits: 107| 11.1M|{ 108| 11.1M| return (uint32_t)(8 * (4*(ld->tail - ld->start) - 4) - (ld->bits_left)); 109| 11.1M|} faad_byte_align: 112| 7.52k|{ 113| 7.52k| int remainder = (32 - ld->bits_left) & 0x7; 114| | 115| 7.52k| if (remainder) ------------------ | Branch (115:9): [True: 5.83k, False: 1.69k] ------------------ 116| 5.83k| { 117| 5.83k| faad_flushbits(ld, 8 - remainder); 118| 5.83k| return (uint8_t)(8 - remainder); 119| 5.83k| } 120| 1.69k| return 0; 121| 7.52k|} faad_flushbits_ex: 124| 1.18M|{ 125| 1.18M| uint32_t tmp; 126| | 127| 1.18M| ld->bufa = ld->bufb; 128| 1.18M| if (ld->bytes_left >= 4) ------------------ | Branch (128:9): [True: 285k, False: 895k] ------------------ 129| 285k| { 130| 285k| tmp = getdword(ld->tail); 131| 285k| ld->bytes_left -= 4; 132| 895k| } else { 133| 895k| tmp = getdword_n(ld->tail, ld->bytes_left); 134| 895k| ld->bytes_left = 0; 135| 895k| } 136| 1.18M| ld->bufb = tmp; 137| 1.18M| ld->tail++; 138| 1.18M| ld->bits_left += (32 - bits); 139| | //ld->bytes_left -= 4; 140| |// if (ld->bytes_left == 0) 141| |// ld->no_more_reading = 1; 142| |// if (ld->bytes_left < 0) 143| |// ld->error = 1; 144| 1.18M|} faad_rewindbits: 149| 206|{ 150| 206| uint32_t tmp; 151| | 152| 206| ld->bytes_left = ld->buffer_size; 153| | 154| 206| if (ld->bytes_left >= 4) ------------------ | Branch (154:9): [True: 205, False: 1] ------------------ 155| 205| { 156| 205| tmp = getdword((uint32_t*)&ld->start[0]); 157| 205| ld->bytes_left -= 4; 158| 205| } else { 159| 1| tmp = getdword_n((uint32_t*)&ld->start[0], ld->bytes_left); 160| 1| ld->bytes_left = 0; 161| 1| } 162| 206| ld->bufa = tmp; 163| | 164| 206| if (ld->bytes_left >= 4) ------------------ | Branch (164:9): [True: 205, False: 1] ------------------ 165| 205| { 166| 205| tmp = getdword((uint32_t*)&ld->start[1]); 167| 205| ld->bytes_left -= 4; 168| 205| } else { 169| 1| tmp = getdword_n((uint32_t*)&ld->start[1], ld->bytes_left); 170| 1| ld->bytes_left = 0; 171| 1| } 172| 206| ld->bufb = tmp; 173| | 174| 206| ld->bits_left = 32; 175| 206| ld->tail = &ld->start[2]; 176| 206|} faad_resetbits: 181| 7.00k|{ 182| 7.00k| uint32_t tmp; 183| 7.00k| uint32_t words = bits >> 5; 184| 7.00k| uint32_t remainder = bits & 0x1F; 185| | 186| 7.00k| if (ld->buffer_size < words * 4) ------------------ | Branch (186:9): [True: 41, False: 6.96k] ------------------ 187| 41| ld->bytes_left = 0; 188| 6.96k| else 189| 6.96k| ld->bytes_left = ld->buffer_size - words*4; 190| | 191| 7.00k| if (ld->bytes_left >= 4) ------------------ | Branch (191:9): [True: 6.90k, False: 104] ------------------ 192| 6.90k| { 193| 6.90k| tmp = getdword(&ld->start[words]); 194| 6.90k| ld->bytes_left -= 4; 195| 6.90k| } else { 196| 104| tmp = getdword_n(&ld->start[words], ld->bytes_left); 197| 104| ld->bytes_left = 0; 198| 104| } 199| 7.00k| ld->bufa = tmp; 200| | 201| 7.00k| if (ld->bytes_left >= 4) ------------------ | Branch (201:9): [True: 6.80k, False: 204] ------------------ 202| 6.80k| { 203| 6.80k| tmp = getdword(&ld->start[words+1]); 204| 6.80k| ld->bytes_left -= 4; 205| 6.80k| } else { 206| 204| tmp = getdword_n(&ld->start[words+1], ld->bytes_left); 207| 204| ld->bytes_left = 0; 208| 204| } 209| 7.00k| ld->bufb = tmp; 210| | 211| 7.00k| ld->bits_left = 32 - remainder; 212| 7.00k| ld->tail = &ld->start[words+2]; 213| | 214| | /* recheck for reading too many bytes */ 215| 7.00k| ld->error = 0; 216| |// if (ld->bytes_left == 0) 217| |// ld->no_more_reading = 1; 218| |// if (ld->bytes_left < 0) 219| |// ld->error = 1; 220| 7.00k|} faad_getbitbuffer: 224| 1.05k|{ 225| 1.05k| int i; 226| 1.05k| unsigned int temp; 227| 1.05k| int bytes = bits >> 3; 228| 1.05k| int remainder = bits & 0x7; 229| | 230| 1.05k| uint8_t *buffer = (uint8_t*)faad_malloc((bytes+1)*sizeof(uint8_t)); 231| | 232| 13.1k| for (i = 0; i < bytes; i++) ------------------ | Branch (232:17): [True: 12.1k, False: 1.05k] ------------------ 233| 12.1k| { 234| 12.1k| buffer[i] = (uint8_t)faad_getbits(ld, 8 DEBUGVAR(print,var,dbg)); 235| 12.1k| } 236| | 237| 1.05k| if (remainder) ------------------ | Branch (237:9): [True: 485, False: 567] ------------------ 238| 485| { 239| 485| temp = faad_getbits(ld, remainder DEBUGVAR(print,var,dbg)) << (8-remainder); 240| | 241| 485| buffer[bytes] = (uint8_t)temp; 242| 485| } 243| | 244| 1.05k| return buffer; 245| 1.05k|} faad_origbitbuffer: 250| 117|{ 251| 117| return (void*)ld->start; 252| 117|} faad_origbitbuffer_size: 256| 117|{ 257| 117| return ld->buffer_size; 258| 117|} bits.c:getdword_n: 39| 899k|{ 40| 899k| uint8_t* m8 = (uint8_t*)mem; 41| 899k| switch (n) 42| 899k| { 43| 963| case 3: ------------------ | Branch (43:5): [True: 963, False: 898k] ------------------ 44| 963| return ((uint32_t)m8[2] << 8) | ((uint32_t)m8[1] << 16) | ((uint32_t)m8[0] << 24); 45| 1.66k| case 2: ------------------ | Branch (45:5): [True: 1.66k, False: 897k] ------------------ 46| 1.66k| return ((uint32_t)m8[1] << 16) | ((uint32_t)m8[0] << 24); 47| 1.70k| case 1: ------------------ | Branch (47:5): [True: 1.70k, False: 897k] ------------------ 48| 1.70k| return (uint32_t)m8[0] << 24; 49| 894k| default: ------------------ | Branch (49:5): [True: 894k, False: 4.33k] ------------------ 50| 894k| return 0; 51| 899k| } 52| 899k|} decoder.c:faad_getbits: 131| 167|{ 132| 167| uint32_t ret; 133| | 134| 167| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 167] ------------------ 135| 0| return 0; 136| | 137| 167| ret = faad_showbits(ld, n); 138| 167| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 167| return ret; 146| 167|} decoder.c:faad_showbits: 103| 167|{ 104| 167| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 167, False: 0] ------------------ 105| 167| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 167| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 167| } 109| | 110| 0| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 0| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 167|} decoder.c:faad_flushbits: 116| 167|{ 117| | /* do nothing if error */ 118| 167| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 167] ------------------ 119| 0| return; 120| | 121| 167| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 167, False: 0] ------------------ 122| 167| { 123| 167| ld->bits_left -= bits; 124| 167| } else { 125| 0| faad_flushbits_ex(ld, bits); 126| 0| } 127| 167|} bits.c:getdword: 97| 305k|{ 98| 305k| uint8_t* m8 = (uint8_t*)mem; 99| 305k| return (uint32_t)m8[3] | ((uint32_t)m8[2] << 8) | ((uint32_t)m8[1] << 16) | ((uint32_t)m8[0] << 24); 100| 305k|} bits.c:faad_flushbits: 116| 18.4k|{ 117| | /* do nothing if error */ 118| 18.4k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 18.4k] ------------------ 119| 0| return; 120| | 121| 18.4k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 11.6k, False: 6.75k] ------------------ 122| 11.6k| { 123| 11.6k| ld->bits_left -= bits; 124| 11.6k| } else { 125| 6.75k| faad_flushbits_ex(ld, bits); 126| 6.75k| } 127| 18.4k|} bits.c:faad_getbits: 131| 12.6k|{ 132| 12.6k| uint32_t ret; 133| | 134| 12.6k| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 12.6k] ------------------ 135| 0| return 0; 136| | 137| 12.6k| ret = faad_showbits(ld, n); 138| 12.6k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 12.6k| return ret; 146| 12.6k|} bits.c:faad_showbits: 103| 12.6k|{ 104| 12.6k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 10.0k, False: 2.57k] ------------------ 105| 10.0k| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 10.0k| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 10.0k| } 109| | 110| 2.57k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 2.57k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 12.6k|} mp4.c:faad_getbits: 131| 2.42k|{ 132| 2.42k| uint32_t ret; 133| | 134| 2.42k| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 2.42k] ------------------ 135| 0| return 0; 136| | 137| 2.42k| ret = faad_showbits(ld, n); 138| 2.42k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 2.42k| return ret; 146| 2.42k|} mp4.c:faad_showbits: 103| 2.42k|{ 104| 2.42k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 2.31k, False: 116] ------------------ 105| 2.31k| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 2.31k| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 2.31k| } 109| | 110| 116| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 116| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 2.42k|} mp4.c:faad_flushbits: 116| 2.42k|{ 117| | /* do nothing if error */ 118| 2.42k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 2.42k] ------------------ 119| 0| return; 120| | 121| 2.42k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 2.31k, False: 116] ------------------ 122| 2.31k| { 123| 2.31k| ld->bits_left -= bits; 124| 2.31k| } else { 125| 116| faad_flushbits_ex(ld, bits); 126| 116| } 127| 2.42k|} mp4.c:faad_get1bit: 149| 41|{ 150| 41| uint8_t r; 151| | 152| 41| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 41, False: 0] ------------------ 153| 41| { 154| 41| ld->bits_left--; 155| 41| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 41| return r; 157| 41| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 0| r = (uint8_t)faad_getbits(ld, 1); 165| 0|#endif 166| 0| return r; 167| 41|} drm_dec.c:faad_get1bit: 149| 873k|{ 150| 873k| uint8_t r; 151| | 152| 873k| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 849k, False: 24.4k] ------------------ 153| 849k| { 154| 849k| ld->bits_left--; 155| 849k| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 849k| return r; 157| 849k| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 24.4k| r = (uint8_t)faad_getbits(ld, 1); 165| 24.4k|#endif 166| 24.4k| return r; 167| 873k|} drm_dec.c:faad_getbits: 131| 24.4k|{ 132| 24.4k| uint32_t ret; 133| | 134| 24.4k| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 24.4k] ------------------ 135| 0| return 0; 136| | 137| 24.4k| ret = faad_showbits(ld, n); 138| 24.4k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 24.4k| return ret; 146| 24.4k|} drm_dec.c:faad_showbits: 103| 24.4k|{ 104| 24.4k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 0, False: 24.4k] ------------------ 105| 0| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 0| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 0| } 109| | 110| 24.4k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 24.4k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 24.4k|} drm_dec.c:faad_flushbits: 116| 24.4k|{ 117| | /* do nothing if error */ 118| 24.4k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 24.4k] ------------------ 119| 0| return; 120| | 121| 24.4k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 0, False: 24.4k] ------------------ 122| 0| { 123| 0| ld->bits_left -= bits; 124| 24.4k| } else { 125| 24.4k| faad_flushbits_ex(ld, bits); 126| 24.4k| } 127| 24.4k|} syntax.c:faad_get1bit: 149| 327k|{ 150| 327k| uint8_t r; 151| | 152| 327k| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 324k, False: 2.87k] ------------------ 153| 324k| { 154| 324k| ld->bits_left--; 155| 324k| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 324k| return r; 157| 324k| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 2.87k| r = (uint8_t)faad_getbits(ld, 1); 165| 2.87k|#endif 166| 2.87k| return r; 167| 327k|} syntax.c:faad_getbits: 131| 1.44M|{ 132| 1.44M| uint32_t ret; 133| | 134| 1.44M| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 1.44M] ------------------ 135| 0| return 0; 136| | 137| 1.44M| ret = faad_showbits(ld, n); 138| 1.44M| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 1.44M| return ret; 146| 1.44M|} syntax.c:faad_showbits: 103| 2.27M|{ 104| 2.27M| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 2.01M, False: 252k] ------------------ 105| 2.01M| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 2.01M| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 2.01M| } 109| | 110| 252k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 252k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 2.27M|} syntax.c:faad_flushbits: 116| 1.45M|{ 117| | /* do nothing if error */ 118| 1.45M| if (ld->error != 0) ------------------ | Branch (118:9): [True: 1, False: 1.45M] ------------------ 119| 1| return; 120| | 121| 1.45M| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 1.13M, False: 320k] ------------------ 122| 1.13M| { 123| 1.13M| ld->bits_left -= bits; 124| 1.13M| } else { 125| 320k| faad_flushbits_ex(ld, bits); 126| 320k| } 127| 1.45M|} syntax.c:faad_check_CRC: 287| 206|{ 288| 206| int bytes, rem; 289| 206| unsigned int CRC; 290| 206| unsigned int r=255; /* Initialize to all ones */ 291| | 292| | /* CRC polynome used x^8 + x^4 + x^3 + x^2 +1 */ 293| 206|#define GPOLY 0435 294| | 295| 206| faad_rewindbits(ld); 296| | 297| 206| CRC = (unsigned int) ~faad_getbits(ld, 8 298| 206| DEBUGVAR(1,999,"faad_check_CRC(): CRC")) & 0xFF; /* CRC is stored inverted */ 299| | 300| 206| bytes = len >> 3; 301| 206| rem = len & 0x7; 302| | 303| 7.92k| for (; bytes > 0; bytes--) ------------------ | Branch (303:12): [True: 7.72k, False: 206] ------------------ 304| 7.72k| { 305| 7.72k| r = crc_table_G8[( r ^ faad_getbits(ld, 8 DEBUGVAR(1,998,"")) ) & 0xFF]; 306| 7.72k| } 307| 853| for (; rem > 0; rem--) ------------------ | Branch (307:12): [True: 647, False: 206] ------------------ 308| 647| { 309| 647| r = ( (r << 1) ^ (( ( faad_get1bit(ld 310| 647| DEBUGVAR(1,998,"")) & 1) ^ ((r >> 7) & 1)) * GPOLY )) & 0xFF; ------------------ | | 293| 647|#define GPOLY 0435 ------------------ 311| 647| } 312| | 313| 206| if (r != CRC) ------------------ | Branch (313:9): [True: 20, False: 186] ------------------ 314| | // if (0) 315| 20| { 316| 20| return 28; 317| 186| } else { 318| 186| return 0; 319| 186| } 320| 206|} syntax.c:reverse_byte: 342| 2.07M|{ 343| 2.07M| return tabFlipbits[b]; 344| 2.07M|} sbr_syntax.c:faad_getbits: 131| 657k|{ 132| 657k| uint32_t ret; 133| | 134| 657k| if (n == 0) ------------------ | Branch (134:9): [True: 919, False: 656k] ------------------ 135| 919| return 0; 136| | 137| 656k| ret = faad_showbits(ld, n); 138| 656k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 656k| return ret; 146| 657k|} sbr_syntax.c:faad_showbits: 103| 656k|{ 104| 656k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 605k, False: 51.6k] ------------------ 105| 605k| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 605k| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 605k| } 109| | 110| 51.6k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 51.6k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 656k|} sbr_syntax.c:faad_flushbits: 116| 656k|{ 117| | /* do nothing if error */ 118| 656k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 1, False: 656k] ------------------ 119| 1| return; 120| | 121| 656k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 577k, False: 79.6k] ------------------ 122| 577k| { 123| 577k| ld->bits_left -= bits; 124| 577k| } else { 125| 79.6k| faad_flushbits_ex(ld, bits); 126| 79.6k| } 127| 656k|} sbr_syntax.c:faad_get1bit: 149| 259k|{ 150| 259k| uint8_t r; 151| | 152| 259k| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 253k, False: 5.88k] ------------------ 153| 253k| { 154| 253k| ld->bits_left--; 155| 253k| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 253k| return r; 157| 253k| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 5.88k| r = (uint8_t)faad_getbits(ld, 1); 165| 5.88k|#endif 166| 5.88k| return r; 167| 259k|} sbr_huff.c:faad_getbits: 131| 52.8k|{ 132| 52.8k| uint32_t ret; 133| | 134| 52.8k| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 52.8k] ------------------ 135| 0| return 0; 136| | 137| 52.8k| ret = faad_showbits(ld, n); 138| 52.8k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 52.8k| return ret; 146| 52.8k|} sbr_huff.c:faad_showbits: 103| 52.8k|{ 104| 52.8k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 33.4k, False: 19.3k] ------------------ 105| 33.4k| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 33.4k| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 33.4k| } 109| | 110| 19.3k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 19.3k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 52.8k|} sbr_huff.c:faad_flushbits: 116| 52.8k|{ 117| | /* do nothing if error */ 118| 52.8k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 52.8k] ------------------ 119| 0| return; 120| | 121| 52.8k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 32.3k, False: 20.4k] ------------------ 122| 32.3k| { 123| 32.3k| ld->bits_left -= bits; 124| 32.3k| } else { 125| 20.4k| faad_flushbits_ex(ld, bits); 126| 20.4k| } 127| 52.8k|} sbr_huff.c:faad_get1bit: 149| 450k|{ 150| 450k| uint8_t r; 151| | 152| 450k| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 437k, False: 12.8k] ------------------ 153| 437k| { 154| 437k| ld->bits_left--; 155| 437k| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 437k| return r; 157| 437k| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 12.8k| r = (uint8_t)faad_getbits(ld, 1); 165| 12.8k|#endif 166| 12.8k| return r; 167| 450k|} ps_syntax.c:faad_get1bit: 149| 11.5M|{ 150| 11.5M| uint8_t r; 151| | 152| 11.5M| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 11.2M, False: 267k] ------------------ 153| 11.2M| { 154| 11.2M| ld->bits_left--; 155| 11.2M| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 11.2M| return r; 157| 11.2M| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 267k| r = (uint8_t)faad_getbits(ld, 1); 165| 267k|#endif 166| 267k| return r; 167| 11.5M|} ps_syntax.c:faad_getbits: 131| 5.61M|{ 132| 5.61M| uint32_t ret; 133| | 134| 5.61M| if (n == 0) ------------------ | Branch (134:9): [True: 3.21k, False: 5.61M] ------------------ 135| 3.21k| return 0; 136| | 137| 5.61M| ret = faad_showbits(ld, n); 138| 5.61M| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 5.61M| return ret; 146| 5.61M|} ps_syntax.c:faad_showbits: 103| 5.61M|{ 104| 5.61M| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 4.97M, False: 638k] ------------------ 105| 4.97M| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 4.97M| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 4.97M| } 109| | 110| 638k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 638k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 5.61M|} ps_syntax.c:faad_flushbits: 116| 5.61M|{ 117| | /* do nothing if error */ 118| 5.61M| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 5.61M] ------------------ 119| 0| return; 120| | 121| 5.61M| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 4.91M, False: 695k] ------------------ 122| 4.91M| { 123| 4.91M| ld->bits_left -= bits; 124| 4.91M| } else { 125| 695k| faad_flushbits_ex(ld, bits); 126| 695k| } 127| 5.61M|} hcr.c:faad_getbits: 131| 24.0k|{ 132| 24.0k| uint32_t ret; 133| | 134| 24.0k| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 24.0k] ------------------ 135| 0| return 0; 136| | 137| 24.0k| ret = faad_showbits(ld, n); 138| 24.0k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 24.0k| return ret; 146| 24.0k|} hcr.c:faad_showbits: 103| 24.0k|{ 104| 24.0k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 14.6k, False: 9.43k] ------------------ 105| 14.6k| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 14.6k| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 14.6k| } 109| | 110| 9.43k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 9.43k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 24.0k|} hcr.c:faad_flushbits: 116| 24.0k|{ 117| | /* do nothing if error */ 118| 24.0k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 24.0k] ------------------ 119| 0| return; 120| | 121| 24.0k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 13.3k, False: 10.6k] ------------------ 122| 13.3k| { 123| 13.3k| ld->bits_left -= bits; 124| 13.3k| } else { 125| 10.6k| faad_flushbits_ex(ld, bits); 126| 10.6k| } 127| 24.0k|} hcr.c:showbits_hcr: 362| 111|{ 363| 111| uint32_t mask; 364| 111| int8_t tail; 365| 111| if (bits == 0) return 0; ------------------ | Branch (365:9): [True: 0, False: 111] ------------------ 366| 111| if (ld->len == 0) return 0; ------------------ | Branch (366:9): [True: 0, False: 111] ------------------ 367| 111| tail = ld->len - bits; 368| 111| mask = 0xFFFFFFFF >> (32 - bits); 369| 111| if (ld->len <= 32) ------------------ | Branch (369:9): [True: 81, False: 30] ------------------ 370| 81| { 371| | /* huffman_spectral_data_2 might request more than available (tail < 0), 372| | pad with zeroes then. */ 373| 81| if (tail >= 0) ------------------ | Branch (373:13): [True: 81, False: 0] ------------------ 374| 81| return (ld->bufa >> tail) & mask; /* tail is 0..31 */ 375| 0| else 376| 0| return (ld->bufa << -tail) & mask; /* -tail is 1..31 */ 377| 81| } else { 378| | /* tail is 1..63 */ 379| 30| if (tail < 32) ------------------ | Branch (379:13): [True: 15, False: 15] ------------------ 380| 15| return ((ld->bufb << (32 - tail)) | (ld->bufa >> tail)) & mask; 381| 15| else 382| 15| return (ld->bufb >> (tail - 32)) & mask; 383| 30| } 384| 111|} hcr.c:flushbits_hcr: 388| 528|{ 389| 528| ld->len -= bits; 390| | 391| 528| if (ld->len <0) ------------------ | Branch (391:9): [True: 0, False: 528] ------------------ 392| 0| { 393| 0| ld->len = 0; 394| 0| return 1; 395| 528| } else { 396| 528| return 0; 397| 528| } 398| 528|} huffman.c:faad_get1bit: 149| 223k|{ 150| 223k| uint8_t r; 151| | 152| 223k| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 217k, False: 6.00k] ------------------ 153| 217k| { 154| 217k| ld->bits_left--; 155| 217k| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 217k| return r; 157| 217k| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 6.00k| r = (uint8_t)faad_getbits(ld, 1); 165| 6.00k|#endif 166| 6.00k| return r; 167| 223k|} huffman.c:faad_getbits: 131| 12.7k|{ 132| 12.7k| uint32_t ret; 133| | 134| 12.7k| if (n == 0) ------------------ | Branch (134:9): [True: 0, False: 12.7k] ------------------ 135| 0| return 0; 136| | 137| 12.7k| ret = faad_showbits(ld, n); 138| 12.7k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 12.7k| return ret; 146| 12.7k|} huffman.c:faad_showbits: 103| 126k|{ 104| 126k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 104k, False: 21.8k] ------------------ 105| 104k| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 104k| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 104k| } 109| | 110| 21.8k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 21.8k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 126k|} huffman.c:faad_flushbits: 116| 126k|{ 117| | /* do nothing if error */ 118| 126k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 126k] ------------------ 119| 0| return; 120| | 121| 126k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 104k, False: 21.8k] ------------------ 122| 104k| { 123| 104k| ld->bits_left -= bits; 124| 104k| } else { 125| 21.8k| faad_flushbits_ex(ld, bits); 126| 21.8k| } 127| 126k|} huffman.c:showbits_hcr: 362| 95.9k|{ 363| 95.9k| uint32_t mask; 364| 95.9k| int8_t tail; 365| 95.9k| if (bits == 0) return 0; ------------------ | Branch (365:9): [True: 0, False: 95.9k] ------------------ 366| 95.9k| if (ld->len == 0) return 0; ------------------ | Branch (366:9): [True: 4.84k, False: 91.1k] ------------------ 367| 91.1k| tail = ld->len - bits; 368| 91.1k| mask = 0xFFFFFFFF >> (32 - bits); 369| 91.1k| if (ld->len <= 32) ------------------ | Branch (369:9): [True: 70.8k, False: 20.2k] ------------------ 370| 70.8k| { 371| | /* huffman_spectral_data_2 might request more than available (tail < 0), 372| | pad with zeroes then. */ 373| 70.8k| if (tail >= 0) ------------------ | Branch (373:13): [True: 61.7k, False: 9.04k] ------------------ 374| 61.7k| return (ld->bufa >> tail) & mask; /* tail is 0..31 */ 375| 9.04k| else 376| 9.04k| return (ld->bufa << -tail) & mask; /* -tail is 1..31 */ 377| 70.8k| } else { 378| | /* tail is 1..63 */ 379| 20.2k| if (tail < 32) ------------------ | Branch (379:13): [True: 2.25k, False: 18.0k] ------------------ 380| 2.25k| return ((ld->bufb << (32 - tail)) | (ld->bufa >> tail)) & mask; 381| 18.0k| else 382| 18.0k| return (ld->bufb >> (tail - 32)) & mask; 383| 20.2k| } 384| 91.1k|} huffman.c:flushbits_hcr: 388| 95.9k|{ 389| 95.9k| ld->len -= bits; 390| | 391| 95.9k| if (ld->len <0) ------------------ | Branch (391:9): [True: 8.24k, False: 87.6k] ------------------ 392| 8.24k| { 393| 8.24k| ld->len = 0; 394| 8.24k| return 1; 395| 87.6k| } else { 396| 87.6k| return 0; 397| 87.6k| } 398| 95.9k|} huffman.c:get1bit_hcr: 407| 49.5k|{ 408| 49.5k| uint32_t res; 409| 49.5k| int8_t ret; 410| | 411| 49.5k| ret = getbits_hcr(ld, 1, &res); 412| 49.5k| *result = (int8_t)(res & 1); 413| 49.5k| return ret; 414| 49.5k|} huffman.c:getbits_hcr: 401| 53.1k|{ 402| 53.1k| *result = showbits_hcr(ld, n); 403| 53.1k| return flushbits_hcr(ld, n); 404| 53.1k|} rvlc.c:faad_get1bit: 149| 3.88k|{ 150| 3.88k| uint8_t r; 151| | 152| 3.88k| if (ld->bits_left > 0) ------------------ | Branch (152:9): [True: 3.80k, False: 77] ------------------ 153| 3.80k| { 154| 3.80k| ld->bits_left--; 155| 3.80k| r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); 156| 3.80k| return r; 157| 3.80k| } 158| | 159| | /* bits_left == 0 */ 160| |#if 0 161| | r = (uint8_t)(ld->bufb >> 31); 162| | faad_flushbits_ex(ld, 1); 163| |#else 164| 77| r = (uint8_t)faad_getbits(ld, 1); 165| 77|#endif 166| 77| return r; 167| 3.88k|} rvlc.c:faad_getbits: 131| 15.6k|{ 132| 15.6k| uint32_t ret; 133| | 134| 15.6k| if (n == 0) ------------------ | Branch (134:9): [True: 4.54k, False: 11.1k] ------------------ 135| 4.54k| return 0; 136| | 137| 11.1k| ret = faad_showbits(ld, n); 138| 11.1k| faad_flushbits(ld, n); 139| | 140| |#ifdef ANALYSIS 141| | if (print) 142| | fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); 143| |#endif 144| | 145| 11.1k| return ret; 146| 15.6k|} rvlc.c:faad_showbits: 103| 11.1k|{ 104| 11.1k| if (bits <= ld->bits_left) ------------------ | Branch (104:9): [True: 9.88k, False: 1.24k] ------------------ 105| 9.88k| { 106| | //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; 107| 9.88k| return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits); 108| 9.88k| } 109| | 110| 1.24k| bits -= ld->bits_left; 111| | //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); 112| 1.24k| return ((ld->bufa & ((1u<bits_left)-1)) << bits) | (ld->bufb >> (32 - bits)); 113| 11.1k|} rvlc.c:faad_flushbits: 116| 11.1k|{ 117| | /* do nothing if error */ 118| 11.1k| if (ld->error != 0) ------------------ | Branch (118:9): [True: 0, False: 11.1k] ------------------ 119| 0| return; 120| | 121| 11.1k| if (bits < ld->bits_left) ------------------ | Branch (121:9): [True: 9.67k, False: 1.45k] ------------------ 122| 9.67k| { 123| 9.67k| ld->bits_left -= bits; 124| 9.67k| } else { 125| 1.45k| faad_flushbits_ex(ld, bits); 126| 1.45k| } 127| 11.1k|} cfftb: 902| 130k|{ 903| 130k| cfftf1pos(cfft->n, c, cfft->work, (const uint16_t*)cfft->ifac, (const complex_t*)cfft->tab, +1); 904| 130k|} cffti: 1006| 3.29k|{ 1007| 3.29k| cfft_info *cfft = (cfft_info*)faad_malloc(sizeof(cfft_info)); 1008| | 1009| 3.29k| cfft->n = n; 1010| 3.29k| cfft->work = (complex_t*)faad_malloc(n*sizeof(complex_t)); 1011| | 1012| |#ifndef FIXED_POINT 1013| | cfft->tab = (complex_t*)faad_malloc(n*sizeof(complex_t)); 1014| | 1015| | cffti1(n, cfft->tab, cfft->ifac); 1016| |#else 1017| 3.29k| cffti1(n, NULL, cfft->ifac); 1018| | 1019| 3.29k| switch (n) ------------------ | Branch (1019:13): [True: 3.29k, False: 0] ------------------ 1020| 3.29k| { 1021| 1.10k| case 64: cfft->tab = (complex_t*)cfft_tab_64; break; ------------------ | Branch (1021:5): [True: 1.10k, False: 2.19k] ------------------ 1022| 1.10k| case 512: cfft->tab = (complex_t*)cfft_tab_512; break; ------------------ | Branch (1022:5): [True: 1.10k, False: 2.19k] ------------------ 1023| |#ifdef LD_DEC 1024| | case 256: cfft->tab = (complex_t*)cfft_tab_256; break; 1025| |#endif 1026| | 1027| 0|#ifdef ALLOW_SMALL_FRAMELENGTH 1028| 542| case 60: cfft->tab = (complex_t*)cfft_tab_60; break; ------------------ | Branch (1028:5): [True: 542, False: 2.75k] ------------------ 1029| 542| case 480: cfft->tab = (complex_t*)cfft_tab_480; break; ------------------ | Branch (1029:5): [True: 542, False: 2.75k] ------------------ 1030| |#ifdef LD_DEC 1031| | case 240: cfft->tab = (complex_t*)cfft_tab_240; break; 1032| |#endif 1033| 0|#endif 1034| 0| case 128: cfft->tab = (complex_t*)cfft_tab_128; break; ------------------ | Branch (1034:5): [True: 0, False: 3.29k] ------------------ 1035| 3.29k| } 1036| 3.29k|#endif 1037| | 1038| 3.29k| return cfft; 1039| 3.29k|} cfftu: 1042| 3.29k|{ 1043| 3.29k| if (cfft->work) faad_free(cfft->work); ------------------ | Branch (1043:9): [True: 3.29k, False: 0] ------------------ 1044| |#ifndef FIXED_POINT 1045| | if (cfft->tab) faad_free(cfft->tab); 1046| |#endif 1047| | 1048| 3.29k| if (cfft) faad_free(cfft); ------------------ | Branch (1048:9): [True: 3.29k, False: 0] ------------------ 1049| 3.29k|} cfft.c:passf3: 184| 27.1k|{ 185| 27.1k| static real_t taur = FRAC_CONST(-0.5); ------------------ | | 61| 27.1k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 27.1k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 27.1k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 27.1k] | | | Branch (61:62): [Folded, False: 27.1k] | | ------------------ ------------------ 186| 27.1k| static real_t taui = FRAC_CONST(0.866025403784439); ------------------ | | 61| 27.1k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 27.1k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 27.1k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 27.1k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 187| 27.1k| uint16_t i, k, ac, ah; 188| 27.1k| complex_t c2, c3, d2, d3, t2; 189| | 190| 27.1k| if (ido == 1) ------------------ | Branch (190:9): [True: 0, False: 27.1k] ------------------ 191| 0| { 192| 0|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 193| | // TODO: remove this code once fuzzer proves it is totally unreahable 194| | // 3 is never the the biggest factor for supported frame lengths; 195| | // consequently `ido` should never be 1. 196| 0| __builtin_trap(); 197| | /* 198| |#endif 199| | if (isign == 1) 200| | { 201| | for (k = 0; k < l1; k++) 202| | { 203| | ac = 3*k+1; 204| | ah = k; 205| | 206| | RE(t2) = RE(cc[ac]) + RE(cc[ac+1]); 207| | IM(t2) = IM(cc[ac]) + IM(cc[ac+1]); 208| | RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),taur); 209| | IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),taur); 210| | 211| | RE(ch[ah]) = RE(cc[ac-1]) + RE(t2); 212| | IM(ch[ah]) = IM(cc[ac-1]) + IM(t2); 213| | 214| | RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+1])), taui); 215| | IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+1])), taui); 216| | 217| | RE(ch[ah+l1]) = RE(c2) - IM(c3); 218| | IM(ch[ah+l1]) = IM(c2) + RE(c3); 219| | RE(ch[ah+2*l1]) = RE(c2) + IM(c3); 220| | IM(ch[ah+2*l1]) = IM(c2) - RE(c3); 221| | } 222| | } else { 223| | for (k = 0; k < l1; k++) 224| | { 225| | ac = 3*k+1; 226| | ah = k; 227| | 228| | RE(t2) = RE(cc[ac]) + RE(cc[ac+1]); 229| | IM(t2) = IM(cc[ac]) + IM(cc[ac+1]); 230| | RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),taur); 231| | IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),taur); 232| | 233| | RE(ch[ah]) = RE(cc[ac-1]) + RE(t2); 234| | IM(ch[ah]) = IM(cc[ac-1]) + IM(t2); 235| | 236| | RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+1])), taui); 237| | IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+1])), taui); 238| | 239| | RE(ch[ah+l1]) = RE(c2) + IM(c3); 240| | IM(ch[ah+l1]) = IM(c2) - RE(c3); 241| | RE(ch[ah+2*l1]) = RE(c2) - IM(c3); 242| | IM(ch[ah+2*l1]) = IM(c2) + RE(c3); 243| | } 244| | } 245| |#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 246| | */ 247| 0|#endif 248| 27.1k| } else { 249| 27.1k| if (isign == 1) ------------------ | Branch (249:13): [True: 27.1k, False: 0] ------------------ 250| 27.1k| { 251| 64.5k| for (k = 0; k < l1; k++) ------------------ | Branch (251:25): [True: 37.4k, False: 27.1k] ------------------ 252| 37.4k| { 253| 2.02M| for (i = 0; i < ido; i++) ------------------ | Branch (253:29): [True: 1.98M, False: 37.4k] ------------------ 254| 1.98M| { 255| 1.98M| ac = i + (3*k+1)*ido; 256| 1.98M| ah = i + k * ido; 257| | 258| 1.98M| RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ 259| 1.98M| RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur); ------------------ | | 268| 1.98M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ ------------------ 260| 1.98M| IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ 261| 1.98M| IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur); ------------------ | | 268| 1.98M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ ------------------ 262| | 263| 1.98M| RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ 264| 1.98M| IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ 265| | 266| 1.98M| RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+ido])), taui); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+ido])), taui); ------------------ | | 268| 1.98M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ ------------------ 267| 1.98M| IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+ido])), taui); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+ido])), taui); ------------------ | | 268| 1.98M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.98M|#define FRAC_BITS 31 | | ------------------ ------------------ 268| | 269| 1.98M| RE(d2) = RE(c2) - IM(c3); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(d2) = RE(c2) - IM(c3); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(d2) = RE(c2) - IM(c3); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ 270| 1.98M| IM(d3) = IM(c2) - RE(c3); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(d3) = IM(c2) - RE(c3); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(d3) = IM(c2) - RE(c3); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ 271| 1.98M| RE(d3) = RE(c2) + IM(c3); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(d3) = RE(c2) + IM(c3); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ RE(d3) = RE(c2) + IM(c3); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ 272| 1.98M| IM(d2) = IM(c2) + RE(c3); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(d2) = IM(c2) + RE(c3); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(d2) = IM(c2) + RE(c3); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ 273| | 274| 1.98M|#if 1 275| 1.98M| ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]), ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]), ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ 276| 1.98M| IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ 277| 1.98M| ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]), ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]), ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ 278| 1.98M| IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 391| 1.98M|#define RE(A) (A)[0] ------------------ IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 392| 1.98M|#define IM(A) (A)[1] ------------------ 279| |#else 280| | ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]), 281| | RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i])); 282| | ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]), 283| | RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i])); 284| |#endif 285| 1.98M| } 286| 37.4k| } 287| 27.1k| } else { 288| 0| for (k = 0; k < l1; k++) ------------------ | Branch (288:25): [True: 0, False: 0] ------------------ 289| 0| { 290| 0| for (i = 0; i < ido; i++) ------------------ | Branch (290:29): [True: 0, False: 0] ------------------ 291| 0| { 292| 0| ac = i + (3*k+1)*ido; 293| 0| ah = i + k * ido; 294| | 295| 0| RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 296| 0| RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 297| 0| IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 298| 0| IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 299| | 300| 0| RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 301| 0| IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 302| | 303| 0| RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+ido])), taui); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+ido])), taui); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 304| 0| IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+ido])), taui); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+ido])), taui); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 305| | 306| 0| RE(d2) = RE(c2) + IM(c3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d2) = RE(c2) + IM(c3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d2) = RE(c2) + IM(c3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 307| 0| IM(d3) = IM(c2) + RE(c3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(d3) = IM(c2) + RE(c3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(d3) = IM(c2) + RE(c3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 308| 0| RE(d3) = RE(c2) - IM(c3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d3) = RE(c2) - IM(c3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d3) = RE(c2) - IM(c3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 309| 0| IM(d2) = IM(c2) - RE(c3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(d2) = IM(c2) - RE(c3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(d2) = IM(c2) - RE(c3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 310| | 311| 0|#if 1 312| 0| ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]), ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]), ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 313| 0| RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 314| 0| ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]), ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]), ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 315| 0| RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 316| |#else 317| | ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]), 318| | IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i])); 319| | ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]), 320| | IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i])); 321| |#endif 322| 0| } 323| 0| } 324| 0| } 325| 27.1k| } 326| 27.1k|} cfft.c:passf5: 506| 27.1k|{ 507| 27.1k| static real_t tr11 = FRAC_CONST(0.309016994374947); ------------------ | | 61| 27.1k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 27.1k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 27.1k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 27.1k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 508| 27.1k| static real_t ti11 = FRAC_CONST(0.951056516295154); ------------------ | | 61| 27.1k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 27.1k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 27.1k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 27.1k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 509| 27.1k| static real_t tr12 = FRAC_CONST(-0.809016994374947); ------------------ | | 61| 27.1k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 27.1k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 27.1k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 27.1k] | | | Branch (61:62): [Folded, False: 27.1k] | | ------------------ ------------------ 510| 27.1k| static real_t ti12 = FRAC_CONST(0.587785252292473); ------------------ | | 61| 27.1k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 27.1k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 27.1k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 27.1k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 511| 27.1k| uint16_t k, ac, ah; 512| 27.1k| complex_t c2, c3, c4, c5, t2, t3, t4, t5; 513| 27.1k| (void)wa1; 514| 27.1k| (void)wa2; 515| 27.1k| (void)wa3; 516| 27.1k| (void)wa4; 517| | 518| 27.1k| if (ido == 1) ------------------ | Branch (518:9): [True: 27.1k, False: 0] ------------------ 519| 27.1k| { 520| 27.1k| if (isign == 1) ------------------ | Branch (520:13): [True: 27.1k, False: 0] ------------------ 521| 27.1k| { 522| 1.21M| for (k = 0; k < l1; k++) ------------------ | Branch (522:25): [True: 1.19M, False: 27.1k] ------------------ 523| 1.19M| { 524| 1.19M| ac = 5*k + 1; 525| 1.19M| ah = k; 526| | 527| 1.19M| RE(t2) = RE(cc[ac]) + RE(cc[ac+3]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+3]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+3]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 528| 1.19M| IM(t2) = IM(cc[ac]) + IM(cc[ac+3]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+3]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+3]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 529| 1.19M| RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 530| 1.19M| IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 531| 1.19M| RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 532| 1.19M| IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 533| 1.19M| RE(t5) = RE(cc[ac]) - RE(cc[ac+3]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t5) = RE(cc[ac]) - RE(cc[ac+3]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(t5) = RE(cc[ac]) - RE(cc[ac+3]); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 534| 1.19M| IM(t5) = IM(cc[ac]) - IM(cc[ac+3]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t5) = IM(cc[ac]) - IM(cc[ac+3]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(t5) = IM(cc[ac]) - IM(cc[ac+3]); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 535| | 536| 1.19M| RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 537| 1.19M| IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 538| | 539| 1.19M| RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ 540| 1.19M| IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ 541| 1.19M| RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ 542| 1.19M| IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 268| 1.19M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.19M|#define FRAC_BITS 31 | | ------------------ ------------------ 543| | 544| 1.19M| ComplexMult(&RE(c5), &RE(c4), ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(c5), &RE(c4), ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 545| 1.19M| ti11, ti12, RE(t5), RE(t4)); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ ti11, ti12, RE(t5), RE(t4)); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 546| 1.19M| ComplexMult(&IM(c5), &IM(c4), ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(c5), &IM(c4), ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 547| 1.19M| ti11, ti12, IM(t5), IM(t4)); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ ti11, ti12, IM(t5), IM(t4)); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 548| | 549| 1.19M| RE(ch[ah+l1]) = RE(c2) - IM(c5); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+l1]) = RE(c2) - IM(c5); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+l1]) = RE(c2) - IM(c5); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 550| 1.19M| IM(ch[ah+l1]) = IM(c2) + RE(c5); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+l1]) = IM(c2) + RE(c5); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+l1]) = IM(c2) + RE(c5); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 551| 1.19M| RE(ch[ah+2*l1]) = RE(c3) - IM(c4); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+2*l1]) = RE(c3) - IM(c4); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+2*l1]) = RE(c3) - IM(c4); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 552| 1.19M| IM(ch[ah+2*l1]) = IM(c3) + RE(c4); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+2*l1]) = IM(c3) + RE(c4); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+2*l1]) = IM(c3) + RE(c4); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 553| 1.19M| RE(ch[ah+3*l1]) = RE(c3) + IM(c4); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+3*l1]) = RE(c3) + IM(c4); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+3*l1]) = RE(c3) + IM(c4); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 554| 1.19M| IM(ch[ah+3*l1]) = IM(c3) - RE(c4); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+3*l1]) = IM(c3) - RE(c4); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+3*l1]) = IM(c3) - RE(c4); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 555| 1.19M| RE(ch[ah+4*l1]) = RE(c2) + IM(c5); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+4*l1]) = RE(c2) + IM(c5); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ RE(ch[ah+4*l1]) = RE(c2) + IM(c5); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ 556| 1.19M| IM(ch[ah+4*l1]) = IM(c2) - RE(c5); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+4*l1]) = IM(c2) - RE(c5); ------------------ | | 392| 1.19M|#define IM(A) (A)[1] ------------------ IM(ch[ah+4*l1]) = IM(c2) - RE(c5); ------------------ | | 391| 1.19M|#define RE(A) (A)[0] ------------------ 557| 1.19M| } 558| 27.1k| } else { 559| 0| for (k = 0; k < l1; k++) ------------------ | Branch (559:25): [True: 0, False: 0] ------------------ 560| 0| { 561| 0| ac = 5*k + 1; 562| 0| ah = k; 563| | 564| 0| RE(t2) = RE(cc[ac]) + RE(cc[ac+3]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+3]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+3]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 565| 0| IM(t2) = IM(cc[ac]) + IM(cc[ac+3]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+3]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+3]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 566| 0| RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 567| 0| IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 568| 0| RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 569| 0| IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 570| 0| RE(t5) = RE(cc[ac]) - RE(cc[ac+3]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t5) = RE(cc[ac]) - RE(cc[ac+3]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(t5) = RE(cc[ac]) - RE(cc[ac+3]); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 571| 0| IM(t5) = IM(cc[ac]) - IM(cc[ac+3]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t5) = IM(cc[ac]) - IM(cc[ac+3]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(t5) = IM(cc[ac]) - IM(cc[ac+3]); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 572| | 573| 0| RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 574| 0| IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 575| | 576| 0| RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 577| 0| IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 578| 0| RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 579| 0| IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); ------------------ | | 268| 0| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 0|#define FRAC_BITS 31 | | ------------------ ------------------ 580| | 581| 0| ComplexMult(&RE(c4), &RE(c5), ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(c4), &RE(c5), ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 582| 0| ti12, ti11, RE(t5), RE(t4)); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ ti12, ti11, RE(t5), RE(t4)); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 583| 0| ComplexMult(&IM(c4), &IM(c5), ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(c4), &IM(c5), ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 584| 0| ti12, ti11, IM(t5), IM(t4)); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ ti12, ti11, IM(t5), IM(t4)); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 585| | 586| 0| RE(ch[ah+l1]) = RE(c2) + IM(c5); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+l1]) = RE(c2) + IM(c5); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+l1]) = RE(c2) + IM(c5); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 587| 0| IM(ch[ah+l1]) = IM(c2) - RE(c5); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+l1]) = IM(c2) - RE(c5); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+l1]) = IM(c2) - RE(c5); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 588| 0| RE(ch[ah+2*l1]) = RE(c3) + IM(c4); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+2*l1]) = RE(c3) + IM(c4); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+2*l1]) = RE(c3) + IM(c4); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 589| 0| IM(ch[ah+2*l1]) = IM(c3) - RE(c4); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+2*l1]) = IM(c3) - RE(c4); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+2*l1]) = IM(c3) - RE(c4); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 590| 0| RE(ch[ah+3*l1]) = RE(c3) - IM(c4); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+3*l1]) = RE(c3) - IM(c4); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+3*l1]) = RE(c3) - IM(c4); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 591| 0| IM(ch[ah+3*l1]) = IM(c3) + RE(c4); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+3*l1]) = IM(c3) + RE(c4); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+3*l1]) = IM(c3) + RE(c4); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 592| 0| RE(ch[ah+4*l1]) = RE(c2) - IM(c5); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+4*l1]) = RE(c2) - IM(c5); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ RE(ch[ah+4*l1]) = RE(c2) - IM(c5); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 593| 0| IM(ch[ah+4*l1]) = IM(c2) + RE(c5); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+4*l1]) = IM(c2) + RE(c5); ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ IM(ch[ah+4*l1]) = IM(c2) + RE(c5); ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 594| 0| } 595| 0| } 596| 27.1k| } else { 597| 0|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 598| | // TODO: remove this code once fuzzer proves it is totally unreahable 599| | // 5 if the biggest factor and it never repeated for supported frame 600| | // lengths; consequently `ido` should always be 1. 601| 0| __builtin_trap(); 602| | /* 603| |#else 604| | uint16_t i; 605| | complex_t d3, d4, d5, d2; 606| |#endif 607| | if (isign == 1) 608| | { 609| | for (k = 0; k < l1; k++) 610| | { 611| | for (i = 0; i < ido; i++) 612| | { 613| | ac = i + (k*5 + 1) * ido; 614| | ah = i + k * ido; 615| | 616| | RE(t2) = RE(cc[ac]) + RE(cc[ac+3*ido]); 617| | IM(t2) = IM(cc[ac]) + IM(cc[ac+3*ido]); 618| | RE(t3) = RE(cc[ac+ido]) + RE(cc[ac+2*ido]); 619| | IM(t3) = IM(cc[ac+ido]) + IM(cc[ac+2*ido]); 620| | RE(t4) = RE(cc[ac+ido]) - RE(cc[ac+2*ido]); 621| | IM(t4) = IM(cc[ac+ido]) - IM(cc[ac+2*ido]); 622| | RE(t5) = RE(cc[ac]) - RE(cc[ac+3*ido]); 623| | IM(t5) = IM(cc[ac]) - IM(cc[ac+3*ido]); 624| | 625| | RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2) + RE(t3); 626| | IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2) + IM(t3); 627| | 628| | RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); 629| | IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); 630| | RE(c3) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); 631| | IM(c3) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); 632| | 633| | ComplexMult(&RE(c5), &RE(c4), 634| | ti11, ti12, RE(t5), RE(t4)); 635| | ComplexMult(&IM(c5), &IM(c4), 636| | ti11, ti12, IM(t5), IM(t4)); 637| | 638| | IM(d2) = IM(c2) + RE(c5); 639| | IM(d3) = IM(c3) + RE(c4); 640| | RE(d4) = RE(c3) + IM(c4); 641| | RE(d5) = RE(c2) + IM(c5); 642| | RE(d2) = RE(c2) - IM(c5); 643| | IM(d5) = IM(c2) - RE(c5); 644| | RE(d3) = RE(c3) - IM(c4); 645| | IM(d4) = IM(c3) - RE(c4); 646| | 647| |#if 1 648| | ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]), 649| | IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i])); 650| | ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]), 651| | IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i])); 652| | ComplexMult(&IM(ch[ah+3*l1*ido]), &RE(ch[ah+3*l1*ido]), 653| | IM(d4), RE(d4), RE(wa3[i]), IM(wa3[i])); 654| | ComplexMult(&IM(ch[ah+4*l1*ido]), &RE(ch[ah+4*l1*ido]), 655| | IM(d5), RE(d5), RE(wa4[i]), IM(wa4[i])); 656| |#else 657| | ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]), 658| | RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i])); 659| | ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]), 660| | RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i])); 661| | ComplexMult(&RE(ch[ah+3*l1*ido]), &IM(ch[ah+3*l1*ido]), 662| | RE(d4), IM(d4), RE(wa3[i]), IM(wa3[i])); 663| | ComplexMult(&RE(ch[ah+4*l1*ido]), &IM(ch[ah+4*l1*ido]), 664| | RE(d5), IM(d5), RE(wa4[i]), IM(wa4[i])); 665| |#endif 666| | } 667| | } 668| | } else { 669| | for (k = 0; k < l1; k++) 670| | { 671| | for (i = 0; i < ido; i++) 672| | { 673| | ac = i + (k*5 + 1) * ido; 674| | ah = i + k * ido; 675| | 676| | RE(t2) = RE(cc[ac]) + RE(cc[ac+3*ido]); 677| | IM(t2) = IM(cc[ac]) + IM(cc[ac+3*ido]); 678| | RE(t3) = RE(cc[ac+ido]) + RE(cc[ac+2*ido]); 679| | IM(t3) = IM(cc[ac+ido]) + IM(cc[ac+2*ido]); 680| | RE(t4) = RE(cc[ac+ido]) - RE(cc[ac+2*ido]); 681| | IM(t4) = IM(cc[ac+ido]) - IM(cc[ac+2*ido]); 682| | RE(t5) = RE(cc[ac]) - RE(cc[ac+3*ido]); 683| | IM(t5) = IM(cc[ac]) - IM(cc[ac+3*ido]); 684| | 685| | RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2) + RE(t3); 686| | IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2) + IM(t3); 687| | 688| | RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12); 689| | IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12); 690| | RE(c3) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11); 691| | IM(c3) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11); 692| | 693| | ComplexMult(&RE(c4), &RE(c5), 694| | ti12, ti11, RE(t5), RE(t4)); 695| | ComplexMult(&IM(c4), &IM(c5), 696| | ti12, ti11, IM(t5), IM(t4)); 697| | 698| | IM(d2) = IM(c2) - RE(c5); 699| | IM(d3) = IM(c3) - RE(c4); 700| | RE(d4) = RE(c3) - IM(c4); 701| | RE(d5) = RE(c2) - IM(c5); 702| | RE(d2) = RE(c2) + IM(c5); 703| | IM(d5) = IM(c2) + RE(c5); 704| | RE(d3) = RE(c3) + IM(c4); 705| | IM(d4) = IM(c3) + RE(c4); 706| | 707| |#if 1 708| | ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]), 709| | RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i])); 710| | ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]), 711| | RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i])); 712| | ComplexMult(&RE(ch[ah+3*l1*ido]), &IM(ch[ah+3*l1*ido]), 713| | RE(d4), IM(d4), RE(wa3[i]), IM(wa3[i])); 714| | ComplexMult(&RE(ch[ah+4*l1*ido]), &IM(ch[ah+4*l1*ido]), 715| | RE(d5), IM(d5), RE(wa4[i]), IM(wa4[i])); 716| |#else 717| | ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]), 718| | IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i])); 719| | ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]), 720| | IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i])); 721| | ComplexMult(&IM(ch[ah+3*l1*ido]), &RE(ch[ah+3*l1*ido]), 722| | IM(d4), RE(d4), RE(wa3[i]), IM(wa3[i])); 723| | ComplexMult(&IM(ch[ah+4*l1*ido]), &RE(ch[ah+4*l1*ido]), 724| | IM(d5), RE(d5), RE(wa4[i]), IM(wa4[i])); 725| |#endif 726| | } 727| | } 728| | } 729| |#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 730| | */ 731| 0|#endif 732| 0| } 733| 27.1k|} cfft.c:cfftf1pos: 743| 130k|{ 744| 130k| uint16_t i; 745| 130k| uint16_t k1, l1, l2; 746| 130k| uint16_t na, nf, ip, iw, ix2, ix3, ix4, ido; 747| | 748| 130k| nf = ifac[1]; 749| 130k| na = 0; 750| 130k| l1 = 1; 751| 130k| iw = 0; 752| | 753| 589k| for (k1 = 2; k1 <= nf+1; k1++) ------------------ | Branch (753:18): [True: 458k, False: 130k] ------------------ 754| 458k| { 755| 458k| ip = ifac[k1]; 756| 458k| l2 = ip*l1; 757| 458k| ido = n / l2; 758| | 759| 458k| switch (ip) ------------------ | Branch (759:17): [True: 458k, False: 0] ------------------ 760| 458k| { 761| 371k| case 4: ------------------ | Branch (761:9): [True: 371k, False: 87.3k] ------------------ 762| 371k| ix2 = iw + ido; 763| 371k| ix3 = ix2 + ido; 764| | 765| 371k| if (na == 0) ------------------ | Branch (765:17): [True: 217k, False: 153k] ------------------ 766| 217k| passf4pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], &wa[ix3]); 767| 153k| else 768| 153k| passf4pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], &wa[ix3]); 769| | 770| 371k| na = 1 - na; 771| 371k| break; 772| 33.1k| case 2: ------------------ | Branch (772:9): [True: 33.1k, False: 425k] ------------------ 773| 33.1k| if (na == 0) ------------------ | Branch (773:17): [True: 33.1k, False: 0] ------------------ 774| 33.1k| passf2pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw]); 775| 0| else 776| 0| passf2pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw]); 777| | 778| 33.1k| na = 1 - na; 779| 33.1k| break; 780| 27.1k| case 3: ------------------ | Branch (780:9): [True: 27.1k, False: 431k] ------------------ 781| 27.1k| ix2 = iw + ido; 782| | 783| 27.1k| if (na == 0) ------------------ | Branch (783:17): [True: 16.8k, False: 10.3k] ------------------ 784| 16.8k| passf3((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], isign); 785| 10.3k| else 786| 10.3k| passf3((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], isign); 787| | 788| 27.1k| na = 1 - na; 789| 27.1k| break; 790| 27.1k| case 5: ------------------ | Branch (790:9): [True: 27.1k, False: 431k] ------------------ 791| 27.1k| ix2 = iw + ido; 792| 27.1k| ix3 = ix2 + ido; 793| 27.1k| ix4 = ix3 + ido; 794| | 795| 27.1k| if (na == 0) ------------------ | Branch (795:17): [True: 27.1k, False: 0] ------------------ 796| 27.1k| passf5((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4], isign); 797| 0| else 798| 0| passf5((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4], isign); 799| | 800| 27.1k| na = 1 - na; 801| 27.1k| break; 802| 458k| } 803| | 804| 458k| l1 = l2; 805| 458k| iw += (ip-1) * ido; 806| 458k| } 807| | 808| 130k| if (na == 0) ------------------ | Branch (808:9): [True: 0, False: 130k] ------------------ 809| 0| return; 810| | 811| 22.9M| for (i = 0; i < n; i++) ------------------ | Branch (811:17): [True: 22.8M, False: 130k] ------------------ 812| 22.8M| { 813| 22.8M| RE(c[i]) = RE(ch[i]); ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ RE(c[i]) = RE(ch[i]); ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ 814| 22.8M| IM(c[i]) = IM(ch[i]); ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ IM(c[i]) = IM(ch[i]); ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ 815| 22.8M| } 816| 130k|} cfft.c:passf4pos: 332| 371k|{ 333| 371k| uint16_t i, k, ac, ah; 334| | 335| 371k| if (ido == 1) ------------------ | Branch (335:9): [True: 103k, False: 267k] ------------------ 336| 103k| { 337| 4.31M| for (k = 0; k < l1; k++) ------------------ | Branch (337:21): [True: 4.21M, False: 103k] ------------------ 338| 4.21M| { 339| 4.21M| complex_t t1, t2, t3, t4; 340| | 341| 4.21M| ac = 4*k; 342| 4.21M| ah = k; 343| | 344| 4.21M| RE(t2) = RE(cc[ac]) + RE(cc[ac+2]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+2]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac]) + RE(cc[ac+2]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 345| 4.21M| RE(t1) = RE(cc[ac]) - RE(cc[ac+2]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(t1) = RE(cc[ac]) - RE(cc[ac+2]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(t1) = RE(cc[ac]) - RE(cc[ac+2]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 346| 4.21M| IM(t2) = IM(cc[ac]) + IM(cc[ac+2]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+2]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac]) + IM(cc[ac+2]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 347| 4.21M| IM(t1) = IM(cc[ac]) - IM(cc[ac+2]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(t1) = IM(cc[ac]) - IM(cc[ac+2]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(t1) = IM(cc[ac]) - IM(cc[ac+2]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 348| 4.21M| RE(t3) = RE(cc[ac+1]) + RE(cc[ac+3]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+1]) + RE(cc[ac+3]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+1]) + RE(cc[ac+3]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 349| 4.21M| IM(t4) = RE(cc[ac+1]) - RE(cc[ac+3]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(t4) = RE(cc[ac+1]) - RE(cc[ac+3]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ IM(t4) = RE(cc[ac+1]) - RE(cc[ac+3]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 350| 4.21M| IM(t3) = IM(cc[ac+3]) + IM(cc[ac+1]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+3]) + IM(cc[ac+1]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+3]) + IM(cc[ac+1]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 351| 4.21M| RE(t4) = IM(cc[ac+3]) - IM(cc[ac+1]); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(t4) = IM(cc[ac+3]) - IM(cc[ac+1]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ RE(t4) = IM(cc[ac+3]) - IM(cc[ac+1]); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 352| | 353| 4.21M| RE(ch[ah]) = RE(t2) + RE(t3); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(t2) + RE(t3); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah]) = RE(t2) + RE(t3); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 354| 4.21M| RE(ch[ah+2*l1]) = RE(t2) - RE(t3); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah+2*l1]) = RE(t2) - RE(t3); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah+2*l1]) = RE(t2) - RE(t3); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 355| | 356| 4.21M| IM(ch[ah]) = IM(t2) + IM(t3); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(t2) + IM(t3); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah]) = IM(t2) + IM(t3); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 357| 4.21M| IM(ch[ah+2*l1]) = IM(t2) - IM(t3); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah+2*l1]) = IM(t2) - IM(t3); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah+2*l1]) = IM(t2) - IM(t3); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 358| | 359| 4.21M| RE(ch[ah+l1]) = RE(t1) + RE(t4); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah+l1]) = RE(t1) + RE(t4); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah+l1]) = RE(t1) + RE(t4); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 360| 4.21M| RE(ch[ah+3*l1]) = RE(t1) - RE(t4); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah+3*l1]) = RE(t1) - RE(t4); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ RE(ch[ah+3*l1]) = RE(t1) - RE(t4); ------------------ | | 391| 4.21M|#define RE(A) (A)[0] ------------------ 361| | 362| 4.21M| IM(ch[ah+l1]) = IM(t1) + IM(t4); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah+l1]) = IM(t1) + IM(t4); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah+l1]) = IM(t1) + IM(t4); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 363| 4.21M| IM(ch[ah+3*l1]) = IM(t1) - IM(t4); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah+3*l1]) = IM(t1) - IM(t4); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ IM(ch[ah+3*l1]) = IM(t1) - IM(t4); ------------------ | | 392| 4.21M|#define IM(A) (A)[1] ------------------ 364| 4.21M| } 365| 267k| } else { 366| 1.98M| for (k = 0; k < l1; k++) ------------------ | Branch (366:21): [True: 1.72M, False: 267k] ------------------ 367| 1.72M| { 368| 1.72M| ac = 4*k*ido; 369| 1.72M| ah = k*ido; 370| | 371| 15.7M| for (i = 0; i < ido; i++) ------------------ | Branch (371:25): [True: 14.0M, False: 1.72M] ------------------ 372| 14.0M| { 373| 14.0M| complex_t c2, c3, c4, t1, t2, t3, t4; 374| | 375| 14.0M| RE(t2) = RE(cc[ac+i]) + RE(cc[ac+i+2*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac+i]) + RE(cc[ac+i+2*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac+i]) + RE(cc[ac+i+2*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 376| 14.0M| RE(t1) = RE(cc[ac+i]) - RE(cc[ac+i+2*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(t1) = RE(cc[ac+i]) - RE(cc[ac+i+2*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(t1) = RE(cc[ac+i]) - RE(cc[ac+i+2*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 377| 14.0M| IM(t2) = IM(cc[ac+i]) + IM(cc[ac+i+2*ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac+i]) + IM(cc[ac+i+2*ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac+i]) + IM(cc[ac+i+2*ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 378| 14.0M| IM(t1) = IM(cc[ac+i]) - IM(cc[ac+i+2*ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(t1) = IM(cc[ac+i]) - IM(cc[ac+i+2*ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(t1) = IM(cc[ac+i]) - IM(cc[ac+i+2*ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 379| 14.0M| RE(t3) = RE(cc[ac+i+ido]) + RE(cc[ac+i+3*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+i+ido]) + RE(cc[ac+i+3*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(t3) = RE(cc[ac+i+ido]) + RE(cc[ac+i+3*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 380| 14.0M| IM(t4) = RE(cc[ac+i+ido]) - RE(cc[ac+i+3*ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(t4) = RE(cc[ac+i+ido]) - RE(cc[ac+i+3*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ IM(t4) = RE(cc[ac+i+ido]) - RE(cc[ac+i+3*ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 381| 14.0M| IM(t3) = IM(cc[ac+i+3*ido]) + IM(cc[ac+i+ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+i+3*ido]) + IM(cc[ac+i+ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(t3) = IM(cc[ac+i+3*ido]) + IM(cc[ac+i+ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 382| 14.0M| RE(t4) = IM(cc[ac+i+3*ido]) - IM(cc[ac+i+ido]); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(t4) = IM(cc[ac+i+3*ido]) - IM(cc[ac+i+ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ RE(t4) = IM(cc[ac+i+3*ido]) - IM(cc[ac+i+ido]); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 383| | 384| 14.0M| RE(c2) = RE(t1) + RE(t4); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(c2) = RE(t1) + RE(t4); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(c2) = RE(t1) + RE(t4); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 385| 14.0M| RE(c4) = RE(t1) - RE(t4); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(c4) = RE(t1) - RE(t4); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(c4) = RE(t1) - RE(t4); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 386| | 387| 14.0M| IM(c2) = IM(t1) + IM(t4); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c2) = IM(t1) + IM(t4); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c2) = IM(t1) + IM(t4); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 388| 14.0M| IM(c4) = IM(t1) - IM(t4); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c4) = IM(t1) - IM(t4); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c4) = IM(t1) - IM(t4); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 389| | 390| 14.0M| RE(ch[ah+i]) = RE(t2) + RE(t3); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(ch[ah+i]) = RE(t2) + RE(t3); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(ch[ah+i]) = RE(t2) + RE(t3); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 391| 14.0M| RE(c3) = RE(t2) - RE(t3); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(c3) = RE(t2) - RE(t3); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ RE(c3) = RE(t2) - RE(t3); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 392| | 393| 14.0M| IM(ch[ah+i]) = IM(t2) + IM(t3); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(ch[ah+i]) = IM(t2) + IM(t3); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(ch[ah+i]) = IM(t2) + IM(t3); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 394| 14.0M| IM(c3) = IM(t2) - IM(t3); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c3) = IM(t2) - IM(t3); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c3) = IM(t2) - IM(t3); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 395| | 396| 14.0M|#if 1 397| 14.0M| ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]), ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]), ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 398| 14.0M| IM(c2), RE(c2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c2), RE(c2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ IM(c2), RE(c2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ IM(c2), RE(c2), RE(wa1[i]), IM(wa1[i])); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 399| 14.0M| ComplexMult(&IM(ch[ah+i+2*l1*ido]), &RE(ch[ah+i+2*l1*ido]), ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(ch[ah+i+2*l1*ido]), &RE(ch[ah+i+2*l1*ido]), ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 400| 14.0M| IM(c3), RE(c3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c3), RE(c3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ IM(c3), RE(c3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ IM(c3), RE(c3), RE(wa2[i]), IM(wa2[i])); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 401| 14.0M| ComplexMult(&IM(ch[ah+i+3*l1*ido]), &RE(ch[ah+i+3*l1*ido]), ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(ch[ah+i+3*l1*ido]), &RE(ch[ah+i+3*l1*ido]), ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ 402| 14.0M| IM(c4), RE(c4), RE(wa3[i]), IM(wa3[i])); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ IM(c4), RE(c4), RE(wa3[i]), IM(wa3[i])); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ IM(c4), RE(c4), RE(wa3[i]), IM(wa3[i])); ------------------ | | 391| 14.0M|#define RE(A) (A)[0] ------------------ IM(c4), RE(c4), RE(wa3[i]), IM(wa3[i])); ------------------ | | 392| 14.0M|#define IM(A) (A)[1] ------------------ 403| |#else 404| | ComplexMult(&RE(ch[ah+i+l1*ido]), &IM(ch[ah+i+l1*ido]), 405| | RE(c2), IM(c2), RE(wa1[i]), IM(wa1[i])); 406| | ComplexMult(&RE(ch[ah+i+2*l1*ido]), &IM(ch[ah+i+2*l1*ido]), 407| | RE(c3), IM(c3), RE(wa2[i]), IM(wa2[i])); 408| | ComplexMult(&RE(ch[ah+i+3*l1*ido]), &IM(ch[ah+i+3*l1*ido]), 409| | RE(c4), IM(c4), RE(wa3[i]), IM(wa3[i])); 410| |#endif 411| 14.0M| } 412| 1.72M| } 413| 267k| } 414| 371k|} cfft.c:passf2pos: 72| 33.1k|{ 73| 33.1k| uint16_t i, k, ah, ac; 74| | 75| 33.1k| if (ido == 1) ------------------ | Branch (75:9): [True: 0, False: 33.1k] ------------------ 76| 0| { 77| 0|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 78| | // TODO: remove this code once fuzzer proves it is totally unreahable 79| | // For supported frame lengths that have odd number of factor 2 it is 80| | // never the last factor; consequently `ido` should never be 1. 81| 0| __builtin_trap(); 82| | /* 83| |#endif 84| | for (k = 0; k < l1; k++) 85| | { 86| | ah = 2*k; 87| | ac = 4*k; 88| | 89| | RE(ch[ah]) = RE(cc[ac]) + RE(cc[ac+1]); 90| | RE(ch[ah+l1]) = RE(cc[ac]) - RE(cc[ac+1]); 91| | IM(ch[ah]) = IM(cc[ac]) + IM(cc[ac+1]); 92| | IM(ch[ah+l1]) = IM(cc[ac]) - IM(cc[ac+1]); 93| | } 94| |#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 95| | */ 96| 0|#endif 97| 33.1k| } else { 98| 66.2k| for (k = 0; k < l1; k++) ------------------ | Branch (98:21): [True: 33.1k, False: 33.1k] ------------------ 99| 33.1k| { 100| 33.1k| ah = k*ido; 101| 33.1k| ac = 2*k*ido; 102| | 103| 8.34M| for (i = 0; i < ido; i++) ------------------ | Branch (103:25): [True: 8.31M, False: 33.1k] ------------------ 104| 8.31M| { 105| 8.31M| complex_t t2; 106| | 107| 8.31M| RE(ch[ah+i]) = RE(cc[ac+i]) + RE(cc[ac+i+ido]); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ RE(ch[ah+i]) = RE(cc[ac+i]) + RE(cc[ac+i+ido]); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ RE(ch[ah+i]) = RE(cc[ac+i]) + RE(cc[ac+i+ido]); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ 108| 8.31M| RE(t2) = RE(cc[ac+i]) - RE(cc[ac+i+ido]); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac+i]) - RE(cc[ac+i+ido]); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ RE(t2) = RE(cc[ac+i]) - RE(cc[ac+i+ido]); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ 109| | 110| 8.31M| IM(ch[ah+i]) = IM(cc[ac+i]) + IM(cc[ac+i+ido]); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ IM(ch[ah+i]) = IM(cc[ac+i]) + IM(cc[ac+i+ido]); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ IM(ch[ah+i]) = IM(cc[ac+i]) + IM(cc[ac+i+ido]); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ 111| 8.31M| IM(t2) = IM(cc[ac+i]) - IM(cc[ac+i+ido]); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac+i]) - IM(cc[ac+i+ido]); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ IM(t2) = IM(cc[ac+i]) - IM(cc[ac+i+ido]); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ 112| | 113| 8.31M|#if 1 114| 8.31M| ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]), ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]), ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ 115| 8.31M| IM(t2), RE(t2), RE(wa[i]), IM(wa[i])); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ IM(t2), RE(t2), RE(wa[i]), IM(wa[i])); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ IM(t2), RE(t2), RE(wa[i]), IM(wa[i])); ------------------ | | 391| 8.31M|#define RE(A) (A)[0] ------------------ IM(t2), RE(t2), RE(wa[i]), IM(wa[i])); ------------------ | | 392| 8.31M|#define IM(A) (A)[1] ------------------ 116| |#else 117| | ComplexMult(&RE(ch[ah+i+l1*ido]), &IM(ch[ah+i+l1*ido]), 118| | RE(t2), IM(t2), RE(wa[i]), IM(wa[i])); 119| |#endif 120| 8.31M| } 121| 33.1k| } 122| 33.1k| } 123| 33.1k|} cfft.c:cffti1: 907| 3.29k|{ 908| 3.29k| static uint16_t ntryh[4] = {3, 4, 2, 5}; 909| |#ifndef FIXED_POINT 910| | real_t arg, argh, argld, fi; 911| | uint16_t ido, ipm; 912| | uint16_t i1, k1, l1, l2; 913| | uint16_t ld, ii, ip; 914| |#endif 915| 3.29k| uint16_t ntry = 0, i, j; 916| 3.29k| uint16_t ib; 917| 3.29k| uint16_t nf, nl, nq, nr; 918| | 919| 3.29k| nl = n; 920| 3.29k| nf = 0; 921| 3.29k| j = 0; 922| | 923| 9.87k|startloop: 924| 9.87k| j++; 925| | 926| 9.87k| if (j <= 4) ------------------ | Branch (926:9): [True: 9.87k, False: 0] ------------------ 927| 9.87k| ntry = ntryh[j-1]; 928| 0| else 929| 0| ntry += 2; 930| | 931| 9.87k| do 932| 19.7k| { 933| 19.7k| nq = nl / ntry; 934| 19.7k| nr = nl - ntry*nq; 935| | 936| 19.7k| if (nr != 0) ------------------ | Branch (936:13): [True: 6.57k, False: 13.1k] ------------------ 937| 6.57k| goto startloop; 938| | 939| 13.1k| nf++; 940| 13.1k| ifac[nf+1] = ntry; 941| 13.1k| nl = nq; 942| | 943| 13.1k| if (ntry == 2 && nf != 1) ------------------ | Branch (943:13): [True: 1.64k, False: 11.5k] | Branch (943:26): [True: 1.64k, False: 0] ------------------ 944| 1.64k| { 945| 7.70k| for (i = 2; i <= nf; i++) ------------------ | Branch (945:25): [True: 6.05k, False: 1.64k] ------------------ 946| 6.05k| { 947| 6.05k| ib = nf - i + 2; 948| 6.05k| ifac[ib+1] = ifac[ib]; 949| 6.05k| } 950| 1.64k| ifac[2] = 2; 951| 1.64k| } 952| 13.1k| } while (nl != 1); ------------------ | Branch (952:14): [True: 9.89k, False: 3.29k] ------------------ 953| | 954| 3.29k| ifac[0] = n; 955| 3.29k| ifac[1] = nf; 956| | 957| |#ifndef FIXED_POINT 958| | argh = (real_t)2.0*(real_t)M_PI / (real_t)n; 959| | i = 0; 960| | l1 = 1; 961| | 962| | for (k1 = 1; k1 <= nf; k1++) 963| | { 964| | ip = ifac[k1+1]; 965| | ld = 0; 966| | l2 = l1*ip; 967| | ido = n / l2; 968| | ipm = ip - 1; 969| | 970| | for (j = 0; j < ipm; j++) 971| | { 972| | i1 = i; 973| | RE(wa[i]) = 1.0; 974| | IM(wa[i]) = 0.0; 975| | ld += l1; 976| | fi = 0; 977| | argld = ld*argh; 978| | 979| | for (ii = 0; ii < ido; ii++) 980| | { 981| | i++; 982| | fi++; 983| | arg = fi * argld; 984| | RE(wa[i]) = (real_t)cos(arg); 985| |#if 1 986| | IM(wa[i]) = (real_t)sin(arg); 987| |#else 988| | IM(wa[i]) = (real_t)-sin(arg); 989| |#endif 990| | } 991| | 992| | if (ip > 5) 993| | { 994| | RE(wa[i1]) = RE(wa[i]); 995| | IM(wa[i1]) = IM(wa[i]); 996| | } 997| | } 998| | l1 = l2; 999| | } 1000| |#else // FIXED_POINT 1001| 3.29k| (void)wa; /* whoa! does it work for FIXED_POINT? */ 1002| 3.29k|#endif 1003| 3.29k|} get_sr_index: 42| 109k|{ 43| 109k| if (92017 <= samplerate) return 0; ------------------ | Branch (43:9): [True: 46.3k, False: 63.4k] ------------------ 44| 63.4k| if (75132 <= samplerate) return 1; ------------------ | Branch (44:9): [True: 1.37k, False: 62.0k] ------------------ 45| 62.0k| if (55426 <= samplerate) return 2; ------------------ | Branch (45:9): [True: 560, False: 61.4k] ------------------ 46| 61.4k| if (46009 <= samplerate) return 3; ------------------ | Branch (46:9): [True: 12.7k, False: 48.7k] ------------------ 47| 48.7k| if (37566 <= samplerate) return 4; ------------------ | Branch (47:9): [True: 7.45k, False: 41.3k] ------------------ 48| 41.3k| if (27713 <= samplerate) return 5; ------------------ | Branch (48:9): [True: 2.67k, False: 38.6k] ------------------ 49| 38.6k| if (23004 <= samplerate) return 6; ------------------ | Branch (49:9): [True: 2.26k, False: 36.3k] ------------------ 50| 36.3k| if (18783 <= samplerate) return 7; ------------------ | Branch (50:9): [True: 1.67k, False: 34.7k] ------------------ 51| 34.7k| if (13856 <= samplerate) return 8; ------------------ | Branch (51:9): [True: 34.1k, False: 604] ------------------ 52| 604| if (11502 <= samplerate) return 9; ------------------ | Branch (52:9): [True: 23, False: 581] ------------------ 53| 581| if (9391 <= samplerate) return 10; ------------------ | Branch (53:9): [True: 22, False: 559] ------------------ 54| | 55| 559| return 11; 56| 581|} get_sample_rate: 60| 30.1k|{ 61| 30.1k| static const uint32_t sample_rates[] = 62| 30.1k| { 63| 30.1k| 96000, 88200, 64000, 48000, 44100, 32000, 64| 30.1k| 24000, 22050, 16000, 12000, 11025, 8000 65| 30.1k| }; 66| | 67| 30.1k| if (sr_index < 12) ------------------ | Branch (67:9): [True: 30.0k, False: 94] ------------------ 68| 30.0k| return sample_rates[sr_index]; 69| | 70| 94| return 0; 71| 30.1k|} max_pred_sfb: 74| 3.25k|{ 75| 3.25k| static const uint8_t pred_sfb_max[] = 76| 3.25k| { 77| 3.25k| 33, 33, 38, 40, 40, 40, 41, 41, 37, 37, 37, 34 78| 3.25k| }; 79| | 80| | 81| 3.25k| if (sr_index < 12) ------------------ | Branch (81:9): [True: 3.25k, False: 0] ------------------ 82| 3.25k| return pred_sfb_max[sr_index]; 83| | 84| 0| return 0; 85| 3.25k|} max_tns_sfb: 89| 13.2k|{ 90| | /* entry for each sampling rate 91| | * 1 Main/LC long window 92| | * 2 Main/LC short window 93| | * 3 SSR long window 94| | * 4 SSR short window 95| | */ 96| 13.2k| static const uint8_t tns_sbf_max[][4] = 97| 13.2k| { 98| 13.2k| {31, 9, 28, 7}, /* 96000 */ 99| 13.2k| {31, 9, 28, 7}, /* 88200 */ 100| 13.2k| {34, 10, 27, 7}, /* 64000 */ 101| 13.2k| {40, 14, 26, 6}, /* 48000 */ 102| 13.2k| {42, 14, 26, 6}, /* 44100 */ 103| 13.2k| {51, 14, 26, 6}, /* 32000 */ 104| 13.2k| {46, 14, 29, 7}, /* 24000 */ 105| 13.2k| {46, 14, 29, 7}, /* 22050 */ 106| 13.2k| {42, 14, 23, 8}, /* 16000 */ 107| 13.2k| {42, 14, 23, 8}, /* 12000 */ 108| 13.2k| {42, 14, 23, 8}, /* 11025 */ 109| 13.2k| {39, 14, 19, 7}, /* 8000 */ 110| 13.2k| {39, 14, 19, 7}, /* 7350 */ 111| 13.2k| {0,0,0,0}, 112| 13.2k| {0,0,0,0}, 113| 13.2k| {0,0,0,0} 114| 13.2k| }; 115| 13.2k| uint8_t i = 0; 116| | 117| 13.2k| if (is_short) i++; ------------------ | Branch (117:9): [True: 4.82k, False: 8.44k] ------------------ 118| 13.2k| if (object_type == SSR) i += 2; ------------------ | | 42| 13.2k|#define SSR 3 ------------------ | Branch (118:9): [True: 34, False: 13.2k] ------------------ 119| | 120| 13.2k| return tns_sbf_max[sr_index][i]; 121| 13.2k|} can_decode_ot: 125| 2.59k|{ 126| 2.59k| switch (object_type) ------------------ | Branch (126:13): [True: 2.59k, False: 3] ------------------ 127| 2.59k| { 128| 2.48k| case LC: ------------------ | | 41| 2.48k|#define LC 2 ------------------ | Branch (128:5): [True: 2.48k, False: 112] ------------------ 129| 2.48k| return 0; 130| 12| case MAIN: ------------------ | | 40| 12|#define MAIN 1 ------------------ | Branch (130:5): [True: 12, False: 2.58k] ------------------ 131| |#ifdef MAIN_DEC 132| | return 0; 133| |#else 134| 12| return -1; 135| 0|#endif 136| 8| case SSR: ------------------ | | 42| 8|#define SSR 3 ------------------ | Branch (136:5): [True: 8, False: 2.58k] ------------------ 137| |#ifdef SSR_DEC 138| | return 0; 139| |#else 140| 8| return -1; 141| 0|#endif 142| 0| case LTP: ------------------ | | 43| 0|#define LTP 4 ------------------ | Branch (142:5): [True: 0, False: 2.59k] ------------------ 143| |#ifdef LTP_DEC 144| | return 0; 145| |#else 146| 0| return -1; 147| 0|#endif 148| | 149| | /* ER object types */ 150| 0|#ifdef ERROR_RESILIENCE 151| 89| case ER_LC: ------------------ | | 46| 89|#define ER_LC 17 ------------------ | Branch (151:5): [True: 89, False: 2.50k] ------------------ 152| 89|#ifdef DRM 153| 89| case DRM_ER_LC: ------------------ | | 48| 89|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ | Branch (153:5): [True: 0, False: 2.59k] ------------------ 154| 89|#endif 155| 89| return 0; 156| 0| case ER_LTP: ------------------ | | 47| 0|#define ER_LTP 19 ------------------ | Branch (156:5): [True: 0, False: 2.59k] ------------------ 157| |#ifdef LTP_DEC 158| | return 0; 159| |#else 160| 0| return -1; 161| 0|#endif 162| 0| case LD: ------------------ | | 45| 0|#define LD 23 ------------------ | Branch (162:5): [True: 0, False: 2.59k] ------------------ 163| |#ifdef LD_DEC 164| | return 0; 165| |#else 166| 0| return -1; 167| 2.59k|#endif 168| 2.59k|#endif 169| 2.59k| } 170| | 171| 3| return -1; 172| 2.59k|} faad_malloc: 175| 858k|{ 176| |#if 0 // defined(_WIN32) && !defined(_WIN32_WCE) 177| | return _aligned_malloc(size, 16); 178| |#else // #ifdef 0 179| 858k| return malloc(size); 180| 858k|#endif // #ifdef 0 181| 858k|} faad_free: 185| 858k|{ 186| |#if 0 // defined(_WIN32) && !defined(_WIN32_WCE) 187| | _aligned_free(b); 188| |#else 189| 858k| free(b); 190| 858k|} wl_min_lzc: 285| 26.3k|{ 286| 26.3k|#if 1 287| 26.3k| x |= (x >> 1); 288| 26.3k| x |= (x >> 2); 289| 26.3k| x |= (x >> 4); 290| 26.3k| x |= (x >> 8); 291| 26.3k| x |= (x >> 16); 292| | 293| 26.3k| return (ones32(x)); 294| |#else 295| | uint32_t count = 0; 296| | 297| | while (x >>= 1) 298| | count++; 299| | 300| | return (count + 1); 301| |#endif 302| 26.3k|} pow2_fix: 359| 246k|{ 360| 246k| uint32_t x1, x2; 361| 246k| uint32_t errcorr; 362| 246k| uint32_t index_frac; 363| 246k| real_t retval; 364| 246k| int32_t whole = (val >> REAL_BITS); ------------------ | | 45| 246k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 365| | 366| 246k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 367| 246k| if (whole >= 17) __builtin_trap(); ------------------ | Branch (367:9): [True: 0, False: 246k] ------------------ 368| 246k|#endif 369| | 370| | /* rest = [0..1] */ 371| 246k| int32_t rest = val & ((1 << REAL_BITS) - 1); ------------------ | | 45| 246k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 372| | 373| | /* index into pow2_tab */ 374| 246k| int32_t index = rest >> (REAL_BITS-TABLE_BITS); ------------------ | | 45| 246k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ int32_t index = rest >> (REAL_BITS-TABLE_BITS); ------------------ | | 304| 246k|#define TABLE_BITS 6 ------------------ 375| | 376| | 377| 246k| if (val == 0) ------------------ | Branch (377:9): [True: 197, False: 246k] ------------------ 378| 197| return (1<> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 45| 110k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ index_frac = rest >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 304| 110k|#define TABLE_BITS 6 ------------------ index_frac = rest >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 306| 110k|#define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 45| 110k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 304| 110k|#define TABLE_BITS 6 | | ------------------ ------------------ 384| 110k| index_frac = index_frac & ((1< 0) ------------------ | Branch (386:9): [True: 38.4k, False: 72.4k] ------------------ 387| 38.4k| { 388| 38.4k| retval = 1 << whole; 389| 72.4k| } else { 390| 72.4k| retval = REAL_CONST(1) >> -whole; ------------------ | | 59| 72.4k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 72.4k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 72.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 72.4k, Folded] | | ------------------ ------------------ 391| 72.4k| } 392| | 393| 110k| x1 = pow2_tab[index & ((1<> INTERP_BITS; ------------------ | | 306| 110k|#define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 45| 110k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 304| 110k|#define TABLE_BITS 6 | | ------------------ ------------------ 396| | 397| 110k| if (whole > 0) ------------------ | Branch (397:9): [True: 38.4k, False: 72.4k] ------------------ 398| 38.4k| { 399| 38.4k| retval = retval * (errcorr + x1); 400| 72.4k| } else { 401| 72.4k| retval = MUL_R(retval, (errcorr + x1)); ------------------ | | 239| 72.4k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 72.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 72.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 402| 72.4k| } 403| | 404| 110k| return retval; 405| 246k|} pow2_int: 408| 168k|{ 409| 168k| uint32_t x1, x2; 410| 168k| uint32_t errcorr; 411| 168k| uint32_t index_frac; 412| 168k| uint64_t retval; 413| 168k| int32_t whole = (val >> REAL_BITS); ------------------ | | 45| 168k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 414| 168k| int32_t exp = 0; 415| | 416| | /* rest = [0..1] */ 417| 168k| int32_t rest = val & ((1 << REAL_BITS) - 1); ------------------ | | 45| 168k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 418| | 419| | /* index into pow2_tab */ 420| 168k| int32_t index = rest >> (REAL_BITS-TABLE_BITS); ------------------ | | 45| 168k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ int32_t index = rest >> (REAL_BITS-TABLE_BITS); ------------------ | | 304| 168k|#define TABLE_BITS 6 ------------------ 421| | 422| 168k| if (val < 0) ------------------ | Branch (422:9): [True: 146k, False: 22.3k] ------------------ 423| 146k| return 0; 424| 22.3k| if (val == 0) ------------------ | Branch (424:9): [True: 242, False: 22.0k] ------------------ 425| 242| return 1; 426| 22.0k| if (whole > COEF_BITS) { ------------------ | | 43| 22.0k|#define COEF_BITS 28 ------------------ | Branch (426:9): [True: 5.31k, False: 16.7k] ------------------ 427| 5.31k| exp = whole - COEF_BITS; ------------------ | | 43| 5.31k|#define COEF_BITS 28 ------------------ 428| 5.31k| whole = COEF_BITS; ------------------ | | 43| 5.31k|#define COEF_BITS 28 ------------------ 429| 5.31k| } 430| | 431| | /* leave INTERP_BITS bits */ 432| 22.0k| index_frac = rest >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 45| 22.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ index_frac = rest >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 304| 22.0k|#define TABLE_BITS 6 ------------------ index_frac = rest >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 306| 22.0k|#define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 45| 22.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 304| 22.0k|#define TABLE_BITS 6 | | ------------------ ------------------ 433| 22.0k| index_frac = index_frac & ((1<= 0) ------------------ | Branch (435:9): [True: 22.0k, False: 0] ------------------ 436| 22.0k| retval = (uint32_t)(1 << whole); 437| 0| else 438| 0| retval = 0; 439| | 440| 22.0k| x1 = pow2_tab[index & ((1<> INTERP_BITS; ------------------ | | 306| 22.0k|#define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 45| 22.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 304| 22.0k|#define TABLE_BITS 6 | | ------------------ ------------------ 443| | 444| 22.0k| retval = MUL_R(retval, (errcorr + x1)); ------------------ | | 239| 22.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 22.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 22.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 445| | 446| 22.0k| return retval << exp; 447| 22.3k|} log2_int: 451| 11.0k|{ 452| 11.0k| uint32_t frac; 453| 11.0k| int32_t exp = 0; 454| 11.0k| uint32_t index; 455| 11.0k| uint32_t index_frac; 456| 11.0k| uint32_t x1, x2; 457| 11.0k| uint32_t errcorr; 458| | 459| 11.0k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 460| 11.0k| if (val == 0) __builtin_trap(); ------------------ | Branch (460:9): [True: 0, False: 11.0k] ------------------ 461| 11.0k|#endif 462| | 463| 11.0k| exp = floor_log2(val); 464| 11.0k| exp -= REAL_BITS; ------------------ | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 465| | 466| | /* frac = [1..2] */ 467| 11.0k| if (exp >= 0) ------------------ | Branch (467:9): [True: 7.79k, False: 3.23k] ------------------ 468| 7.79k| frac = (uint32_t)(val >> exp); 469| 3.23k| else 470| 3.23k| frac = (uint32_t)(val << -exp); 471| | 472| | /* index in the log2 table */ 473| 11.0k| index = frac >> (REAL_BITS-TABLE_BITS); ------------------ | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ index = frac >> (REAL_BITS-TABLE_BITS); ------------------ | | 304| 11.0k|#define TABLE_BITS 6 ------------------ 474| | 475| | /* leftover part for linear interpolation */ 476| 11.0k| index_frac = frac & ((1<<(REAL_BITS-TABLE_BITS))-1); ------------------ | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ index_frac = frac & ((1<<(REAL_BITS-TABLE_BITS))-1); ------------------ | | 304| 11.0k|#define TABLE_BITS 6 ------------------ 477| | 478| | /* leave INTERP_BITS bits */ 479| 11.0k| index_frac = index_frac >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ index_frac = index_frac >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 304| 11.0k|#define TABLE_BITS 6 ------------------ index_frac = index_frac >> (REAL_BITS-TABLE_BITS-INTERP_BITS); ------------------ | | 306| 11.0k|#define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 304| 11.0k|#define TABLE_BITS 6 | | ------------------ ------------------ 480| | 481| 11.0k| x1 = log2_tab[index & ((1<> INTERP_BITS; ------------------ | | 306| 11.0k|#define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define INTERP_BITS (REAL_BITS-TABLE_BITS) | | ------------------ | | | | 304| 11.0k|#define TABLE_BITS 6 | | ------------------ ------------------ 488| | 489| 11.0k| return ((exp+REAL_BITS) << REAL_BITS) + errcorr + x1; ------------------ | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ return ((exp+REAL_BITS) << REAL_BITS) + errcorr + x1; ------------------ | | 45| 11.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 490| 11.0k|} common.c:ones32: 246| 48.3k|{ 247| 48.3k| x -= ((x >> 1) & 0x55555555); 248| 48.3k| x = (((x >> 2) & 0x33333333) + (x & 0x33333333)); 249| 48.3k| x = (((x >> 4) + x) & 0x0f0f0f0f); 250| 48.3k| x += (x >> 8); 251| 48.3k| x += (x >> 16); 252| | 253| 48.3k| return (x & 0x0000003f); 254| 48.3k|} common.c:floor_log2: 262| 11.0k|{ 263| 11.0k|#if 1 264| 11.0k| x |= (x >> 1); 265| 11.0k| x |= (x >> 2); 266| 11.0k| x |= (x >> 4); 267| 11.0k| x |= (x >> 8); 268| 11.0k| x |= (x >> 16); 269| 11.0k| x |= (x >> 32); 270| | 271| 11.0k| return (ones64(x) - 1); 272| |#else 273| | uint32_t count = 0; 274| | 275| | while (x >>= 1) 276| | count++; 277| | 278| | return count; 279| |#endif 280| 11.0k|} common.c:ones64: 257| 11.0k|{ 258| 11.0k| return ones32((uint32_t)x) + ones32(x >> 32); 259| 11.0k|} NeAACDecOpen: 124| 1.68k|{ 125| 1.68k| uint8_t i; 126| 1.68k| NeAACDecStruct *hDecoder = NULL; 127| | 128| 1.68k| if ((hDecoder = (NeAACDecStruct*)faad_malloc(sizeof(NeAACDecStruct))) == NULL) ------------------ | Branch (128:9): [True: 0, False: 1.68k] ------------------ 129| 0| return NULL; 130| | 131| 1.68k| memset(hDecoder, 0, sizeof(NeAACDecStruct)); 132| | 133| 1.68k| hDecoder->cmes = mes; 134| 1.68k| hDecoder->config.outputFormat = FAAD_FMT_16BIT; ------------------ | | 98| 1.68k|#define FAAD_FMT_16BIT 1 ------------------ 135| 1.68k| hDecoder->config.defObjectType = MAIN; ------------------ | | 40| 1.68k|#define MAIN 1 ------------------ 136| 1.68k| hDecoder->config.defSampleRate = 44100; /* Default: 44.1kHz */ 137| 1.68k| hDecoder->config.downMatrix = 0; 138| 1.68k| hDecoder->adts_header_present = 0; 139| 1.68k| hDecoder->adif_header_present = 0; 140| 1.68k| hDecoder->latm_header_present = 0; 141| 1.68k|#ifdef ERROR_RESILIENCE 142| 1.68k| hDecoder->aacSectionDataResilienceFlag = 0; 143| 1.68k| hDecoder->aacScalefactorDataResilienceFlag = 0; 144| 1.68k| hDecoder->aacSpectralDataResilienceFlag = 0; 145| 1.68k|#endif 146| 1.68k| hDecoder->frameLength = 1024; 147| | 148| 1.68k| hDecoder->frame = 0; 149| 1.68k| hDecoder->sample_buffer = NULL; 150| | 151| | // Same as (1, 1) after 1024 iterations; otherwise first values does not look random at all. 152| 1.68k| hDecoder->__r1 = 0x2bb431ea; 153| 1.68k| hDecoder->__r2 = 0x206155b7; 154| | 155| 109k| for (i = 0; i < MAX_CHANNELS; i++) ------------------ | | 43| 109k|#define MAX_CHANNELS 64 ------------------ | Branch (155:17): [True: 107k, False: 1.68k] ------------------ 156| 107k| { 157| 107k| hDecoder->element_id[i] = INVALID_ELEMENT_ID; ------------------ | | 94| 107k|#define INVALID_ELEMENT_ID 255 ------------------ 158| 107k| hDecoder->window_shape_prev[i] = 0; 159| 107k| hDecoder->time_out[i] = NULL; 160| 107k| hDecoder->fb_intermed[i] = NULL; 161| |#ifdef SSR_DEC 162| | hDecoder->ssr_overlap[i] = NULL; 163| | hDecoder->prev_fmd[i] = NULL; 164| |#endif 165| |#ifdef MAIN_DEC 166| | hDecoder->pred_stat[i] = NULL; 167| |#endif 168| |#ifdef LTP_DEC 169| | hDecoder->ltp_lag[i] = 0; 170| | hDecoder->lt_pred_stat[i] = NULL; 171| |#endif 172| 107k| } 173| | 174| 1.68k|#ifdef SBR_DEC 175| 82.4k| for (i = 0; i < MAX_SYNTAX_ELEMENTS; i++) ------------------ | | 44| 82.4k|#define MAX_SYNTAX_ELEMENTS 48 ------------------ | Branch (175:17): [True: 80.7k, False: 1.68k] ------------------ 176| 80.7k| { 177| 80.7k| hDecoder->sbr[i] = NULL; 178| 80.7k| } 179| 1.68k|#endif 180| | 181| 1.68k| hDecoder->drc = drc_init(REAL_CONST(1.0), REAL_CONST(1.0)); ------------------ | | 59| 1.68k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 1.68k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 1.68k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 1.68k, Folded] | | ------------------ ------------------ hDecoder->drc = drc_init(REAL_CONST(1.0), REAL_CONST(1.0)); ------------------ | | 59| 1.68k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 1.68k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 1.68k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 1.68k, Folded] | | ------------------ ------------------ 182| | 183| 1.68k| return hDecoder; 184| 1.68k|} NeAACDecGetCurrentConfiguration: 187| 1.54k|{ 188| 1.54k| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 189| 1.54k| if (hDecoder) ------------------ | Branch (189:9): [True: 1.54k, False: 0] ------------------ 190| 1.54k| { 191| 1.54k| NeAACDecConfigurationPtr config = &(hDecoder->config); 192| | 193| 1.54k| return config; 194| 1.54k| } 195| | 196| 0| return NULL; 197| 1.54k|} NeAACDecSetConfiguration: 201| 1.55k|{ 202| 1.55k| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 203| 1.55k| if (hDecoder && config) ------------------ | Branch (203:9): [True: 1.55k, False: 0] | Branch (203:21): [True: 1.55k, False: 0] ------------------ 204| 1.55k| { 205| | /* check if we can decode this object type */ 206| 1.55k| if (can_decode_ot(config->defObjectType) < 0) ------------------ | Branch (206:13): [True: 3, False: 1.54k] ------------------ 207| 3| return 0; 208| 1.54k| hDecoder->config.defObjectType = config->defObjectType; 209| | 210| | /* samplerate: anything but 0 should be possible */ 211| 1.54k| if (config->defSampleRate == 0) ------------------ | Branch (211:13): [True: 0, False: 1.54k] ------------------ 212| 0| return 0; 213| 1.54k| hDecoder->config.defSampleRate = config->defSampleRate; 214| | 215| | /* check output format */ 216| 1.54k|#ifdef FIXED_POINT 217| 1.54k| if ((config->outputFormat < 1) || (config->outputFormat > 4)) ------------------ | Branch (217:13): [True: 0, False: 1.54k] | Branch (217:43): [True: 1, False: 1.54k] ------------------ 218| 1| return 0; 219| |#else 220| | if ((config->outputFormat < 1) || (config->outputFormat > 5)) 221| | return 0; 222| |#endif 223| 1.54k| hDecoder->config.outputFormat = config->outputFormat; 224| | 225| 1.54k| if (config->downMatrix > 1) ------------------ | Branch (225:13): [True: 0, False: 1.54k] ------------------ 226| 0| return 0; 227| 1.54k| hDecoder->config.downMatrix = config->downMatrix; 228| | 229| | /* OK */ 230| 1.54k| return 1; 231| 1.54k| } 232| | 233| 0| return 0; 234| 1.55k|} NeAACDecInit: 268| 1.07k|{ 269| 1.07k| uint32_t bits = 0; 270| 1.07k| bitfile ld; 271| 1.07k| adif_header adif; 272| 1.07k| adts_header adts; 273| 1.07k| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 274| | 275| | 276| 1.07k| if ((hDecoder == NULL) || (samplerate == NULL) || (channels == NULL) || (buffer_size == 0)) ------------------ | Branch (276:9): [True: 0, False: 1.07k] | Branch (276:31): [True: 0, False: 1.07k] | Branch (276:55): [True: 0, False: 1.07k] | Branch (276:77): [True: 0, False: 1.07k] ------------------ 277| 0| return -1; 278| | 279| 1.07k| adts.old_format = hDecoder->config.useOldADTSFormat; 280| 1.07k| hDecoder->sf_index = get_sr_index(hDecoder->config.defSampleRate); 281| 1.07k| hDecoder->object_type = hDecoder->config.defObjectType; 282| 1.07k| *samplerate = get_sample_rate(hDecoder->sf_index); 283| 1.07k| *channels = 1; 284| | 285| 1.07k| if (buffer != NULL) ------------------ | Branch (285:9): [True: 1.07k, False: 0] ------------------ 286| 1.07k| { 287| |#if 0 288| | int is_latm; 289| | latm_header *l = &hDecoder->latm_config; 290| |#endif 291| | 292| 1.07k| faad_initbits(&ld, buffer, buffer_size); 293| | 294| |#if 0 295| | memset(l, 0, sizeof(latm_header)); 296| | is_latm = latmCheck(l, &ld); 297| | l->inited = 0; 298| | l->frameLength = 0; 299| | faad_rewindbits(&ld); 300| | if(is_latm && l->ASCbits>0) 301| | { 302| | int32_t x; 303| | hDecoder->latm_header_present = 1; 304| | x = NeAACDecInit2(hDecoder, l->ASC, (l->ASCbits+7)/8, samplerate, channels); 305| | if(x!=0) 306| | hDecoder->latm_header_present = 0; 307| | return x; 308| | } else 309| |#endif 310| | /* Check if an ADIF header is present */ 311| 1.07k| if ((buffer_size >= 8) && (buffer[0] == 'A') && (buffer[1] == 'D') && ------------------ | Branch (311:13): [True: 94, False: 978] | Branch (311:35): [True: 47, False: 47] | Branch (311:57): [True: 45, False: 2] ------------------ 312| 45| (buffer[2] == 'I') && (buffer[3] == 'F')) ------------------ | Branch (312:13): [True: 44, False: 1] | Branch (312:35): [True: 43, False: 1] ------------------ 313| 43| { 314| 43| hDecoder->adif_header_present = 1; 315| | 316| 43| get_adif_header(&adif, &ld); 317| 43| faad_byte_align(&ld); 318| | 319| 43| hDecoder->sf_index = adif.pce[0].sf_index; 320| 43| hDecoder->object_type = adif.pce[0].object_type + 1; 321| | 322| 43| *samplerate = get_sample_rate(hDecoder->sf_index); 323| 43| *channels = adif.pce[0].channels; 324| | 325| 43| memcpy(&(hDecoder->pce), &(adif.pce[0]), sizeof(program_config)); 326| 43| hDecoder->pce_set = 1; 327| | 328| 43| bits = bit2byte(faad_get_processed_bits(&ld)); ------------------ | | 46| 43|#define bit2byte(a) ((a+7)>>BYTE_NUMBIT_LD) | | ------------------ | | | | 44| 43|#define BYTE_NUMBIT_LD 3 | | ------------------ ------------------ 329| | 330| | /* Check if an ADTS header is present */ 331| 1.02k| } else if (adts_frame(&adts, &ld) == 0) { ------------------ | Branch (331:20): [True: 11, False: 1.01k] ------------------ 332| 11| hDecoder->adts_header_present = 1; 333| | 334| 11| hDecoder->sf_index = adts.sf_index; 335| 11| hDecoder->object_type = adts.profile + 1; 336| | 337| 11| *samplerate = get_sample_rate(hDecoder->sf_index); 338| 11| *channels = (adts.channel_configuration > 6) ? ------------------ | Branch (338:25): [True: 7, False: 4] ------------------ 339| 7| 2 : adts.channel_configuration; 340| 11| } 341| | 342| 1.07k| if (ld.error) ------------------ | Branch (342:13): [True: 0, False: 1.07k] ------------------ 343| 0| { 344| 0| faad_endbits(&ld); 345| 0| return -1; 346| 0| } 347| 1.07k| faad_endbits(&ld); 348| 1.07k| } 349| | 350| 1.07k| if (!*samplerate) ------------------ | Branch (350:9): [True: 28, False: 1.04k] ------------------ 351| 28| return -1; 352| | 353| 1.04k|#if (defined(PS_DEC) || defined(DRM_PS)) 354| | /* check if we have a mono file */ 355| 1.04k| if (*channels == 1) ------------------ | Branch (355:9): [True: 1.01k, False: 26] ------------------ 356| 1.01k| { 357| | /* upMatrix to 2 channels for implicit signalling of PS */ 358| 1.01k| *channels = 2; 359| 1.01k| } 360| 1.04k|#endif 361| | 362| 1.04k| hDecoder->channelConfiguration = *channels; 363| | 364| 1.04k|#ifdef SBR_DEC 365| | /* implicit signalling */ 366| 1.04k| if (*samplerate <= 24000 && (hDecoder->config.dontUpSampleImplicitSBR == 0)) ------------------ | Branch (366:9): [True: 568, False: 476] | Branch (366:33): [True: 568, False: 0] ------------------ 367| 568| { 368| 568| *samplerate *= 2; 369| 568| hDecoder->forceUpSampling = 1; 370| 568| } else if (*samplerate > 24000 && (hDecoder->config.dontUpSampleImplicitSBR == 0)) { ------------------ | Branch (370:16): [True: 476, False: 0] | Branch (370:39): [True: 476, False: 0] ------------------ 371| 476| hDecoder->downSampledSBR = 1; 372| 476| } 373| 1.04k|#endif 374| | 375| | /* must be done before frameLength is divided by 2 for LD */ 376| |#ifdef SSR_DEC 377| | if (hDecoder->object_type == SSR) 378| | hDecoder->fb = ssr_filter_bank_init(hDecoder->frameLength/SSR_BANDS); 379| | else 380| |#endif 381| 1.04k| hDecoder->fb = filter_bank_init(hDecoder->frameLength); 382| | 383| |#ifdef LD_DEC 384| | if (hDecoder->object_type == LD) 385| | hDecoder->frameLength >>= 1; 386| |#endif 387| | 388| 1.04k| if (can_decode_ot(hDecoder->object_type) < 0) ------------------ | Branch (388:9): [True: 20, False: 1.02k] ------------------ 389| 20| return -1; 390| | 391| 1.02k| return bits; 392| 1.04k|} NeAACDecInit2: 400| 474|{ 401| 474| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 402| 474| int8_t rc; 403| 474| mp4AudioSpecificConfig mp4ASC; 404| | 405| 474| if((hDecoder == NULL) ------------------ | Branch (405:8): [True: 0, False: 474] ------------------ 406| 474| || (pBuffer == NULL) ------------------ | Branch (406:12): [True: 0, False: 474] ------------------ 407| 474| || (SizeOfDecoderSpecificInfo < 2) ------------------ | Branch (407:12): [True: 0, False: 474] ------------------ 408| 474| || (samplerate == NULL) ------------------ | Branch (408:12): [True: 0, False: 474] ------------------ 409| 474| || (channels == NULL)) ------------------ | Branch (409:12): [True: 0, False: 474] ------------------ 410| 0| { 411| 0| return -1; 412| 0| } 413| | 414| 474| hDecoder->adif_header_present = 0; 415| 474| hDecoder->adts_header_present = 0; 416| | 417| | /* decode the audio specific config */ 418| 474| rc = AudioSpecificConfig2(pBuffer, SizeOfDecoderSpecificInfo, &mp4ASC, 419| 474| &(hDecoder->pce), hDecoder->latm_header_present); 420| | 421| | /* copy the relevant info to the decoder handle */ 422| 474| *samplerate = mp4ASC.samplingFrequency; 423| 474| if (mp4ASC.channelsConfiguration) ------------------ | Branch (423:9): [True: 346, False: 128] ------------------ 424| 346| { 425| 346| *channels = mp4ASC.channelsConfiguration; 426| 346| } else { 427| 128| *channels = hDecoder->pce.channels; 428| 128| hDecoder->pce_set = 1; 429| 128| } 430| 474|#if (defined(PS_DEC) || defined(DRM_PS)) 431| | /* check if we have a mono file */ 432| 474| if (*channels == 1) ------------------ | Branch (432:9): [True: 4, False: 470] ------------------ 433| 4| { 434| | /* upMatrix to 2 channels for implicit signalling of PS */ 435| 4| *channels = 2; 436| 4| } 437| 474|#endif 438| 474| hDecoder->sf_index = mp4ASC.samplingFrequencyIndex; 439| 474| hDecoder->object_type = mp4ASC.objectTypeIndex; 440| 474|#ifdef ERROR_RESILIENCE 441| 474| hDecoder->aacSectionDataResilienceFlag = mp4ASC.aacSectionDataResilienceFlag; 442| 474| hDecoder->aacScalefactorDataResilienceFlag = mp4ASC.aacScalefactorDataResilienceFlag; 443| 474| hDecoder->aacSpectralDataResilienceFlag = mp4ASC.aacSpectralDataResilienceFlag; 444| 474|#endif 445| 474|#ifdef SBR_DEC 446| 474| hDecoder->sbr_present_flag = mp4ASC.sbr_present_flag; 447| 474| hDecoder->downSampledSBR = mp4ASC.downSampledSBR; 448| 474| if (hDecoder->config.dontUpSampleImplicitSBR == 0) ------------------ | Branch (448:9): [True: 474, False: 0] ------------------ 449| 474| hDecoder->forceUpSampling = mp4ASC.forceUpSampling; 450| 0| else 451| 0| hDecoder->forceUpSampling = 0; 452| | 453| | /* AAC core decoder samplerate is 2 times as low */ 454| 474| if (((hDecoder->sbr_present_flag == 1)&&(!hDecoder->downSampledSBR)) || hDecoder->forceUpSampling == 1) ------------------ | Branch (454:10): [True: 213, False: 261] | Branch (454:45): [True: 167, False: 46] | Branch (454:77): [True: 76, False: 231] ------------------ 455| 243| { 456| 243| hDecoder->sf_index = get_sr_index(mp4ASC.samplingFrequency / 2); 457| 243| } 458| 474|#endif 459| | 460| 474| if (rc != 0) ------------------ | Branch (460:9): [True: 1, False: 473] ------------------ 461| 1| { 462| 1| return rc; 463| 1| } 464| 473| hDecoder->channelConfiguration = mp4ASC.channelsConfiguration; 465| 473| if (mp4ASC.frameLengthFlag) ------------------ | Branch (465:9): [True: 410, False: 63] ------------------ 466| 410|#ifdef ALLOW_SMALL_FRAMELENGTH 467| 410| hDecoder->frameLength = 960; 468| |#else 469| | return -1; 470| |#endif 471| | 472| | /* must be done before frameLength is divided by 2 for LD */ 473| |#ifdef SSR_DEC 474| | if (hDecoder->object_type == SSR) 475| | hDecoder->fb = ssr_filter_bank_init(hDecoder->frameLength/SSR_BANDS); 476| | else 477| |#endif 478| 473| hDecoder->fb = filter_bank_init(hDecoder->frameLength); 479| | 480| |#ifdef LD_DEC 481| | if (hDecoder->object_type == LD) 482| | hDecoder->frameLength >>= 1; 483| |#endif 484| | 485| 473| return 0; 486| 474|} NeAACDecInitDRM: 492| 132|{ 493| 132| NeAACDecStruct** hDecoder = (NeAACDecStruct**)hpDecoder; 494| 132| if (hDecoder == NULL) ------------------ | Branch (494:9): [True: 0, False: 132] ------------------ 495| 0| return 1; /* error */ 496| | 497| 132| NeAACDecClose(*hDecoder); 498| | 499| 132| *hDecoder = NeAACDecOpen(); 500| | 501| | /* Special object type defined for DRM */ 502| 132| (*hDecoder)->config.defObjectType = DRM_ER_LC; ------------------ | | 48| 132|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ 503| | 504| 132| (*hDecoder)->config.defSampleRate = samplerate; 505| 132|#ifdef ERROR_RESILIENCE // This shoudl always be defined for DRM 506| 132| (*hDecoder)->aacSectionDataResilienceFlag = 1; /* VCB11 */ 507| 132| (*hDecoder)->aacScalefactorDataResilienceFlag = 0; /* no RVLC */ 508| 132| (*hDecoder)->aacSpectralDataResilienceFlag = 1; /* HCR */ 509| 132|#endif 510| 132| (*hDecoder)->frameLength = 960; 511| 132| (*hDecoder)->sf_index = get_sr_index((*hDecoder)->config.defSampleRate); 512| 132| (*hDecoder)->object_type = (*hDecoder)->config.defObjectType; 513| | 514| 132| if ((channels == DRMCH_STEREO) || (channels == DRMCH_SBR_STEREO)) ------------------ | | 64| 132|#define DRMCH_STEREO 2 ------------------ if ((channels == DRMCH_STEREO) || (channels == DRMCH_SBR_STEREO)) ------------------ | | 66| 132|#define DRMCH_SBR_STEREO 4 ------------------ | Branch (514:9): [True: 0, False: 132] | Branch (514:39): [True: 2, False: 130] ------------------ 515| 2| (*hDecoder)->channelConfiguration = 2; 516| 130| else 517| 130| (*hDecoder)->channelConfiguration = 1; 518| | 519| 132|#ifdef SBR_DEC 520| 132| if ((channels == DRMCH_MONO) || (channels == DRMCH_STEREO)) ------------------ | | 63| 132|#define DRMCH_MONO 1 ------------------ if ((channels == DRMCH_MONO) || (channels == DRMCH_STEREO)) ------------------ | | 64| 132|#define DRMCH_STEREO 2 ------------------ | Branch (520:9): [True: 0, False: 132] | Branch (520:37): [True: 0, False: 132] ------------------ 521| 0| (*hDecoder)->sbr_present_flag = 0; 522| 132| else 523| 132| (*hDecoder)->sbr_present_flag = 1; 524| 132|#endif 525| | 526| 132| (*hDecoder)->fb = filter_bank_init((*hDecoder)->frameLength); 527| | 528| 132| return 0; 529| 132|} NeAACDecClose: 533| 1.68k|{ 534| 1.68k| uint8_t i; 535| 1.68k| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 536| | 537| 1.68k| if (hDecoder == NULL) ------------------ | Branch (537:9): [True: 0, False: 1.68k] ------------------ 538| 0| return; 539| | 540| |#ifdef PROFILE 541| | printf("AAC decoder total: %I64d cycles\n", hDecoder->cycles); 542| | printf("requant: %I64d cycles\n", hDecoder->requant_cycles); 543| | printf("spectral_data: %I64d cycles\n", hDecoder->spectral_cycles); 544| | printf("scalefactors: %I64d cycles\n", hDecoder->scalefac_cycles); 545| | printf("output: %I64d cycles\n", hDecoder->output_cycles); 546| |#endif 547| | 548| 109k| for (i = 0; i < MAX_CHANNELS; i++) ------------------ | | 43| 109k|#define MAX_CHANNELS 64 ------------------ | Branch (548:17): [True: 107k, False: 1.68k] ------------------ 549| 107k| { 550| 107k| if (hDecoder->time_out[i]) faad_free(hDecoder->time_out[i]); ------------------ | Branch (550:13): [True: 60.3k, False: 47.3k] ------------------ 551| 107k| if (hDecoder->fb_intermed[i]) faad_free(hDecoder->fb_intermed[i]); ------------------ | Branch (551:13): [True: 37.9k, False: 69.6k] ------------------ 552| |#ifdef SSR_DEC 553| | if (hDecoder->ssr_overlap[i]) faad_free(hDecoder->ssr_overlap[i]); 554| | if (hDecoder->prev_fmd[i]) faad_free(hDecoder->prev_fmd[i]); 555| |#endif 556| |#ifdef MAIN_DEC 557| | if (hDecoder->pred_stat[i]) faad_free(hDecoder->pred_stat[i]); 558| |#endif 559| |#ifdef LTP_DEC 560| | if (hDecoder->lt_pred_stat[i]) faad_free(hDecoder->lt_pred_stat[i]); 561| |#endif 562| 107k| } 563| | 564| |#ifdef SSR_DEC 565| | if (hDecoder->object_type == SSR) 566| | ssr_filter_bank_end(hDecoder->fb); 567| | else 568| |#endif 569| 1.68k| filter_bank_end(hDecoder->fb); 570| | 571| 1.68k| drc_end(hDecoder->drc); 572| | 573| 1.68k| if (hDecoder->sample_buffer) faad_free(hDecoder->sample_buffer); ------------------ | Branch (573:9): [True: 262, False: 1.42k] ------------------ 574| | 575| 1.68k|#ifdef SBR_DEC 576| 82.4k| for (i = 0; i < MAX_SYNTAX_ELEMENTS; i++) ------------------ | | 44| 82.4k|#define MAX_SYNTAX_ELEMENTS 48 ------------------ | Branch (576:17): [True: 80.7k, False: 1.68k] ------------------ 577| 80.7k| { 578| 80.7k| if (hDecoder->sbr[i]) ------------------ | Branch (578:13): [True: 27.6k, False: 53.0k] ------------------ 579| 27.6k| sbrDecodeEnd(hDecoder->sbr[i]); 580| 80.7k| } 581| 1.68k|#endif 582| | 583| 1.68k| if (hDecoder) faad_free(hDecoder); ------------------ | Branch (583:9): [True: 1.68k, False: 0] ------------------ 584| 1.68k|} NeAACDecPostSeekReset: 587| 815|{ 588| 815| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 589| 815| if (hDecoder) ------------------ | Branch (589:9): [True: 815, False: 0] ------------------ 590| 815| { 591| 815| hDecoder->postSeekResetFlag = 1; 592| | 593| 815| if (frame != -1) ------------------ | Branch (593:13): [True: 815, False: 0] ------------------ 594| 815| hDecoder->frame = frame; 595| 815| } 596| 815|} NeAACDecDecode: 825| 2.68k|{ 826| 2.68k| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 827| | return aac_frame_decode(hDecoder, hInfo, buffer, buffer_size, NULL, 0); 828| 2.68k|} NeAACDecDecode2: 836| 305|{ 837| 305| NeAACDecStruct* hDecoder = (NeAACDecStruct*)hpDecoder; 838| 305| if ((sample_buffer_size == 0) || (sample_buffer == NULL) || (*sample_buffer == NULL)) ------------------ | Branch (838:9): [True: 0, False: 305] | Branch (838:38): [True: 0, False: 305] | Branch (838:65): [True: 0, False: 305] ------------------ 839| 0| { 840| 0| hInfo->error = 27; 841| 0| return NULL; 842| 0| } 843| | 844| 305| return aac_frame_decode(hDecoder, hInfo, buffer, buffer_size, 845| 305| sample_buffer, sample_buffer_size); 846| 305|} decoder.c:aac_frame_decode: 854| 2.98k|{ 855| 2.98k| uint16_t i; 856| 2.98k| uint8_t channels = 0; 857| 2.98k| uint8_t output_channels = 0; 858| 2.98k| bitfile ld; 859| 2.98k| uint32_t bitsconsumed; 860| 2.98k| uint16_t frame_len; 861| 2.98k| void *sample_buffer; 862| |#if 0 863| | uint32_t startbit=0, endbit=0, payload_bits=0; 864| |#endif 865| 2.98k| uint32_t required_buffer_size=0; 866| | 867| |#ifdef PROFILE 868| | int64_t count = faad_get_ts(); 869| |#endif 870| | 871| | /* safety checks */ 872| 2.98k| if ((hDecoder == NULL) || (hInfo == NULL) || (buffer == NULL)) ------------------ | Branch (872:9): [True: 0, False: 2.98k] | Branch (872:31): [True: 0, False: 2.98k] | Branch (872:50): [True: 0, False: 2.98k] ------------------ 873| 0| { 874| 0| return NULL; 875| 0| } 876| | 877| |#if 0 878| | printf("%d\n", buffer_size*8); 879| |#endif 880| | 881| 2.98k| frame_len = hDecoder->frameLength; 882| | 883| | 884| 2.98k| memset(hInfo, 0, sizeof(NeAACDecFrameInfo)); 885| 2.98k| memset(hDecoder->internal_channel, 0, MAX_CHANNELS*sizeof(hDecoder->internal_channel[0])); ------------------ | | 43| 2.98k|#define MAX_CHANNELS 64 ------------------ 886| | 887| |#ifdef USE_TIME_LIMIT 888| | if ((TIME_LIMIT * get_sample_rate(hDecoder->sf_index)) > hDecoder->TL_count) 889| | { 890| | hDecoder->TL_count += 1024; 891| | } else { 892| | hInfo->error = (NUM_ERROR_MESSAGES-1); 893| | goto error; 894| | } 895| |#endif 896| | 897| | 898| | /* check for some common metadata tag types in the bitstream 899| | * No need to return an error 900| | */ 901| | /* ID3 */ 902| 2.98k| if (buffer_size >= 128) ------------------ | Branch (902:9): [True: 1.42k, False: 1.55k] ------------------ 903| 1.42k| { 904| 1.42k| if (memcmp(buffer, "TAG", 3) == 0) ------------------ | Branch (904:13): [True: 3, False: 1.42k] ------------------ 905| 3| { 906| | /* found it */ 907| 3| hInfo->bytesconsumed = 128; /* 128 bytes fixed size */ 908| | /* no error, but no output either */ 909| 3| return NULL; 910| 3| } 911| 1.42k| } 912| | 913| | 914| | /* initialize the bitstream */ 915| 2.98k| faad_initbits(&ld, buffer, buffer_size); 916| 2.98k| if (ld.error != 0) ------------------ | Branch (916:9): [True: 956, False: 2.02k] ------------------ 917| 956| return NULL; 918| | 919| |#if 0 920| | { 921| | int i; 922| | for (i = 0; i < ((buffer_size+3)>>2); i++) 923| | { 924| | uint8_t *buf; 925| | uint32_t temp = 0; 926| | buf = faad_getbitbuffer(&ld, 32); 927| | //temp = getdword((void*)buf); 928| | temp = *((uint32_t*)buf); 929| | printf("0x%.8X\n", temp); 930| | free(buf); 931| | } 932| | faad_endbits(&ld); 933| | faad_initbits(&ld, buffer, buffer_size); 934| | } 935| |#endif 936| | 937| |#if 0 938| | if(hDecoder->latm_header_present) 939| | { 940| | payload_bits = faad_latm_frame(&hDecoder->latm_config, &ld); 941| | startbit = faad_get_processed_bits(&ld); 942| | if(payload_bits == -1U) 943| | { 944| | hInfo->error = 1; 945| | goto error; 946| | } 947| | } 948| |#endif 949| | 950| 2.02k|#ifdef DRM 951| 2.02k| if (hDecoder->object_type == DRM_ER_LC) ------------------ | | 48| 2.02k|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ | Branch (951:9): [True: 167, False: 1.86k] ------------------ 952| 167| { 953| | /* We do not support stereo right now */ 954| 167| if (0) //(hDecoder->channelConfiguration == 2) ------------------ | Branch (954:13): [Folded, False: 167] ------------------ 955| 0| { 956| 0| hInfo->error = 28; // Throw CRC error 957| 0| goto error; 958| 0| } 959| | 960| 167| faad_getbits(&ld, 8 961| 167| DEBUGVAR(1,1,"NeAACDecDecode(): skip CRC")); 962| 167| } 963| 2.02k|#endif 964| | 965| 2.02k| if (hDecoder->adts_header_present) ------------------ | Branch (965:9): [True: 3, False: 2.02k] ------------------ 966| 3| { 967| 3| adts_header adts; 968| | 969| 3| adts.old_format = hDecoder->config.useOldADTSFormat; 970| 3| if ((hInfo->error = adts_frame(&adts, &ld)) > 0) ------------------ | Branch (970:13): [True: 0, False: 3] ------------------ 971| 0| goto error; 972| | 973| | /* MPEG2 does byte_alignment() here, 974| | * but ADTS header is always multiple of 8 bits in MPEG2 975| | * so not needed to actually do it. 976| | */ 977| 3| } 978| | 979| |#ifdef ANALYSIS 980| | dbg_count = 0; 981| |#endif 982| | 983| | /* decode the complete bitstream */ 984| 2.02k|#ifdef DRM 985| 2.02k| if (/*(hDecoder->object_type == 6) ||*/ hDecoder->object_type == DRM_ER_LC) ------------------ | | 48| 2.02k|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ | Branch (985:45): [True: 167, False: 1.86k] ------------------ 986| 167| { 987| 167| DRM_aac_scalable_main_element(hDecoder, hInfo, &ld, &hDecoder->pce, hDecoder->drc); 988| 1.86k| } else { 989| 1.86k|#endif 990| 1.86k| raw_data_block(hDecoder, hInfo, &ld, &hDecoder->pce, hDecoder->drc); 991| 1.86k|#ifdef DRM 992| 1.86k| } 993| 2.02k|#endif 994| | 995| |#if 0 996| | if(hDecoder->latm_header_present) 997| | { 998| | endbit = faad_get_processed_bits(&ld); 999| | if(endbit-startbit > payload_bits) 1000| | fprintf(stderr, "\r\nERROR, too many payload bits read: %u > %d. Please. report with a link to a sample\n", 1001| | endbit-startbit, payload_bits); 1002| | if(hDecoder->latm_config.otherDataLenBits > 0) 1003| | faad_getbits(&ld, hDecoder->latm_config.otherDataLenBits); 1004| | faad_byte_align(&ld); 1005| | } 1006| |#endif 1007| | 1008| 2.02k| channels = hDecoder->fr_channels; 1009| | 1010| 2.02k| if (hInfo->error > 0) ------------------ | Branch (1010:9): [True: 1.54k, False: 481] ------------------ 1011| 1.54k| goto error; 1012| | 1013| | /* safety check */ 1014| 481| if (channels == 0 || channels > MAX_CHANNELS) ------------------ | | 43| 468|#define MAX_CHANNELS 64 ------------------ | Branch (1014:9): [True: 13, False: 468] | Branch (1014:26): [True: 0, False: 468] ------------------ 1015| 13| { 1016| | /* invalid number of channels */ 1017| 13| hInfo->error = 12; 1018| 13| goto error; 1019| 13| } 1020| | 1021| | /* no more bit reading after this */ 1022| 468| bitsconsumed = faad_get_processed_bits(&ld); 1023| 468| hInfo->bytesconsumed = bit2byte(bitsconsumed); ------------------ | | 46| 468|#define bit2byte(a) ((a+7)>>BYTE_NUMBIT_LD) | | ------------------ | | | | 44| 468|#define BYTE_NUMBIT_LD 3 | | ------------------ ------------------ 1024| 468| if (ld.error) ------------------ | Branch (1024:9): [True: 0, False: 468] ------------------ 1025| 0| { 1026| 0| hInfo->error = 14; 1027| 0| goto error; 1028| 0| } 1029| 468| faad_endbits(&ld); 1030| | 1031| | 1032| 468| if (!hDecoder->adts_header_present && !hDecoder->adif_header_present ------------------ | Branch (1032:9): [True: 467, False: 1] | Branch (1032:43): [True: 467, False: 0] ------------------ 1033| |#if 0 1034| | && !hDecoder->latm_header_present 1035| |#endif 1036| 468| ) 1037| 467| { 1038| 467| if (hDecoder->channelConfiguration == 0) ------------------ | Branch (1038:13): [True: 16, False: 451] ------------------ 1039| 16| hDecoder->channelConfiguration = channels; 1040| | 1041| 467| if (channels == 8) /* 7.1 */ ------------------ | Branch (1041:13): [True: 20, False: 447] ------------------ 1042| 20| hDecoder->channelConfiguration = 7; 1043| 467| if (channels == 7) /* not a standard channelConfiguration */ ------------------ | Branch (1043:13): [True: 0, False: 467] ------------------ 1044| 0| hDecoder->channelConfiguration = 0; 1045| 467| } 1046| | 1047| 468| if ((channels == 5 || channels == 6) && hDecoder->config.downMatrix) ------------------ | Branch (1047:10): [True: 0, False: 468] | Branch (1047:27): [True: 173, False: 295] | Branch (1047:45): [True: 47, False: 126] ------------------ 1048| 47| { 1049| 47| hDecoder->downMatrix = 1; 1050| 47| output_channels = 2; 1051| 421| } else { 1052| 421| output_channels = channels; 1053| 421| } 1054| | 1055| 468|#if (defined(PS_DEC) || defined(DRM_PS)) 1056| 468| hDecoder->upMatrix = 0; 1057| | /* check if we have a mono file */ 1058| 468| if (output_channels == 1) ------------------ | Branch (1058:9): [True: 0, False: 468] ------------------ 1059| 0| { 1060| | /* upMatrix to 2 channels for implicit signalling of PS */ 1061| 0| hDecoder->upMatrix = 1; 1062| 0| output_channels = 2; 1063| 0| } 1064| 468|#endif 1065| | 1066| | /* Make a channel configuration based on either a PCE or a channelConfiguration */ 1067| 468| if (!hDecoder->downMatrix && hDecoder->pce_set) ------------------ | Branch (1067:9): [True: 421, False: 47] | Branch (1067:34): [True: 18, False: 403] ------------------ 1068| 18| { 1069| | /* In some codepath program_config_element result is ignored. */ 1070| 18| if (hDecoder->pce.channels > MAX_CHANNELS) ------------------ | | 43| 18|#define MAX_CHANNELS 64 ------------------ | Branch (1070:13): [True: 0, False: 18] ------------------ 1071| 0| { 1072| 0| hInfo->error = 22; 1073| 0| return NULL; 1074| 0| } 1075| 18| } 1076| 468| create_channel_config(hDecoder, hInfo); 1077| | 1078| | /* number of samples in this frame */ 1079| 468| hInfo->samples = frame_len*output_channels; 1080| | /* number of channels in this frame */ 1081| 468| hInfo->channels = output_channels; 1082| | /* samplerate */ 1083| 468| hInfo->samplerate = get_sample_rate(hDecoder->sf_index); 1084| | /* object type */ 1085| 468| hInfo->object_type = hDecoder->object_type; 1086| | /* sbr */ 1087| 468| hInfo->sbr = NO_SBR; ------------------ | | 57| 468|#define NO_SBR 0 ------------------ 1088| | /* header type */ 1089| 468| hInfo->header_type = RAW; ------------------ | | 51| 468|#define RAW 0 ------------------ 1090| 468| if (hDecoder->adif_header_present) ------------------ | Branch (1090:9): [True: 0, False: 468] ------------------ 1091| 0| hInfo->header_type = ADIF; ------------------ | | 52| 0|#define ADIF 1 ------------------ 1092| 468| if (hDecoder->adts_header_present) ------------------ | Branch (1092:9): [True: 1, False: 467] ------------------ 1093| 1| hInfo->header_type = ADTS; ------------------ | | 53| 1|#define ADTS 2 ------------------ 1094| |#if 0 1095| | if (hDecoder->latm_header_present) 1096| | hInfo->header_type = LATM; 1097| |#endif 1098| 468|#if (defined(PS_DEC) || defined(DRM_PS)) 1099| 468| hInfo->ps = hDecoder->ps_used_global; 1100| 468|#endif 1101| | 1102| | /* check if frame has channel elements */ 1103| 468| if (channels == 0) ------------------ | Branch (1103:9): [True: 0, False: 468] ------------------ 1104| 0| { 1105| 0| hDecoder->frame++; 1106| 0| return NULL; 1107| 0| } 1108| | 1109| 468| { 1110| 468| static const uint8_t str[] = { sizeof(int16_t), sizeof(int32_t), sizeof(int32_t), 1111| 468| sizeof(float32_t), sizeof(double), sizeof(int16_t), sizeof(int16_t), 1112| 468| sizeof(int16_t), sizeof(int16_t), 0, 0, 0 1113| 468| }; 1114| 468| uint8_t stride = str[hDecoder->config.outputFormat-1]; 1115| 468|#ifdef SBR_DEC 1116| 468| if (((hDecoder->sbr_present_flag == 1)&&(!hDecoder->downSampledSBR)) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (1116:14): [True: 383, False: 85] | Branch (1116:49): [True: 302, False: 81] | Branch (1116:81): [True: 6, False: 160] ------------------ 1117| 308| { 1118| 308| stride = 2 * stride; 1119| 308| } 1120| 468|#endif 1121| 468| required_buffer_size = frame_len*output_channels*stride; 1122| 468| } 1123| | 1124| | /* check if we want to use internal sample_buffer */ 1125| 468| if (sample_buffer_size == 0) ------------------ | Branch (1125:9): [True: 349, False: 119] ------------------ 1126| 349| { 1127| | /* allocate the buffer for the final samples */ 1128| 349| if (hDecoder->sample_buffer_size != required_buffer_size) ------------------ | Branch (1128:13): [True: 274, False: 75] ------------------ 1129| 274| { 1130| 274| if (hDecoder->sample_buffer) ------------------ | Branch (1130:17): [True: 12, False: 262] ------------------ 1131| 12| faad_free(hDecoder->sample_buffer); 1132| 274| hDecoder->sample_buffer = NULL; 1133| 274| hDecoder->sample_buffer = faad_malloc(required_buffer_size); 1134| 274| hDecoder->sample_buffer_size = required_buffer_size; 1135| 274| } 1136| 349| } else if (sample_buffer_size < required_buffer_size) { ------------------ | Branch (1136:16): [True: 83, False: 36] ------------------ 1137| | /* provided sample buffer is not big enough */ 1138| 83| hInfo->error = 27; 1139| 83| return NULL; 1140| 83| } 1141| | 1142| 385| if (sample_buffer_size == 0) ------------------ | Branch (1142:9): [True: 349, False: 36] ------------------ 1143| 349| { 1144| 349| sample_buffer = hDecoder->sample_buffer; 1145| 349| } else { 1146| 36| sample_buffer = *sample_buffer2; 1147| 36| } 1148| | 1149| 385|#ifdef SBR_DEC 1150| 385| if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (1150:9): [True: 307, False: 78] | Branch (1150:46): [True: 6, False: 72] ------------------ 1151| 313| { 1152| 313| uint8_t ele; 1153| | 1154| | /* this data is different when SBR is used or when the data is upsampled */ 1155| 313| if (!hDecoder->downSampledSBR) ------------------ | Branch (1155:13): [True: 233, False: 80] ------------------ 1156| 233| { 1157| 233| frame_len *= 2; 1158| 233| hInfo->samples *= 2; 1159| 233| hInfo->samplerate *= 2; 1160| 233| } 1161| | 1162| | /* check if every element was provided with SBR data */ 1163| 2.78k| for (ele = 0; ele < hDecoder->fr_ch_ele; ele++) ------------------ | Branch (1163:23): [True: 2.47k, False: 313] ------------------ 1164| 2.47k| { 1165| 2.47k| if (hDecoder->sbr[ele] == NULL) ------------------ | Branch (1165:17): [True: 0, False: 2.47k] ------------------ 1166| 0| { 1167| 0| hInfo->error = 25; 1168| 0| goto error; 1169| 0| } 1170| 2.47k| } 1171| | 1172| | /* sbr */ 1173| 313| if (hDecoder->sbr_present_flag == 1) ------------------ | Branch (1173:13): [True: 307, False: 6] ------------------ 1174| 307| { 1175| 307| hInfo->object_type = HE_AAC; ------------------ | | 44| 307|#define HE_AAC 5 ------------------ 1176| 307| hInfo->sbr = SBR_UPSAMPLED; ------------------ | | 58| 307|#define SBR_UPSAMPLED 1 ------------------ 1177| 307| } else { 1178| 6| hInfo->sbr = NO_SBR_UPSAMPLED; ------------------ | | 60| 6|#define NO_SBR_UPSAMPLED 3 ------------------ 1179| 6| } 1180| 313| if (hDecoder->downSampledSBR) ------------------ | Branch (1180:13): [True: 80, False: 233] ------------------ 1181| 80| { 1182| 80| hInfo->sbr = SBR_DOWNSAMPLED; ------------------ | | 59| 80|#define SBR_DOWNSAMPLED 2 ------------------ 1183| 80| } 1184| 313| } 1185| 385|#endif 1186| | 1187| | 1188| 385| sample_buffer = output_to_PCM(hDecoder, hDecoder->time_out, sample_buffer, 1189| 385| output_channels, frame_len, hDecoder->config.outputFormat); 1190| | 1191| | 1192| 385|#ifdef DRM 1193| | //conceal_output(hDecoder, frame_len, output_channels, sample_buffer); 1194| 385|#endif 1195| | 1196| | 1197| 385| hDecoder->postSeekResetFlag = 0; 1198| | 1199| 385| hDecoder->frame++; 1200| |#ifdef LD_DEC 1201| | if (hDecoder->object_type != LD) 1202| | { 1203| |#endif 1204| 385| if (hDecoder->frame <= 1) ------------------ | Branch (1204:13): [True: 164, False: 221] ------------------ 1205| 164| hInfo->samples = 0; 1206| |#ifdef LD_DEC 1207| | } else { 1208| | /* LD encoders will give lower delay */ 1209| | if (hDecoder->frame <= 0) 1210| | hInfo->samples = 0; 1211| | } 1212| |#endif 1213| | 1214| | /* cleanup */ 1215| |#ifdef ANALYSIS 1216| | fflush(stdout); 1217| |#endif 1218| | 1219| |#ifdef PROFILE 1220| | count = faad_get_ts() - count; 1221| | hDecoder->cycles += count; 1222| |#endif 1223| | 1224| 385| return sample_buffer; 1225| | 1226| 1.55k|error: 1227| | 1228| | /* reset filterbank state */ 1229| 101k| for (i = 0; i < MAX_CHANNELS; i++) ------------------ | | 43| 101k|#define MAX_CHANNELS 64 ------------------ | Branch (1229:17): [True: 99.7k, False: 1.55k] ------------------ 1230| 99.7k| { 1231| 99.7k| if (hDecoder->fb_intermed[i] != NULL) ------------------ | Branch (1231:13): [True: 44.4k, False: 55.3k] ------------------ 1232| 44.4k| { 1233| 44.4k| memset(hDecoder->fb_intermed[i], 0, hDecoder->frameLength*sizeof(real_t)); 1234| 44.4k| } 1235| 99.7k| } 1236| 1.55k|#ifdef SBR_DEC 1237| 76.3k| for (i = 0; i < MAX_SYNTAX_ELEMENTS; i++) ------------------ | | 44| 76.3k|#define MAX_SYNTAX_ELEMENTS 48 ------------------ | Branch (1237:17): [True: 74.8k, False: 1.55k] ------------------ 1238| 74.8k| { 1239| 74.8k| if (hDecoder->sbr[i] != NULL) ------------------ | Branch (1239:13): [True: 33.0k, False: 41.8k] ------------------ 1240| 33.0k| { 1241| 33.0k| sbrReset(hDecoder->sbr[i]); 1242| 33.0k| } 1243| 74.8k| } 1244| 1.55k|#endif 1245| | 1246| | 1247| 1.55k| faad_endbits(&ld); 1248| | 1249| | /* cleanup */ 1250| |#ifdef ANALYSIS 1251| | fflush(stdout); 1252| |#endif 1253| | 1254| | return NULL; 1255| 385|} decoder.c:create_channel_config: 599| 468|{ 600| 468| hInfo->num_front_channels = 0; 601| 468| hInfo->num_side_channels = 0; 602| 468| hInfo->num_back_channels = 0; 603| 468| hInfo->num_lfe_channels = 0; 604| 468| memset(hInfo->channel_position, 0, MAX_CHANNELS*sizeof(uint8_t)); ------------------ | | 43| 468|#define MAX_CHANNELS 64 ------------------ 605| | 606| 468| if (hDecoder->downMatrix) ------------------ | Branch (606:9): [True: 47, False: 421] ------------------ 607| 47| { 608| 47| hInfo->num_front_channels = 2; 609| 47| hInfo->channel_position[0] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 47|#define FRONT_CHANNEL_LEFT (2) ------------------ 610| 47| hInfo->channel_position[1] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 47|#define FRONT_CHANNEL_RIGHT (3) ------------------ 611| 47| return; 612| 47| } 613| | 614| | /* check if there is a PCE */ 615| | /* TODO: why CPE flag is ignored? */ 616| 421| if (hDecoder->pce_set) ------------------ | Branch (616:9): [True: 18, False: 403] ------------------ 617| 18| { 618| 18| uint8_t i, chpos = 0; 619| 18| uint8_t chdir, back_center = 0; 620| | 621| 18| hInfo->num_front_channels = hDecoder->pce.num_front_channels; 622| 18| hInfo->num_side_channels = hDecoder->pce.num_side_channels; 623| 18| hInfo->num_back_channels = hDecoder->pce.num_back_channels; 624| 18| hInfo->num_lfe_channels = hDecoder->pce.num_lfe_channels; 625| 18| chdir = hInfo->num_front_channels; 626| 18| if (chdir & 1) ------------------ | Branch (626:13): [True: 8, False: 10] ------------------ 627| 8| { 628| 8|#if (defined(PS_DEC) || defined(DRM_PS)) 629| 8| if (hInfo->num_front_channels == 1 && ------------------ | Branch (629:17): [True: 0, False: 8] ------------------ 630| 0| hInfo->num_side_channels == 0 && ------------------ | Branch (630:17): [True: 0, False: 0] ------------------ 631| 0| hInfo->num_back_channels == 0 && ------------------ | Branch (631:17): [True: 0, False: 0] ------------------ 632| 0| hInfo->num_lfe_channels == 0) ------------------ | Branch (632:17): [True: 0, False: 0] ------------------ 633| 0| { 634| | /* When PS is enabled output is always stereo */ 635| 0| hInfo->channel_position[chpos++] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 0|#define FRONT_CHANNEL_LEFT (2) ------------------ 636| 0| hInfo->channel_position[chpos++] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 0|#define FRONT_CHANNEL_RIGHT (3) ------------------ 637| 0| } else 638| 8|#endif 639| 8| hInfo->channel_position[chpos++] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 8|#define FRONT_CHANNEL_CENTER (1) ------------------ 640| 8| chdir--; 641| 8| } 642| 138| for (i = 0; i < chdir; i++) ------------------ | Branch (642:21): [True: 120, False: 18] ------------------ 643| 120| { 644| 120| hInfo->channel_position[chpos++] = 645| 120| (i & 1) ? FRONT_CHANNEL_RIGHT : FRONT_CHANNEL_LEFT; ------------------ | | 116| 60|#define FRONT_CHANNEL_RIGHT (3) ------------------ (i & 1) ? FRONT_CHANNEL_RIGHT : FRONT_CHANNEL_LEFT; ------------------ | | 115| 180|#define FRONT_CHANNEL_LEFT (2) ------------------ | Branch (645:17): [True: 60, False: 60] ------------------ 646| 120| } 647| | 648| 161| for (i = 0; i < hInfo->num_side_channels; i++) ------------------ | Branch (648:21): [True: 143, False: 18] ------------------ 649| 143| { 650| 143| hInfo->channel_position[chpos++] = 651| 143| (i & 1) ? SIDE_CHANNEL_RIGHT : SIDE_CHANNEL_LEFT; ------------------ | | 118| 70|#define SIDE_CHANNEL_RIGHT (5) ------------------ (i & 1) ? SIDE_CHANNEL_RIGHT : SIDE_CHANNEL_LEFT; ------------------ | | 117| 216|#define SIDE_CHANNEL_LEFT (4) ------------------ | Branch (651:17): [True: 70, False: 73] ------------------ 652| 143| } 653| | 654| 18| chdir = hInfo->num_back_channels; 655| 18| if (chdir & 1) ------------------ | Branch (655:13): [True: 9, False: 9] ------------------ 656| 9| { 657| 9| back_center = 1; 658| 9| chdir--; 659| 9| } 660| 80| for (i = 0; i < chdir; i++) ------------------ | Branch (660:21): [True: 62, False: 18] ------------------ 661| 62| { 662| 62| hInfo->channel_position[chpos++] = 663| 62| (i & 1) ? BACK_CHANNEL_RIGHT : BACK_CHANNEL_LEFT; ------------------ | | 120| 31|#define BACK_CHANNEL_RIGHT (7) ------------------ (i & 1) ? BACK_CHANNEL_RIGHT : BACK_CHANNEL_LEFT; ------------------ | | 119| 93|#define BACK_CHANNEL_LEFT (6) ------------------ | Branch (663:17): [True: 31, False: 31] ------------------ 664| 62| } 665| 18| if (back_center) ------------------ | Branch (665:13): [True: 9, False: 9] ------------------ 666| 9| { 667| 9| hInfo->channel_position[chpos++] = BACK_CHANNEL_CENTER; ------------------ | | 121| 9|#define BACK_CHANNEL_CENTER (8) ------------------ 668| 9| } 669| | 670| 42| for (i = 0; i < hInfo->num_lfe_channels; i++) ------------------ | Branch (670:21): [True: 24, False: 18] ------------------ 671| 24| { 672| 24| hInfo->channel_position[chpos++] = LFE_CHANNEL; ------------------ | | 122| 24|#define LFE_CHANNEL (9) ------------------ 673| 24| } 674| | 675| 403| } else { 676| 403| switch (hDecoder->channelConfiguration) 677| 403| { 678| 114| case 1: ------------------ | Branch (678:9): [True: 114, False: 289] ------------------ 679| 114|#if (defined(PS_DEC) || defined(DRM_PS)) 680| | /* When PS is enabled output is always stereo */ 681| 114| hInfo->num_front_channels = 2; 682| 114| hInfo->channel_position[0] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 114|#define FRONT_CHANNEL_LEFT (2) ------------------ 683| 114| hInfo->channel_position[1] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 114|#define FRONT_CHANNEL_RIGHT (3) ------------------ 684| |#else 685| | hInfo->num_front_channels = 1; 686| | hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; 687| |#endif 688| 114| break; 689| 85| case 2: ------------------ | Branch (689:9): [True: 85, False: 318] ------------------ 690| 85| hInfo->num_front_channels = 2; 691| 85| hInfo->channel_position[0] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 85|#define FRONT_CHANNEL_LEFT (2) ------------------ 692| 85| hInfo->channel_position[1] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 85|#define FRONT_CHANNEL_RIGHT (3) ------------------ 693| 85| break; 694| 3| case 3: ------------------ | Branch (694:9): [True: 3, False: 400] ------------------ 695| 3| hInfo->num_front_channels = 3; 696| 3| hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 3|#define FRONT_CHANNEL_CENTER (1) ------------------ 697| 3| hInfo->channel_position[1] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 3|#define FRONT_CHANNEL_LEFT (2) ------------------ 698| 3| hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 3|#define FRONT_CHANNEL_RIGHT (3) ------------------ 699| 3| break; 700| 81| case 4: ------------------ | Branch (700:9): [True: 81, False: 322] ------------------ 701| 81| hInfo->num_front_channels = 3; 702| 81| hInfo->num_back_channels = 1; 703| 81| hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 81|#define FRONT_CHANNEL_CENTER (1) ------------------ 704| 81| hInfo->channel_position[1] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 81|#define FRONT_CHANNEL_LEFT (2) ------------------ 705| 81| hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 81|#define FRONT_CHANNEL_RIGHT (3) ------------------ 706| 81| hInfo->channel_position[3] = BACK_CHANNEL_CENTER; ------------------ | | 121| 81|#define BACK_CHANNEL_CENTER (8) ------------------ 707| 81| break; 708| 37| case 5: ------------------ | Branch (708:9): [True: 37, False: 366] ------------------ 709| 37| hInfo->num_front_channels = 3; 710| 37| hInfo->num_back_channels = 2; 711| 37| hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 37|#define FRONT_CHANNEL_CENTER (1) ------------------ 712| 37| hInfo->channel_position[1] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 37|#define FRONT_CHANNEL_LEFT (2) ------------------ 713| 37| hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 37|#define FRONT_CHANNEL_RIGHT (3) ------------------ 714| 37| hInfo->channel_position[3] = BACK_CHANNEL_LEFT; ------------------ | | 119| 37|#define BACK_CHANNEL_LEFT (6) ------------------ 715| 37| hInfo->channel_position[4] = BACK_CHANNEL_RIGHT; ------------------ | | 120| 37|#define BACK_CHANNEL_RIGHT (7) ------------------ 716| 37| break; 717| 30| case 6: ------------------ | Branch (717:9): [True: 30, False: 373] ------------------ 718| 30| hInfo->num_front_channels = 3; 719| 30| hInfo->num_back_channels = 2; 720| 30| hInfo->num_lfe_channels = 1; 721| 30| hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 30|#define FRONT_CHANNEL_CENTER (1) ------------------ 722| 30| hInfo->channel_position[1] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 30|#define FRONT_CHANNEL_LEFT (2) ------------------ 723| 30| hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 30|#define FRONT_CHANNEL_RIGHT (3) ------------------ 724| 30| hInfo->channel_position[3] = BACK_CHANNEL_LEFT; ------------------ | | 119| 30|#define BACK_CHANNEL_LEFT (6) ------------------ 725| 30| hInfo->channel_position[4] = BACK_CHANNEL_RIGHT; ------------------ | | 120| 30|#define BACK_CHANNEL_RIGHT (7) ------------------ 726| 30| hInfo->channel_position[5] = LFE_CHANNEL; ------------------ | | 122| 30|#define LFE_CHANNEL (9) ------------------ 727| 30| break; 728| 52| case 7: ------------------ | Branch (728:9): [True: 52, False: 351] ------------------ 729| 52| hInfo->num_front_channels = 3; 730| 52| hInfo->num_side_channels = 2; 731| 52| hInfo->num_back_channels = 2; 732| 52| hInfo->num_lfe_channels = 1; 733| 52| hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 52|#define FRONT_CHANNEL_CENTER (1) ------------------ 734| 52| hInfo->channel_position[1] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 52|#define FRONT_CHANNEL_LEFT (2) ------------------ 735| 52| hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 52|#define FRONT_CHANNEL_RIGHT (3) ------------------ 736| 52| hInfo->channel_position[3] = SIDE_CHANNEL_LEFT; ------------------ | | 117| 52|#define SIDE_CHANNEL_LEFT (4) ------------------ 737| 52| hInfo->channel_position[4] = SIDE_CHANNEL_RIGHT; ------------------ | | 118| 52|#define SIDE_CHANNEL_RIGHT (5) ------------------ 738| 52| hInfo->channel_position[5] = BACK_CHANNEL_LEFT; ------------------ | | 119| 52|#define BACK_CHANNEL_LEFT (6) ------------------ 739| 52| hInfo->channel_position[6] = BACK_CHANNEL_RIGHT; ------------------ | | 120| 52|#define BACK_CHANNEL_RIGHT (7) ------------------ 740| 52| hInfo->channel_position[7] = LFE_CHANNEL; ------------------ | | 122| 52|#define LFE_CHANNEL (9) ------------------ 741| 52| break; 742| 1| default: /* channelConfiguration == 0 || channelConfiguration > 7 */ ------------------ | Branch (742:9): [True: 1, False: 402] ------------------ 743| 1| { 744| 1| uint8_t i; 745| 1| uint8_t ch = hDecoder->fr_channels - hDecoder->has_lfe; 746| 1| if (ch & 1) /* there's either a center front or a center back channel */ ------------------ | Branch (746:21): [True: 0, False: 1] ------------------ 747| 0| { 748| 0| uint8_t ch1 = (ch-1)/2; 749| 0| if (hDecoder->first_syn_ele == ID_SCE) ------------------ | | 86| 0|#define ID_SCE 0x0 ------------------ | Branch (749:25): [True: 0, False: 0] ------------------ 750| 0| { 751| 0| hInfo->num_front_channels = ch1 + 1; 752| 0| hInfo->num_back_channels = ch1; 753| 0| hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 0|#define FRONT_CHANNEL_CENTER (1) ------------------ 754| 0| for (i = 1; i <= ch1; i+=2) ------------------ | Branch (754:37): [True: 0, False: 0] ------------------ 755| 0| { 756| 0| hInfo->channel_position[i] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 0|#define FRONT_CHANNEL_LEFT (2) ------------------ 757| 0| hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 0|#define FRONT_CHANNEL_RIGHT (3) ------------------ 758| 0| } 759| 0| for (i = ch1+1; i < ch; i+=2) ------------------ | Branch (759:41): [True: 0, False: 0] ------------------ 760| 0| { 761| 0| hInfo->channel_position[i] = BACK_CHANNEL_LEFT; ------------------ | | 119| 0|#define BACK_CHANNEL_LEFT (6) ------------------ 762| 0| hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT; ------------------ | | 120| 0|#define BACK_CHANNEL_RIGHT (7) ------------------ 763| 0| } 764| 0| } else { 765| 0| hInfo->num_front_channels = ch1; 766| 0| hInfo->num_back_channels = ch1 + 1; 767| 0| for (i = 0; i < ch1; i+=2) ------------------ | Branch (767:37): [True: 0, False: 0] ------------------ 768| 0| { 769| 0| hInfo->channel_position[i] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 0|#define FRONT_CHANNEL_LEFT (2) ------------------ 770| 0| hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 0|#define FRONT_CHANNEL_RIGHT (3) ------------------ 771| 0| } 772| 0| for (i = ch1; i < ch-1; i+=2) ------------------ | Branch (772:39): [True: 0, False: 0] ------------------ 773| 0| { 774| 0| hInfo->channel_position[i] = BACK_CHANNEL_LEFT; ------------------ | | 119| 0|#define BACK_CHANNEL_LEFT (6) ------------------ 775| 0| hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT; ------------------ | | 120| 0|#define BACK_CHANNEL_RIGHT (7) ------------------ 776| 0| } 777| 0| hInfo->channel_position[ch-1] = BACK_CHANNEL_CENTER; ------------------ | | 121| 0|#define BACK_CHANNEL_CENTER (8) ------------------ 778| 0| } 779| 1| } else { 780| 1| uint8_t ch1 = (ch)/2; 781| 1| hInfo->num_front_channels = ch1; 782| 1| hInfo->num_back_channels = ch1; 783| 1| if (ch1 & 1) ------------------ | Branch (783:25): [True: 0, False: 1] ------------------ 784| 0| { 785| 0| hInfo->channel_position[0] = FRONT_CHANNEL_CENTER; ------------------ | | 114| 0|#define FRONT_CHANNEL_CENTER (1) ------------------ 786| 0| for (i = 1; i <= ch1; i+=2) ------------------ | Branch (786:37): [True: 0, False: 0] ------------------ 787| 0| { 788| 0| hInfo->channel_position[i] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 0|#define FRONT_CHANNEL_LEFT (2) ------------------ 789| 0| hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 0|#define FRONT_CHANNEL_RIGHT (3) ------------------ 790| 0| } 791| 0| for (i = ch1+1; i < ch-1; i+=2) ------------------ | Branch (791:41): [True: 0, False: 0] ------------------ 792| 0| { 793| 0| hInfo->channel_position[i] = BACK_CHANNEL_LEFT; ------------------ | | 119| 0|#define BACK_CHANNEL_LEFT (6) ------------------ 794| 0| hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT; ------------------ | | 120| 0|#define BACK_CHANNEL_RIGHT (7) ------------------ 795| 0| } 796| 0| hInfo->channel_position[ch-1] = BACK_CHANNEL_CENTER; ------------------ | | 121| 0|#define BACK_CHANNEL_CENTER (8) ------------------ 797| 1| } else { 798| 17| for (i = 0; i < ch1; i+=2) ------------------ | Branch (798:37): [True: 16, False: 1] ------------------ 799| 16| { 800| 16| hInfo->channel_position[i] = FRONT_CHANNEL_LEFT; ------------------ | | 115| 16|#define FRONT_CHANNEL_LEFT (2) ------------------ 801| 16| hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT; ------------------ | | 116| 16|#define FRONT_CHANNEL_RIGHT (3) ------------------ 802| 16| } 803| 17| for (i = ch1; i < ch; i+=2) ------------------ | Branch (803:39): [True: 16, False: 1] ------------------ 804| 16| { 805| 16| hInfo->channel_position[i] = BACK_CHANNEL_LEFT; ------------------ | | 119| 16|#define BACK_CHANNEL_LEFT (6) ------------------ 806| 16| hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT; ------------------ | | 120| 16|#define BACK_CHANNEL_RIGHT (7) ------------------ 807| 16| } 808| 1| } 809| 1| } 810| 1| hInfo->num_lfe_channels = hDecoder->has_lfe; 811| 1| for (i = ch; i < hDecoder->fr_channels; i++) ------------------ | Branch (811:30): [True: 0, False: 1] ------------------ 812| 0| { 813| 0| hInfo->channel_position[i] = LFE_CHANNEL; ------------------ | | 122| 0|#define LFE_CHANNEL (9) ------------------ 814| 0| } 815| 1| } 816| 1| break; 817| 403| } 818| 403| } 819| 421|} drc_init: 39| 1.68k|{ 40| 1.68k| drc_info *drc = (drc_info*)faad_malloc(sizeof(drc_info)); 41| 1.68k| memset(drc, 0, sizeof(drc_info)); 42| | 43| 1.68k| drc->ctrl1 = cut; 44| 1.68k| drc->ctrl2 = boost; 45| | 46| 1.68k| drc->num_bands = 1; 47| 1.68k| drc->band_top[0] = 1024/4 - 1; 48| 1.68k| drc->dyn_rng_sgn[0] = 1; 49| 1.68k| drc->dyn_rng_ctl[0] = 0; 50| | 51| 1.68k| return drc; 52| 1.68k|} drc_end: 55| 1.68k|{ 56| 1.68k| if (drc) faad_free(drc); ------------------ | Branch (56:9): [True: 1.68k, False: 0] ------------------ 57| 1.68k|} drm_ps_data: 445| 250k|{ 446| 250k| uint16_t bits = (uint16_t)faad_get_processed_bits(ld); 447| | 448| 250k| ps->drm_ps_data_available = 1; 449| | 450| 250k| ps->bs_enable_sa = faad_get1bit(ld); 451| 250k| ps->bs_enable_pan = faad_get1bit(ld); 452| | 453| 250k| if (ps->bs_enable_sa) ------------------ | Branch (453:9): [True: 8.62k, False: 241k] ------------------ 454| 8.62k| { 455| 8.62k| drm_ps_sa_element(ps, ld); 456| 8.62k| } 457| | 458| 250k| if (ps->bs_enable_pan) ------------------ | Branch (458:9): [True: 6.39k, False: 243k] ------------------ 459| 6.39k| { 460| 6.39k| drm_ps_pan_element(ps, ld); 461| 6.39k| } 462| | 463| 250k| bits = (uint16_t)faad_get_processed_bits(ld) - bits; 464| | 465| 250k| return bits; 466| 250k|} drm_ps_init: 890| 2.23k|{ 891| 2.23k| drm_ps_info *ps = (drm_ps_info*)faad_malloc(sizeof(drm_ps_info)); 892| | 893| 2.23k| memset(ps, 0, sizeof(drm_ps_info)); 894| | 895| 2.23k| return ps; 896| 2.23k|} drm_ps_free: 899| 2.23k|{ 900| 2.23k| faad_free(ps); 901| 2.23k|} drm_ps_decode: 905| 63|{ 906| 63| if (ps == NULL) ------------------ | Branch (906:9): [True: 0, False: 63] ------------------ 907| 0| { 908| 0| memcpy(X_right, X_left, sizeof(qmf_t)*30*64); 909| 0| return 0; 910| 0| } 911| | 912| 63| if (!ps->drm_ps_data_available && !guess) ------------------ | Branch (912:9): [True: 0, False: 63] | Branch (912:39): [True: 0, False: 0] ------------------ 913| 0| { 914| 0| memcpy(X_right, X_left, sizeof(qmf_t)*30*64); 915| 0| memset(ps->g_prev_sa_index, 0, sizeof(ps->g_prev_sa_index)); 916| 0| memset(ps->g_prev_pan_index, 0, sizeof(ps->g_prev_pan_index)); 917| 0| return 0; 918| 0| } 919| | 920| | /* if SBR CRC doesn't match out, we can assume decode errors to start with, 921| | and we'll guess what the parameters should be */ 922| 63| if (!guess) ------------------ | Branch (922:9): [True: 24, False: 39] ------------------ 923| 24| { 924| 24| ps->sa_decode_error = 0; 925| 24| ps->pan_decode_error = 0; 926| 24| drm_ps_delta_decode(ps); 927| 24| } else 928| 39| { 929| 39| ps->sa_decode_error = 1; 930| 39| ps->pan_decode_error = 1; 931| | /* don't even bother decoding */ 932| 39| } 933| | 934| 63| ps->drm_ps_data_available = 0; 935| | 936| 63| drm_calc_sa_side_signal(ps, X_left); 937| 63| drm_add_ambiance(ps, X_left, X_right); 938| | 939| 63| if (ps->bs_enable_sa) ------------------ | Branch (939:9): [True: 19, False: 44] ------------------ 940| 19| { 941| 19| ps->g_last_had_sa = 1; 942| | 943| 19| memcpy(ps->g_prev_sa_index, ps->g_sa_index, sizeof(int8_t) * DRM_NUM_SA_BANDS); ------------------ | | 41| 19|#define DRM_NUM_SA_BANDS 8 ------------------ 944| | 945| 44| } else { 946| 44| ps->g_last_had_sa = 0; 947| 44| } 948| | 949| 63| if (ps->bs_enable_pan) ------------------ | Branch (949:9): [True: 26, False: 37] ------------------ 950| 26| { 951| 26| drm_add_pan(ps, X_left, X_right); 952| | 953| 26| ps->g_last_had_pan = 1; 954| | 955| 26| memcpy(ps->g_prev_pan_index, ps->g_pan_index, sizeof(int8_t) * DRM_NUM_PAN_BANDS); ------------------ | | 42| 26|#define DRM_NUM_PAN_BANDS 20 ------------------ 956| | 957| 37| } else { 958| 37| ps->g_last_had_pan = 0; 959| 37| } 960| | 961| | 962| 63| return 0; 963| 63|} drm_dec.c:drm_ps_sa_element: 469| 8.62k|{ 470| 8.62k| drm_ps_huff_tab huff; 471| 8.62k| uint8_t band; 472| | 473| 8.62k| ps->bs_sa_dt_flag = faad_get1bit(ld); 474| 8.62k| if (ps->bs_sa_dt_flag) ------------------ | Branch (474:9): [True: 4.29k, False: 4.32k] ------------------ 475| 4.29k| { 476| 4.29k| huff = t_huffman_sa; 477| 4.32k| } else { 478| 4.32k| huff = f_huffman_sa; 479| 4.32k| } 480| | 481| 77.5k| for (band = 0; band < DRM_NUM_SA_BANDS; band++) ------------------ | | 41| 77.5k|#define DRM_NUM_SA_BANDS 8 ------------------ | Branch (481:20): [True: 68.9k, False: 8.62k] ------------------ 482| 68.9k| { 483| 68.9k| ps->bs_sa_data[band] = huff_dec(ld, huff); 484| 68.9k| } 485| 8.62k|} drm_dec.c:huff_dec: 508| 196k|{ 509| 196k| uint8_t bit; 510| 196k| int8_t index = 0; 511| | 512| 555k| while (index >= 0) ------------------ | Branch (512:12): [True: 358k, False: 196k] ------------------ 513| 358k| { 514| 358k| bit = (uint8_t)faad_get1bit(ld); 515| 358k| index = huff[index][bit]; 516| 358k| } 517| | 518| 196k| return index + 15; 519| 196k|} drm_dec.c:drm_ps_pan_element: 488| 6.39k|{ 489| 6.39k| drm_ps_huff_tab huff; 490| 6.39k| uint8_t band; 491| | 492| 6.39k| ps->bs_pan_dt_flag = faad_get1bit(ld); 493| 6.39k| if (ps->bs_pan_dt_flag) ------------------ | Branch (493:9): [True: 1.28k, False: 5.11k] ------------------ 494| 1.28k| { 495| 1.28k| huff = t_huffman_pan; 496| 5.11k| } else { 497| 5.11k| huff = f_huffman_pan; 498| 5.11k| } 499| | 500| 134k| for (band = 0; band < DRM_NUM_PAN_BANDS; band++) ------------------ | | 42| 134k|#define DRM_NUM_PAN_BANDS 20 ------------------ | Branch (500:20): [True: 127k, False: 6.39k] ------------------ 501| 127k| { 502| 127k| ps->bs_pan_data[band] = huff_dec(ld, huff); 503| 127k| } 504| 6.39k|} drm_dec.c:drm_ps_delta_decode: 551| 24|{ 552| 24| uint8_t band; 553| | 554| 24| if (ps->bs_enable_sa) ------------------ | Branch (554:9): [True: 15, False: 9] ------------------ 555| 15| { 556| 15| if (ps->bs_sa_dt_flag && !ps->g_last_had_sa) ------------------ | Branch (556:13): [True: 1, False: 14] | Branch (556:34): [True: 1, False: 0] ------------------ 557| 1| { 558| | /* wait until we get a DT frame */ 559| 1| ps->bs_enable_sa = 0; 560| 14| } else if (ps->bs_sa_dt_flag) { ------------------ | Branch (560:20): [True: 0, False: 14] ------------------ 561| | /* DT frame, we have a last frame, so we can decode */ 562| 0| ps->g_sa_index[0] = sa_delta_clip(ps, ps->g_prev_sa_index[0]+ps->bs_sa_data[0]); 563| 14| } else { 564| | /* DF always decodable */ 565| 14| ps->g_sa_index[0] = sa_delta_clip(ps,ps->bs_sa_data[0]); 566| 14| } 567| | 568| 120| for (band = 1; band < DRM_NUM_SA_BANDS; band++) ------------------ | | 41| 120|#define DRM_NUM_SA_BANDS 8 ------------------ | Branch (568:24): [True: 105, False: 15] ------------------ 569| 105| { 570| 105| if (ps->bs_sa_dt_flag && ps->g_last_had_sa) ------------------ | Branch (570:17): [True: 7, False: 98] | Branch (570:38): [True: 0, False: 7] ------------------ 571| 0| { 572| 0| ps->g_sa_index[band] = sa_delta_clip(ps, ps->g_prev_sa_index[band] + ps->bs_sa_data[band]); 573| 105| } else if (!ps->bs_sa_dt_flag) { ------------------ | Branch (573:24): [True: 98, False: 7] ------------------ 574| 98| ps->g_sa_index[band] = sa_delta_clip(ps, ps->g_sa_index[band-1] + ps->bs_sa_data[band]); 575| 98| } 576| 105| } 577| 15| } 578| | 579| | /* An error during SA decoding implies PAN data will be undecodable, too */ 580| | /* Also, we don't like on/off switching in PS, so we force to last settings */ 581| 24| if (ps->sa_decode_error) { ------------------ | Branch (581:9): [True: 14, False: 10] ------------------ 582| 14| ps->pan_decode_error = 1; 583| 14| ps->bs_enable_pan = ps->g_last_had_pan; 584| 14| ps->bs_enable_sa = ps->g_last_had_sa; 585| 14| } 586| | 587| | 588| 24| if (ps->bs_enable_sa) ------------------ | Branch (588:9): [True: 0, False: 24] ------------------ 589| 0| { 590| 0| if (ps->sa_decode_error) { ------------------ | Branch (590:13): [True: 0, False: 0] ------------------ 591| 0| for (band = 0; band < DRM_NUM_SA_BANDS; band++) ------------------ | | 41| 0|#define DRM_NUM_SA_BANDS 8 ------------------ | Branch (591:28): [True: 0, False: 0] ------------------ 592| 0| { 593| 0| ps->g_sa_index[band] = ps->g_last_good_sa_index[band]; 594| 0| } 595| 0| } else { 596| 0| for (band = 0; band < DRM_NUM_SA_BANDS; band++) ------------------ | | 41| 0|#define DRM_NUM_SA_BANDS 8 ------------------ | Branch (596:28): [True: 0, False: 0] ------------------ 597| 0| { 598| 0| ps->g_last_good_sa_index[band] = ps->g_sa_index[band]; 599| 0| } 600| 0| } 601| 0| } 602| | 603| 24| if (ps->bs_enable_pan) ------------------ | Branch (603:9): [True: 10, False: 14] ------------------ 604| 10| { 605| 10| if (ps->bs_pan_dt_flag && !ps->g_last_had_pan) ------------------ | Branch (605:13): [True: 4, False: 6] | Branch (605:35): [True: 0, False: 4] ------------------ 606| 0| { 607| 0| ps->bs_enable_pan = 0; 608| 10| } else if (ps->bs_pan_dt_flag) { ------------------ | Branch (608:21): [True: 4, False: 6] ------------------ 609| 4| ps->g_pan_index[0] = pan_delta_clip(ps, ps->g_prev_pan_index[0]+ps->bs_pan_data[0]); 610| 6| } else { 611| 6| ps->g_pan_index[0] = pan_delta_clip(ps, ps->bs_pan_data[0]); 612| 6| } 613| | 614| 200| for (band = 1; band < DRM_NUM_PAN_BANDS; band++) ------------------ | | 42| 200|#define DRM_NUM_PAN_BANDS 20 ------------------ | Branch (614:24): [True: 190, False: 10] ------------------ 615| 190| { 616| 190| if (ps->bs_pan_dt_flag && ps->g_last_had_pan) ------------------ | Branch (616:17): [True: 76, False: 114] | Branch (616:39): [True: 76, False: 0] ------------------ 617| 76| { 618| 76| ps->g_pan_index[band] = pan_delta_clip(ps, ps->g_prev_pan_index[band] + ps->bs_pan_data[band]); 619| 114| } else if (!ps->bs_pan_dt_flag) { ------------------ | Branch (619:24): [True: 114, False: 0] ------------------ 620| 114| ps->g_pan_index[band] = pan_delta_clip(ps, ps->g_pan_index[band-1] + ps->bs_pan_data[band]); 621| 114| } 622| 190| } 623| | 624| 10| if (ps->pan_decode_error) { ------------------ | Branch (624:13): [True: 10, False: 0] ------------------ 625| 210| for (band = 0; band < DRM_NUM_PAN_BANDS; band++) ------------------ | | 42| 210|#define DRM_NUM_PAN_BANDS 20 ------------------ | Branch (625:28): [True: 200, False: 10] ------------------ 626| 200| { 627| 200| ps->g_pan_index[band] = ps->g_last_good_pan_index[band]; 628| 200| } 629| 10| } else { 630| 0| for (band = 0; band < DRM_NUM_PAN_BANDS; band++) ------------------ | | 42| 0|#define DRM_NUM_PAN_BANDS 20 ------------------ | Branch (630:28): [True: 0, False: 0] ------------------ 631| 0| { 632| 0| ps->g_last_good_pan_index[band] = ps->g_pan_index[band]; 633| 0| } 634| 0| } 635| 10| } 636| 24|} drm_dec.c:sa_delta_clip: 523| 112|{ 524| 112| if (i < 0) { ------------------ | Branch (524:9): [True: 91, False: 21] ------------------ 525| | /* printf(" SAminclip %d", i); */ 526| 91| ps->sa_decode_error = 1; 527| 91| return 0; 528| 91| } else if (i > 7) { ------------------ | Branch (528:16): [True: 3, False: 18] ------------------ 529| | /* printf(" SAmaxclip %d", i); */ 530| 3| ps->sa_decode_error = 1; 531| 3| return 7; 532| 3| } else 533| 18| return i; 534| 112|} drm_dec.c:pan_delta_clip: 537| 200|{ 538| 200| if (i < -7) { ------------------ | Branch (538:9): [True: 29, False: 171] ------------------ 539| | /* printf(" PANminclip %d", i); */ 540| 29| ps->pan_decode_error = 1; 541| 29| return -7; 542| 171| } else if (i > 7) { ------------------ | Branch (542:16): [True: 81, False: 90] ------------------ 543| | /* printf(" PANmaxclip %d", i); */ 544| 81| ps->pan_decode_error = 1; 545| 81| return 7; 546| 81| } else 547| 90| return i; 548| 200|} drm_dec.c:drm_calc_sa_side_signal: 639| 63|{ 640| 63| uint8_t s, b, k; 641| 63| complex_t qfrac, tmp0, tmp, in, R0; 642| 63| real_t peakdiff; 643| 63| real_t nrg; 644| 63| real_t power; 645| 63| real_t transratio; 646| 63| real_t new_delay_slopes[NUM_OF_LINKS]; 647| 63| uint8_t temp_delay_ser[NUM_OF_LINKS]; 648| 63| complex_t Phi_Fract; 649| 63|#ifdef FIXED_POINT 650| 63| uint32_t in_re, in_im; 651| 63|#endif 652| | 653| 1.51k| for (b = 0; b < sa_freq_scale[DRM_NUM_SA_BANDS]; b++) ------------------ | | 41| 1.51k|#define DRM_NUM_SA_BANDS 8 ------------------ | Branch (653:17): [True: 1.44k, False: 63] ------------------ 654| 1.44k| { 655| | /* set delay indices */ 656| 5.79k| for (k = 0; k < NUM_OF_LINKS; k++) ------------------ | | 43| 5.79k|#define NUM_OF_LINKS 3 ------------------ | Branch (656:21): [True: 4.34k, False: 1.44k] ------------------ 657| 4.34k| temp_delay_ser[k] = ps->delay_buf_index_ser[k]; 658| | 659| 1.44k| RE(Phi_Fract) = RE(Phi_Fract_Qmf[b]); ------------------ | | 391| 1.44k|#define RE(A) (A)[0] ------------------ RE(Phi_Fract) = RE(Phi_Fract_Qmf[b]); ------------------ | | 391| 1.44k|#define RE(A) (A)[0] ------------------ 660| 1.44k| IM(Phi_Fract) = IM(Phi_Fract_Qmf[b]); ------------------ | | 392| 1.44k|#define IM(A) (A)[1] ------------------ IM(Phi_Fract) = IM(Phi_Fract_Qmf[b]); ------------------ | | 392| 1.44k|#define IM(A) (A)[1] ------------------ 661| | 662| 44.9k| for (s = 0; s < NUM_OF_SUBSAMPLES; s++) ------------------ | | 45| 44.9k|#define NUM_OF_SUBSAMPLES 30 ------------------ | Branch (662:21): [True: 43.4k, False: 1.44k] ------------------ 663| 43.4k| { 664| 43.4k| const real_t gamma = REAL_CONST(1.5); ------------------ | | 59| 43.4k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 43.4k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 43.4k, Folded] | | ------------------ ------------------ 665| 43.4k| const real_t sigma = REAL_CONST(1.5625); ------------------ | | 59| 43.4k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 43.4k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 43.4k, Folded] | | ------------------ ------------------ 666| | 667| 43.4k| RE(in) = QMF_RE(X[s][b]); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ RE(in) = QMF_RE(X[s][b]); ------------------ | | 168| 43.4k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 43.4k|#define RE(A) (A)[0] | | ------------------ ------------------ 668| 43.4k| IM(in) = QMF_IM(X[s][b]); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ IM(in) = QMF_IM(X[s][b]); ------------------ | | 169| 43.4k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 43.4k|#define IM(A) (A)[1] | | ------------------ ------------------ 669| | 670| 43.4k|#ifdef FIXED_POINT 671| | /* NOTE: all input is scaled by 2^(-5) because of fixed point QMF 672| | * meaning that P will be scaled by 2^(-10) compared to floating point version 673| | */ 674| 43.4k| in_re = ((abs(RE(in))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ in_re = ((abs(RE(in))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ in_re = ((abs(RE(in))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 675| 43.4k| in_im = ((abs(IM(in))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ in_im = ((abs(IM(in))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ in_im = ((abs(IM(in))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 676| 43.4k| power = in_re*in_re + in_im*in_im; 677| |#else 678| | power = MUL_R(RE(in),RE(in)) + MUL_R(IM(in),IM(in)); 679| |#endif 680| | 681| 43.4k| ps->peakdecay_fast[b] = MUL_F(ps->peakdecay_fast[b], peak_decay); ------------------ | | 268| 43.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 682| 43.4k| if (ps->peakdecay_fast[b] < power) ------------------ | Branch (682:17): [True: 5.87k, False: 37.5k] ------------------ 683| 5.87k| ps->peakdecay_fast[b] = power; 684| | 685| 43.4k| peakdiff = ps->prev_peakdiff[b]; 686| 43.4k| peakdiff += MUL_F((ps->peakdecay_fast[b] - power - ps->prev_peakdiff[b]), smooth_coeff); ------------------ | | 268| 43.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 687| 43.4k| ps->prev_peakdiff[b] = peakdiff; 688| | 689| 43.4k| nrg = ps->prev_nrg[b]; 690| 43.4k| nrg += MUL_F((power - ps->prev_nrg[b]), smooth_coeff); ------------------ | | 268| 43.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 691| 43.4k| ps->prev_nrg[b] = nrg; 692| | 693| 43.4k| if (MUL_R(peakdiff, gamma) <= nrg) { ------------------ | | 239| 43.4k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ | Branch (693:17): [True: 41.0k, False: 2.41k] ------------------ 694| 41.0k| transratio = sigma; 695| 41.0k| } else { 696| 2.41k| transratio = MUL_R(DIV_R(nrg, MUL_R(peakdiff, gamma)), sigma); ------------------ | | 239| 2.41k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 2.41k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 2.41k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 697| 2.41k| } 698| | 699| 173k| for (k = 0; k < NUM_OF_LINKS; k++) ------------------ | | 43| 173k|#define NUM_OF_LINKS 3 ------------------ | Branch (699:25): [True: 130k, False: 43.4k] ------------------ 700| 130k| { 701| 130k| new_delay_slopes[k] = MUL_F(g_decayslope[b], filter_coeff[k]); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 702| 130k| } 703| | 704| 43.4k| RE(tmp0) = RE(ps->d_buff[0][b]); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ RE(tmp0) = RE(ps->d_buff[0][b]); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ 705| 43.4k| IM(tmp0) = IM(ps->d_buff[0][b]); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ IM(tmp0) = IM(ps->d_buff[0][b]); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ 706| | 707| 43.4k| RE(ps->d_buff[0][b]) = RE(ps->d_buff[1][b]); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ RE(ps->d_buff[0][b]) = RE(ps->d_buff[1][b]); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ 708| 43.4k| IM(ps->d_buff[0][b]) = IM(ps->d_buff[1][b]); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ IM(ps->d_buff[0][b]) = IM(ps->d_buff[1][b]); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ 709| | 710| 43.4k| RE(ps->d_buff[1][b]) = RE(in); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ RE(ps->d_buff[1][b]) = RE(in); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ 711| 43.4k| IM(ps->d_buff[1][b]) = IM(in); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ IM(ps->d_buff[1][b]) = IM(in); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ 712| | 713| 43.4k| ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ 714| | 715| 43.4k| RE(R0) = RE(tmp); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ RE(R0) = RE(tmp); ------------------ | | 391| 43.4k|#define RE(A) (A)[0] ------------------ 716| 43.4k| IM(R0) = IM(tmp); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ IM(R0) = IM(tmp); ------------------ | | 392| 43.4k|#define IM(A) (A)[1] ------------------ 717| | 718| 173k| for (k = 0; k < NUM_OF_LINKS; k++) ------------------ | | 43| 173k|#define NUM_OF_LINKS 3 ------------------ | Branch (718:25): [True: 130k, False: 43.4k] ------------------ 719| 130k| { 720| 130k| RE(qfrac) = RE(Q_Fract_allpass_Qmf[b][k]); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ RE(qfrac) = RE(Q_Fract_allpass_Qmf[b][k]); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ 721| 130k| IM(qfrac) = IM(Q_Fract_allpass_Qmf[b][k]); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ IM(qfrac) = IM(Q_Fract_allpass_Qmf[b][k]); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ 722| | 723| 130k| RE(tmp0) = RE(ps->d2_buff[k][temp_delay_ser[k]][b]); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ RE(tmp0) = RE(ps->d2_buff[k][temp_delay_ser[k]][b]); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ 724| 130k| IM(tmp0) = IM(ps->d2_buff[k][temp_delay_ser[k]][b]); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ IM(tmp0) = IM(ps->d2_buff[k][temp_delay_ser[k]][b]); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ 725| | 726| 130k| ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(qfrac), IM(qfrac)); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(qfrac), IM(qfrac)); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(qfrac), IM(qfrac)); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(qfrac), IM(qfrac)); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(qfrac), IM(qfrac)); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(qfrac), IM(qfrac)); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ 727| | 728| 130k| RE(tmp) += -MUL_F(new_delay_slopes[k], RE(R0)); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ RE(tmp) += -MUL_F(new_delay_slopes[k], RE(R0)); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 729| 130k| IM(tmp) += -MUL_F(new_delay_slopes[k], IM(R0)); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ IM(tmp) += -MUL_F(new_delay_slopes[k], IM(R0)); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 730| | 731| 130k| RE(ps->d2_buff[k][temp_delay_ser[k]][b]) = RE(R0) + MUL_F(new_delay_slopes[k], RE(tmp)); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ RE(ps->d2_buff[k][temp_delay_ser[k]][b]) = RE(R0) + MUL_F(new_delay_slopes[k], RE(tmp)); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ RE(ps->d2_buff[k][temp_delay_ser[k]][b]) = RE(R0) + MUL_F(new_delay_slopes[k], RE(tmp)); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 732| 130k| IM(ps->d2_buff[k][temp_delay_ser[k]][b]) = IM(R0) + MUL_F(new_delay_slopes[k], IM(tmp)); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ IM(ps->d2_buff[k][temp_delay_ser[k]][b]) = IM(R0) + MUL_F(new_delay_slopes[k], IM(tmp)); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ IM(ps->d2_buff[k][temp_delay_ser[k]][b]) = IM(R0) + MUL_F(new_delay_slopes[k], IM(tmp)); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 733| | 734| 130k| RE(R0) = RE(tmp); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ RE(R0) = RE(tmp); ------------------ | | 391| 130k|#define RE(A) (A)[0] ------------------ 735| 130k| IM(R0) = IM(tmp); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ IM(R0) = IM(tmp); ------------------ | | 392| 130k|#define IM(A) (A)[1] ------------------ 736| 130k| } 737| | 738| 43.4k| QMF_RE(ps->SA[s][b]) = MUL_R(RE(R0), transratio); ------------------ | | 168| 43.4k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 43.4k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(ps->SA[s][b]) = MUL_R(RE(R0), transratio); ------------------ | | 239| 43.4k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 739| 43.4k| QMF_IM(ps->SA[s][b]) = MUL_R(IM(R0), transratio); ------------------ | | 169| 43.4k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 43.4k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(ps->SA[s][b]) = MUL_R(IM(R0), transratio); ------------------ | | 239| 43.4k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 43.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 740| | 741| 173k| for (k = 0; k < NUM_OF_LINKS; k++) ------------------ | | 43| 173k|#define NUM_OF_LINKS 3 ------------------ | Branch (741:25): [True: 130k, False: 43.4k] ------------------ 742| 130k| { 743| 130k| if (++temp_delay_ser[k] >= delay_length[k]) ------------------ | Branch (743:21): [True: 33.4k, False: 96.9k] ------------------ 744| 33.4k| temp_delay_ser[k] = 0; 745| 130k| } 746| 43.4k| } 747| 1.44k| } 748| | 749| 252| for (k = 0; k < NUM_OF_LINKS; k++) ------------------ | | 43| 252|#define NUM_OF_LINKS 3 ------------------ | Branch (749:17): [True: 189, False: 63] ------------------ 750| 189| ps->delay_buf_index_ser[k] = temp_delay_ser[k]; 751| 63|} drm_dec.c:drm_add_ambiance: 754| 63|{ 755| 63| uint8_t s, b, ifreq, qclass; 756| 63| real_t sa_map[MAX_SA_BAND], sa_dir_map[MAX_SA_BAND], k_sa_map[MAX_SA_BAND], k_sa_dir_map[MAX_SA_BAND]; 757| 63| real_t new_dir_map, new_sa_map; 758| | 759| 63| if (ps->bs_enable_sa) ------------------ | Branch (759:9): [True: 19, False: 44] ------------------ 760| 19| { 761| | /* Instead of dequantization and mapping, we use an inverse mapping 762| | to look up all the values we need */ 763| 456| for (b = 0; b < sa_freq_scale[DRM_NUM_SA_BANDS]; b++) ------------------ | | 41| 456|#define DRM_NUM_SA_BANDS 8 ------------------ | Branch (763:21): [True: 437, False: 19] ------------------ 764| 437| { 765| 437| const real_t inv_f_num_of_subsamples = FRAC_CONST(0.03333333333); ------------------ | | 61| 437|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 437|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 437|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 437] | | | Branch (61:62): [True: 437, Folded] | | ------------------ ------------------ 766| | 767| 437| ifreq = sa_inv_freq[b]; 768| 437| qclass = (b != 0); 769| | 770| 437| sa_map[b] = sa_quant[ps->g_prev_sa_index[ifreq]][qclass]; 771| 437| new_sa_map = sa_quant[ps->g_sa_index[ifreq]][qclass]; 772| | 773| 437| k_sa_map[b] = MUL_F(inv_f_num_of_subsamples, (new_sa_map - sa_map[b])); ------------------ | | 268| 437| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 437|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 437|#define FRAC_BITS 31 | | ------------------ ------------------ 774| | 775| 437| sa_dir_map[b] = sa_sqrt_1_minus[ps->g_prev_sa_index[ifreq]][qclass]; 776| 437| new_dir_map = sa_sqrt_1_minus[ps->g_sa_index[ifreq]][qclass]; 777| | 778| 437| k_sa_dir_map[b] = MUL_F(inv_f_num_of_subsamples, (new_dir_map - sa_dir_map[b])); ------------------ | | 268| 437| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 437|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 437|#define FRAC_BITS 31 | | ------------------ ------------------ 779| | 780| 437| } 781| | 782| 589| for (s = 0; s < NUM_OF_SUBSAMPLES; s++) ------------------ | | 45| 589|#define NUM_OF_SUBSAMPLES 30 ------------------ | Branch (782:21): [True: 570, False: 19] ------------------ 783| 570| { 784| 13.6k| for (b = 0; b < sa_freq_scale[DRM_NUM_SA_BANDS]; b++) ------------------ | | 41| 13.6k|#define DRM_NUM_SA_BANDS 8 ------------------ | Branch (784:25): [True: 13.1k, False: 570] ------------------ 785| 13.1k| { 786| 13.1k| QMF_RE(X_right[s][b]) = MUL_F(QMF_RE(X_left[s][b]), sa_dir_map[b]) - MUL_F(QMF_RE(ps->SA[s][b]), sa_map[b]); ------------------ | | 168| 13.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 13.1k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_right[s][b]) = MUL_F(QMF_RE(X_left[s][b]), sa_dir_map[b]) - MUL_F(QMF_RE(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ QMF_RE(X_right[s][b]) = MUL_F(QMF_RE(X_left[s][b]), sa_dir_map[b]) - MUL_F(QMF_RE(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ 787| 13.1k| QMF_IM(X_right[s][b]) = MUL_F(QMF_IM(X_left[s][b]), sa_dir_map[b]) - MUL_F(QMF_IM(ps->SA[s][b]), sa_map[b]); ------------------ | | 169| 13.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 13.1k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_right[s][b]) = MUL_F(QMF_IM(X_left[s][b]), sa_dir_map[b]) - MUL_F(QMF_IM(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ QMF_IM(X_right[s][b]) = MUL_F(QMF_IM(X_left[s][b]), sa_dir_map[b]) - MUL_F(QMF_IM(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ 788| 13.1k| QMF_RE(X_left[s][b]) = MUL_F(QMF_RE(X_left[s][b]), sa_dir_map[b]) + MUL_F(QMF_RE(ps->SA[s][b]), sa_map[b]); ------------------ | | 168| 13.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 13.1k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_left[s][b]) = MUL_F(QMF_RE(X_left[s][b]), sa_dir_map[b]) + MUL_F(QMF_RE(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ QMF_RE(X_left[s][b]) = MUL_F(QMF_RE(X_left[s][b]), sa_dir_map[b]) + MUL_F(QMF_RE(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ 789| 13.1k| QMF_IM(X_left[s][b]) = MUL_F(QMF_IM(X_left[s][b]), sa_dir_map[b]) + MUL_F(QMF_IM(ps->SA[s][b]), sa_map[b]); ------------------ | | 169| 13.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 13.1k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_left[s][b]) = MUL_F(QMF_IM(X_left[s][b]), sa_dir_map[b]) + MUL_F(QMF_IM(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ QMF_IM(X_left[s][b]) = MUL_F(QMF_IM(X_left[s][b]), sa_dir_map[b]) + MUL_F(QMF_IM(ps->SA[s][b]), sa_map[b]); ------------------ | | 268| 13.1k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.1k|#define FRAC_BITS 31 | | ------------------ ------------------ 790| | 791| 13.1k| sa_map[b] += k_sa_map[b]; 792| 13.1k| sa_dir_map[b] += k_sa_dir_map[b]; 793| 13.1k| } 794| 23.9k| for (b = sa_freq_scale[DRM_NUM_SA_BANDS]; b < NUM_OF_QMF_CHANNELS; b++) ------------------ | | 41| 570|#define DRM_NUM_SA_BANDS 8 ------------------ for (b = sa_freq_scale[DRM_NUM_SA_BANDS]; b < NUM_OF_QMF_CHANNELS; b++) ------------------ | | 44| 23.9k|#define NUM_OF_QMF_CHANNELS 64 ------------------ | Branch (794:55): [True: 23.3k, False: 570] ------------------ 795| 23.3k| { 796| 23.3k| QMF_RE(X_right[s][b]) = QMF_RE(X_left[s][b]); ------------------ | | 168| 23.3k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 23.3k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_right[s][b]) = QMF_RE(X_left[s][b]); ------------------ | | 168| 23.3k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 23.3k|#define RE(A) (A)[0] | | ------------------ ------------------ 797| 23.3k| QMF_IM(X_right[s][b]) = QMF_IM(X_left[s][b]); ------------------ | | 169| 23.3k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 23.3k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_right[s][b]) = QMF_IM(X_left[s][b]); ------------------ | | 169| 23.3k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 23.3k|#define IM(A) (A)[1] | | ------------------ ------------------ 798| 23.3k| } 799| 570| } 800| 19| } 801| 44| else { 802| 1.36k| for (s = 0; s < NUM_OF_SUBSAMPLES; s++) ------------------ | | 45| 1.36k|#define NUM_OF_SUBSAMPLES 30 ------------------ | Branch (802:21): [True: 1.32k, False: 44] ------------------ 803| 1.32k| { 804| 85.8k| for (b = 0; b < NUM_OF_QMF_CHANNELS; b++) ------------------ | | 44| 85.8k|#define NUM_OF_QMF_CHANNELS 64 ------------------ | Branch (804:25): [True: 84.4k, False: 1.32k] ------------------ 805| 84.4k| { 806| 84.4k| QMF_RE(X_right[s][b]) = QMF_RE(X_left[s][b]); ------------------ | | 168| 84.4k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 84.4k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_right[s][b]) = QMF_RE(X_left[s][b]); ------------------ | | 168| 84.4k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 84.4k|#define RE(A) (A)[0] | | ------------------ ------------------ 807| 84.4k| QMF_IM(X_right[s][b]) = QMF_IM(X_left[s][b]); ------------------ | | 169| 84.4k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 84.4k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_right[s][b]) = QMF_IM(X_left[s][b]); ------------------ | | 169| 84.4k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 84.4k|#define IM(A) (A)[1] | | ------------------ ------------------ 808| 84.4k| } 809| 1.32k| } 810| 44| } 811| 63|} drm_dec.c:drm_add_pan: 814| 26|{ 815| 26| uint8_t s, b, qclass, ifreq; 816| 26| real_t tmp, coeff1, coeff2; 817| 26| real_t pan_base[MAX_PAN_BAND]; 818| 26| real_t pan_delta[MAX_PAN_BAND]; 819| 26| qmf_t temp_l, temp_r; ------------------ | | 167| 26|#define qmf_t complex_t ------------------ 820| | 821| 26| if (ps->bs_enable_pan) ------------------ | Branch (821:9): [True: 26, False: 0] ------------------ 822| 26| { 823| 1.69k| for (b = 0; b < NUM_OF_QMF_CHANNELS; b++) ------------------ | | 44| 1.69k|#define NUM_OF_QMF_CHANNELS 64 ------------------ | Branch (823:21): [True: 1.66k, False: 26] ------------------ 824| 1.66k| { 825| | /* Instead of dequantization, 20->64 mapping and 2^G(x,y) we do an 826| | inverse mapping 64->20 and look up the 2^G(x,y) values directly */ 827| 1.66k| ifreq = pan_inv_freq[b]; 828| 1.66k| qclass = pan_quant_class[ifreq]; 829| | 830| 1.66k| if (ps->g_prev_pan_index[ifreq] >= 0) ------------------ | Branch (830:17): [True: 1.66k, False: 0] ------------------ 831| 1.66k| { 832| 1.66k| pan_base[b] = pan_pow_2_pos[ps->g_prev_pan_index[ifreq]][qclass]; 833| 1.66k| } else { 834| 0| pan_base[b] = pan_pow_2_neg[-ps->g_prev_pan_index[ifreq]][qclass]; 835| 0| } 836| | 837| | /* 2^((a-b)/30) = 2^(a/30) * 1/(2^(b/30)) */ 838| | /* a en b can be negative so we may need to inverse parts */ 839| 1.66k| if (ps->g_pan_index[ifreq] >= 0) ------------------ | Branch (839:17): [True: 1.66k, False: 0] ------------------ 840| 1.66k| { 841| 1.66k| if (ps->g_prev_pan_index[ifreq] >= 0) ------------------ | Branch (841:21): [True: 1.66k, False: 0] ------------------ 842| 1.66k| { 843| 1.66k| pan_delta[b] = MUL_C(pan_pow_2_30_pos[ps->g_pan_index[ifreq]][qclass], ------------------ | | 241| 1.66k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 1.66k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 1.66k|#define COEF_BITS 28 | | ------------------ ------------------ 844| 1.66k| pan_pow_2_30_neg[ps->g_prev_pan_index[ifreq]][qclass]); 845| 1.66k| } else { 846| 0| pan_delta[b] = MUL_C(pan_pow_2_30_pos[ps->g_pan_index[ifreq]][qclass], ------------------ | | 241| 0| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 0|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 0|#define COEF_BITS 28 | | ------------------ ------------------ 847| 0| pan_pow_2_30_pos[-ps->g_prev_pan_index[ifreq]][qclass]); 848| 0| } 849| 1.66k| } else { 850| 0| if (ps->g_prev_pan_index[ifreq] >= 0) ------------------ | Branch (850:21): [True: 0, False: 0] ------------------ 851| 0| { 852| 0| pan_delta[b] = MUL_C(pan_pow_2_30_neg[-ps->g_pan_index[ifreq]][qclass], ------------------ | | 241| 0| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 0|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 0|#define COEF_BITS 28 | | ------------------ ------------------ 853| 0| pan_pow_2_30_neg[ps->g_prev_pan_index[ifreq]][qclass]); 854| 0| } else { 855| 0| pan_delta[b] = MUL_C(pan_pow_2_30_neg[-ps->g_pan_index[ifreq]][qclass], ------------------ | | 241| 0| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 0|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 0|#define COEF_BITS 28 | | ------------------ ------------------ 856| 0| pan_pow_2_30_pos[-ps->g_prev_pan_index[ifreq]][qclass]); 857| 0| } 858| 0| } 859| 1.66k| } 860| | 861| 806| for (s = 0; s < NUM_OF_SUBSAMPLES; s++) ------------------ | | 45| 806|#define NUM_OF_SUBSAMPLES 30 ------------------ | Branch (861:21): [True: 780, False: 26] ------------------ 862| 780| { 863| | /* PAN always uses all 64 channels */ 864| 50.7k| for (b = 0; b < NUM_OF_QMF_CHANNELS; b++) ------------------ | | 44| 50.7k|#define NUM_OF_QMF_CHANNELS 64 ------------------ | Branch (864:25): [True: 49.9k, False: 780] ------------------ 865| 49.9k| { 866| 49.9k| tmp = pan_base[b]; 867| | 868| 49.9k| coeff2 = DIV_R(REAL_CONST(2.0), (REAL_CONST(1.0) + tmp)); ------------------ | | 157| 99.8k|#define DIV_R(A, B) (((int64_t)A * REAL_PRECISION)/B) | | ------------------ | | | | 46| 49.9k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (157:32): [True: 49.9k, Folded] | | | Branch (157:52): [True: 49.9k, Folded] | | ------------------ ------------------ 869| 49.9k| coeff1 = MUL_R(coeff2, tmp); ------------------ | | 239| 49.9k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 870| | 871| 49.9k| QMF_RE(temp_l) = QMF_RE(X_left[s][b]); ------------------ | | 168| 49.9k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 49.9k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(temp_l) = QMF_RE(X_left[s][b]); ------------------ | | 168| 49.9k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 49.9k|#define RE(A) (A)[0] | | ------------------ ------------------ 872| 49.9k| QMF_IM(temp_l) = QMF_IM(X_left[s][b]); ------------------ | | 169| 49.9k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 49.9k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(temp_l) = QMF_IM(X_left[s][b]); ------------------ | | 169| 49.9k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 49.9k|#define IM(A) (A)[1] | | ------------------ ------------------ 873| 49.9k| QMF_RE(temp_r) = QMF_RE(X_right[s][b]); ------------------ | | 168| 49.9k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 49.9k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(temp_r) = QMF_RE(X_right[s][b]); ------------------ | | 168| 49.9k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 49.9k|#define RE(A) (A)[0] | | ------------------ ------------------ 874| 49.9k| QMF_IM(temp_r) = QMF_IM(X_right[s][b]); ------------------ | | 169| 49.9k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 49.9k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(temp_r) = QMF_IM(X_right[s][b]); ------------------ | | 169| 49.9k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 49.9k|#define IM(A) (A)[1] | | ------------------ ------------------ 875| | 876| 49.9k| QMF_RE(X_left[s][b]) = MUL_R(QMF_RE(temp_l), coeff1); ------------------ | | 168| 49.9k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 49.9k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_left[s][b]) = MUL_R(QMF_RE(temp_l), coeff1); ------------------ | | 239| 49.9k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 877| 49.9k| QMF_IM(X_left[s][b]) = MUL_R(QMF_IM(temp_l), coeff1); ------------------ | | 169| 49.9k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 49.9k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_left[s][b]) = MUL_R(QMF_IM(temp_l), coeff1); ------------------ | | 239| 49.9k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 878| 49.9k| QMF_RE(X_right[s][b]) = MUL_R(QMF_RE(temp_r), coeff2); ------------------ | | 168| 49.9k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 49.9k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_right[s][b]) = MUL_R(QMF_RE(temp_r), coeff2); ------------------ | | 239| 49.9k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 879| 49.9k| QMF_IM(X_right[s][b]) = MUL_R(QMF_IM(temp_r), coeff2); ------------------ | | 169| 49.9k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 49.9k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_right[s][b]) = MUL_R(QMF_IM(temp_r), coeff2); ------------------ | | 239| 49.9k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 49.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 880| | 881| | /* 2^(a+k*b) = 2^a * 2^b * ... * 2^b */ 882| | /* ^^^^^^^^^^^^^^^ k times */ 883| 49.9k| pan_base[b] = MUL_C(pan_base[b], pan_delta[b]); ------------------ | | 241| 49.9k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 49.9k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 49.9k|#define COEF_BITS 28 | | ------------------ ------------------ 884| 49.9k| } 885| 780| } 886| 26| } 887| 26|} filter_bank_init: 49| 1.64k|{ 50| 1.64k| uint16_t nshort = frame_len/8; 51| |#ifdef LD_DEC 52| | uint16_t frame_len_ld = frame_len/2; 53| |#endif 54| | 55| 1.64k| fb_info *fb = (fb_info*)faad_malloc(sizeof(fb_info)); 56| 1.64k| memset(fb, 0, sizeof(fb_info)); 57| | 58| | /* normal */ 59| 1.64k| fb->mdct256 = faad_mdct_init(2*nshort); 60| 1.64k| fb->mdct2048 = faad_mdct_init(2*frame_len); 61| |#ifdef LD_DEC 62| | /* LD */ 63| | fb->mdct1024 = faad_mdct_init(2*frame_len_ld); 64| |#endif 65| | 66| 1.64k|#ifdef ALLOW_SMALL_FRAMELENGTH 67| 1.64k| if (frame_len == 1024) ------------------ | Branch (67:9): [True: 1.10k, False: 542] ------------------ 68| 1.10k| { 69| 1.10k|#endif 70| 1.10k| fb->long_window[0] = sine_long_1024; 71| 1.10k| fb->short_window[0] = sine_short_128; 72| 1.10k| fb->long_window[1] = kbd_long_1024; 73| 1.10k| fb->short_window[1] = kbd_short_128; 74| |#ifdef LD_DEC 75| | fb->ld_window[0] = sine_mid_512; 76| | fb->ld_window[1] = ld_mid_512; 77| |#endif 78| 1.10k|#ifdef ALLOW_SMALL_FRAMELENGTH 79| 1.10k| } else /* (frame_len == 960) */ { 80| 542| fb->long_window[0] = sine_long_960; 81| 542| fb->short_window[0] = sine_short_120; 82| 542| fb->long_window[1] = kbd_long_960; 83| 542| fb->short_window[1] = kbd_short_120; 84| |#ifdef LD_DEC 85| | fb->ld_window[0] = sine_mid_480; 86| | fb->ld_window[1] = ld_mid_480; 87| |#endif 88| 542| } 89| 1.64k|#endif 90| | 91| 1.64k| return fb; 92| 1.64k|} filter_bank_end: 95| 1.68k|{ 96| 1.68k| if (fb != NULL) ------------------ | Branch (96:9): [True: 1.64k, False: 33] ------------------ 97| 1.64k| { 98| |#ifdef PROFILE 99| | printf("FB: %I64d cycles\n", fb->cycles); 100| |#endif 101| | 102| 1.64k| faad_mdct_end(fb->mdct256); 103| 1.64k| faad_mdct_end(fb->mdct2048); 104| |#ifdef LD_DEC 105| | faad_mdct_end(fb->mdct1024); 106| |#endif 107| | 108| 1.64k| faad_free(fb); 109| 1.64k| } 110| 1.68k|} ifilter_bank: 168| 45.3k|{ 169| 45.3k| int16_t i; 170| 45.3k| ALIGN real_t transf_buf[2*1024] = {0}; 171| | 172| 45.3k| const real_t *window_long = NULL; 173| 45.3k| const real_t *window_long_prev = NULL; 174| 45.3k| const real_t *window_short = NULL; 175| 45.3k| const real_t *window_short_prev = NULL; 176| | 177| 45.3k| uint16_t nlong = frame_len; 178| 45.3k| uint16_t nshort = frame_len/8; 179| 45.3k| uint16_t trans = nshort/2; 180| | 181| 45.3k| uint16_t nflat_ls = (nlong-nshort)/2; 182| | 183| |#ifdef PROFILE 184| | int64_t count = faad_get_ts(); 185| |#endif 186| | 187| | /* select windows of current frame and previous frame (Sine or KBD) */ 188| |#ifdef LD_DEC 189| | if (object_type == LD) 190| | { 191| | window_long = fb->ld_window[window_shape]; 192| | window_long_prev = fb->ld_window[window_shape_prev]; 193| | } else { 194| |#else 195| 45.3k| (void)object_type; 196| 45.3k|#endif 197| 45.3k| window_long = fb->long_window[window_shape]; 198| 45.3k| window_long_prev = fb->long_window[window_shape_prev]; 199| 45.3k| window_short = fb->short_window[window_shape]; 200| 45.3k| window_short_prev = fb->short_window[window_shape_prev]; 201| |#ifdef LD_DEC 202| | } 203| |#endif 204| | 205| |#if 0 206| | for (i = 0; i < 1024; i++) 207| | { 208| | printf("%d\n", freq_in[i]); 209| | } 210| |#endif 211| | 212| |#if 0 213| | printf("%d %d\n", window_sequence, window_shape); 214| |#endif 215| | 216| 45.3k| switch (window_sequence) ------------------ | Branch (216:13): [True: 45.3k, False: 0] ------------------ 217| 45.3k| { 218| 28.7k| case ONLY_LONG_SEQUENCE: ------------------ | | 96| 28.7k|#define ONLY_LONG_SEQUENCE 0x0 ------------------ | Branch (218:5): [True: 28.7k, False: 16.5k] ------------------ 219| | /* perform iMDCT */ 220| 28.7k| imdct_long(fb, freq_in, transf_buf, 2*nlong); 221| | 222| | /* add second half output of previous frame to windowed output of current frame */ 223| 7.26M| for (i = 0; i < nlong; i+=4) ------------------ | Branch (223:21): [True: 7.23M, False: 28.7k] ------------------ 224| 7.23M| { 225| 7.23M| time_out[i] = overlap[i] + MUL_F(transf_buf[i],window_long_prev[i]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 226| 7.23M| time_out[i+1] = overlap[i+1] + MUL_F(transf_buf[i+1],window_long_prev[i+1]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 227| 7.23M| time_out[i+2] = overlap[i+2] + MUL_F(transf_buf[i+2],window_long_prev[i+2]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 228| 7.23M| time_out[i+3] = overlap[i+3] + MUL_F(transf_buf[i+3],window_long_prev[i+3]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 229| 7.23M| } 230| | 231| | /* window the second half and save as overlap for next frame */ 232| 7.26M| for (i = 0; i < nlong; i+=4) ------------------ | Branch (232:21): [True: 7.23M, False: 28.7k] ------------------ 233| 7.23M| { 234| 7.23M| overlap[i] = MUL_F(transf_buf[nlong+i],window_long[nlong-1-i]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 235| 7.23M| overlap[i+1] = MUL_F(transf_buf[nlong+i+1],window_long[nlong-2-i]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 236| 7.23M| overlap[i+2] = MUL_F(transf_buf[nlong+i+2],window_long[nlong-3-i]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 237| 7.23M| overlap[i+3] = MUL_F(transf_buf[nlong+i+3],window_long[nlong-4-i]); ------------------ | | 268| 7.23M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.23M|#define FRAC_BITS 31 | | ------------------ ------------------ 238| 7.23M| } 239| 28.7k| break; 240| | 241| 3.94k| case LONG_START_SEQUENCE: ------------------ | | 97| 3.94k|#define LONG_START_SEQUENCE 0x1 ------------------ | Branch (241:5): [True: 3.94k, False: 41.3k] ------------------ 242| | /* perform iMDCT */ 243| 3.94k| imdct_long(fb, freq_in, transf_buf, 2*nlong); 244| | 245| | /* add second half output of previous frame to windowed output of current frame */ 246| 969k| for (i = 0; i < nlong; i+=4) ------------------ | Branch (246:21): [True: 965k, False: 3.94k] ------------------ 247| 965k| { 248| 965k| time_out[i] = overlap[i] + MUL_F(transf_buf[i],window_long_prev[i]); ------------------ | | 268| 965k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ ------------------ 249| 965k| time_out[i+1] = overlap[i+1] + MUL_F(transf_buf[i+1],window_long_prev[i+1]); ------------------ | | 268| 965k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ ------------------ 250| 965k| time_out[i+2] = overlap[i+2] + MUL_F(transf_buf[i+2],window_long_prev[i+2]); ------------------ | | 268| 965k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ ------------------ 251| 965k| time_out[i+3] = overlap[i+3] + MUL_F(transf_buf[i+3],window_long_prev[i+3]); ------------------ | | 268| 965k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 965k|#define FRAC_BITS 31 | | ------------------ ------------------ 252| 965k| } 253| | 254| | /* window the second half and save as overlap for next frame */ 255| | /* construct second half window using padding with 1's and 0's */ 256| 1.69M| for (i = 0; i < nflat_ls; i++) ------------------ | Branch (256:21): [True: 1.68M, False: 3.94k] ------------------ 257| 1.68M| overlap[i] = transf_buf[nlong+i]; 258| 486k| for (i = 0; i < nshort; i++) ------------------ | Branch (258:21): [True: 482k, False: 3.94k] ------------------ 259| 482k| overlap[nflat_ls+i] = MUL_F(transf_buf[nlong+nflat_ls+i],window_short[nshort-i-1]); ------------------ | | 268| 486k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 482k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 482k|#define FRAC_BITS 31 | | ------------------ ------------------ 260| 1.69M| for (i = 0; i < nflat_ls; i++) ------------------ | Branch (260:21): [True: 1.68M, False: 3.94k] ------------------ 261| 1.68M| overlap[nflat_ls+nshort+i] = 0; 262| 3.94k| break; 263| | 264| 12.2k| case EIGHT_SHORT_SEQUENCE: ------------------ | | 98| 12.2k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (264:5): [True: 12.2k, False: 33.1k] ------------------ 265| | /* perform iMDCT for each short block */ 266| 12.2k| faad_imdct(fb->mdct256, freq_in+0*nshort, transf_buf+2*nshort*0); 267| 12.2k| faad_imdct(fb->mdct256, freq_in+1*nshort, transf_buf+2*nshort*1); 268| 12.2k| faad_imdct(fb->mdct256, freq_in+2*nshort, transf_buf+2*nshort*2); 269| 12.2k| faad_imdct(fb->mdct256, freq_in+3*nshort, transf_buf+2*nshort*3); 270| 12.2k| faad_imdct(fb->mdct256, freq_in+4*nshort, transf_buf+2*nshort*4); 271| 12.2k| faad_imdct(fb->mdct256, freq_in+5*nshort, transf_buf+2*nshort*5); 272| 12.2k| faad_imdct(fb->mdct256, freq_in+6*nshort, transf_buf+2*nshort*6); 273| 12.2k| faad_imdct(fb->mdct256, freq_in+7*nshort, transf_buf+2*nshort*7); 274| | 275| | /* add second half output of previous frame to windowed output of current frame */ 276| 5.42M| for (i = 0; i < nflat_ls; i++) ------------------ | Branch (276:21): [True: 5.41M, False: 12.2k] ------------------ 277| 5.41M| time_out[i] = overlap[i]; 278| 1.55M| for(i = 0; i < nshort; i++) ------------------ | Branch (278:20): [True: 1.54M, False: 12.2k] ------------------ 279| 1.54M| { 280| 1.54M| time_out[nflat_ls+ i] = overlap[nflat_ls+ i] + MUL_F(transf_buf[nshort*0+i],window_short_prev[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 281| 1.54M| time_out[nflat_ls+1*nshort+i] = overlap[nflat_ls+nshort*1+i] + MUL_F(transf_buf[nshort*1+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*2+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ time_out[nflat_ls+1*nshort+i] = overlap[nflat_ls+nshort*1+i] + MUL_F(transf_buf[nshort*1+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*2+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 282| 1.54M| time_out[nflat_ls+2*nshort+i] = overlap[nflat_ls+nshort*2+i] + MUL_F(transf_buf[nshort*3+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*4+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ time_out[nflat_ls+2*nshort+i] = overlap[nflat_ls+nshort*2+i] + MUL_F(transf_buf[nshort*3+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*4+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 283| 1.54M| time_out[nflat_ls+3*nshort+i] = overlap[nflat_ls+nshort*3+i] + MUL_F(transf_buf[nshort*5+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*6+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ time_out[nflat_ls+3*nshort+i] = overlap[nflat_ls+nshort*3+i] + MUL_F(transf_buf[nshort*5+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*6+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 284| 1.54M| if (i < trans) ------------------ | Branch (284:17): [True: 773k, False: 773k] ------------------ 285| 773k| time_out[nflat_ls+4*nshort+i] = overlap[nflat_ls+nshort*4+i] + MUL_F(transf_buf[nshort*7+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*8+i],window_short[i]); ------------------ | | 268| 773k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ ------------------ time_out[nflat_ls+4*nshort+i] = overlap[nflat_ls+nshort*4+i] + MUL_F(transf_buf[nshort*7+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*8+i],window_short[i]); ------------------ | | 268| 773k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ ------------------ 286| 1.54M| } 287| | 288| | /* window the second half and save as overlap for next frame */ 289| 1.55M| for(i = 0; i < nshort; i++) ------------------ | Branch (289:20): [True: 1.54M, False: 12.2k] ------------------ 290| 1.54M| { 291| 1.54M| if (i >= trans) ------------------ | Branch (291:17): [True: 773k, False: 773k] ------------------ 292| 773k| overlap[nflat_ls+4*nshort+i-nlong] = MUL_F(transf_buf[nshort*7+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*8+i],window_short[i]); ------------------ | | 268| 773k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ ------------------ overlap[nflat_ls+4*nshort+i-nlong] = MUL_F(transf_buf[nshort*7+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*8+i],window_short[i]); ------------------ | | 268| 773k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 773k|#define FRAC_BITS 31 | | ------------------ ------------------ 293| 1.54M| overlap[nflat_ls+5*nshort+i-nlong] = MUL_F(transf_buf[nshort*9+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*10+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ overlap[nflat_ls+5*nshort+i-nlong] = MUL_F(transf_buf[nshort*9+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*10+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 294| 1.54M| overlap[nflat_ls+6*nshort+i-nlong] = MUL_F(transf_buf[nshort*11+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*12+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ overlap[nflat_ls+6*nshort+i-nlong] = MUL_F(transf_buf[nshort*11+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*12+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 295| 1.54M| overlap[nflat_ls+7*nshort+i-nlong] = MUL_F(transf_buf[nshort*13+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*14+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ overlap[nflat_ls+7*nshort+i-nlong] = MUL_F(transf_buf[nshort*13+i],window_short[nshort-1-i]) + MUL_F(transf_buf[nshort*14+i],window_short[i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 296| 1.54M| overlap[nflat_ls+8*nshort+i-nlong] = MUL_F(transf_buf[nshort*15+i],window_short[nshort-1-i]); ------------------ | | 268| 1.54M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.54M|#define FRAC_BITS 31 | | ------------------ ------------------ 297| 1.54M| } 298| 5.42M| for (i = 0; i < nflat_ls; i++) ------------------ | Branch (298:21): [True: 5.41M, False: 12.2k] ------------------ 299| 5.41M| overlap[nflat_ls+nshort+i] = 0; 300| 12.2k| break; 301| | 302| 430| case LONG_STOP_SEQUENCE: ------------------ | | 99| 430|#define LONG_STOP_SEQUENCE 0x3 ------------------ | Branch (302:5): [True: 430, False: 44.8k] ------------------ 303| | /* perform iMDCT */ 304| 430| imdct_long(fb, freq_in, transf_buf, 2*nlong); 305| | 306| | /* add second half output of previous frame to windowed output of current frame */ 307| | /* construct first half window using padding with 1's and 0's */ 308| 189k| for (i = 0; i < nflat_ls; i++) ------------------ | Branch (308:21): [True: 189k, False: 430] ------------------ 309| 189k| time_out[i] = overlap[i]; 310| 54.5k| for (i = 0; i < nshort; i++) ------------------ | Branch (310:21): [True: 54.1k, False: 430] ------------------ 311| 54.1k| time_out[nflat_ls+i] = overlap[nflat_ls+i] + MUL_F(transf_buf[nflat_ls+i],window_short_prev[i]); ------------------ | | 268| 54.5k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 54.1k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 54.1k|#define FRAC_BITS 31 | | ------------------ ------------------ 312| 189k| for (i = 0; i < nflat_ls; i++) ------------------ | Branch (312:21): [True: 189k, False: 430] ------------------ 313| 189k| time_out[nflat_ls+nshort+i] = overlap[nflat_ls+nshort+i] + transf_buf[nflat_ls+nshort+i]; 314| | 315| | /* window the second half and save as overlap for next frame */ 316| 433k| for (i = 0; i < nlong; i++) ------------------ | Branch (316:21): [True: 433k, False: 430] ------------------ 317| 433k| overlap[i] = MUL_F(transf_buf[nlong+i],window_long[nlong-1-i]); ------------------ | | 268| 433k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 433k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 433k|#define FRAC_BITS 31 | | ------------------ ------------------ 318| 430| break; 319| 45.3k| } 320| | 321| |#if 0 322| | for (i = 0; i < 1024; i++) 323| | { 324| | printf("%d\n", time_out[i]); 325| | //printf("0x%.8X\n", time_out[i]); 326| | } 327| |#endif 328| | 329| | 330| |#ifdef PROFILE 331| | count = faad_get_ts() - count; 332| | fb->cycles += count; 333| |#endif 334| 45.3k|} filtbank.c:imdct_long: 113| 33.1k|{ 114| |#ifdef LD_DEC 115| | mdct_info *mdct = NULL; 116| | 117| | switch (len) 118| | { 119| | case 2048: 120| | case 1920: 121| | mdct = fb->mdct2048; 122| | break; 123| | case 1024: 124| | case 960: 125| | mdct = fb->mdct1024; 126| | break; 127| | } 128| | 129| | faad_imdct(mdct, in_data, out_data); 130| |#else 131| 33.1k| (void)len; 132| 33.1k| faad_imdct(fb->mdct2048, in_data, out_data); 133| 33.1k|#endif 134| 33.1k|} mdct.c:ComplexMult: 278| 45.6M|{ 279| 45.6M| *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 45.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 45.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 52| 45.6M|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 45.6M|#define FRAC_BITS 31 | | ------------------ ------------------ 280| 45.6M| *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 45.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 45.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 52| 45.6M|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 45.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 45.6M|#define FRAC_BITS 31 | | ------------------ ------------------ 281| 45.6M|} cfft.c:ComplexMult: 278| 56.8M|{ 279| 56.8M| *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 56.8M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 56.8M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 52| 56.8M|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 56.8M|#define FRAC_BITS 31 | | ------------------ ------------------ 280| 56.8M| *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 56.8M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 56.8M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 52| 56.8M|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 56.8M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 56.8M|#define FRAC_BITS 31 | | ------------------ ------------------ 281| 56.8M|} ps_dec.c:ComplexMult: 278| 17.6M|{ 279| 17.6M| *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 17.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 17.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 52| 17.6M|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 17.6M|#define FRAC_BITS 31 | | ------------------ ------------------ 280| 17.6M| *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 17.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 17.6M| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 52| 17.6M|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 17.6M|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 17.6M|#define FRAC_BITS 31 | | ------------------ ------------------ 281| 17.6M|} drm_dec.c:ComplexMult: 278| 173k|{ 279| 173k| *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 173k| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 267| 173k| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2)) * FRAC_MUL; ------------------ | | 52| 173k|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ ------------------ 280| 173k| *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 173k| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 267| 173k| #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_SIZE-1))) >> FRAC_SIZE) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ ------------------ *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2)) * FRAC_MUL; ------------------ | | 52| 173k|#define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 49| 173k|#define FRAC_SIZE 32 /* frac is a 32 bit integer */ | | ------------------ | | #define FRAC_MUL (1u << (FRAC_SIZE - FRAC_BITS)) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ ------------------ 281| 173k|} reordered_spectral_data: 212| 476|{ 213| 476| uint16_t PCWs_done; 214| 476| uint16_t numberOfSegments, numberOfSets, numberOfCodewords; 215| | 216| 476| codeword_t codeword[512]; 217| 476| bits_t segment[512]; 218| | 219| 476| uint16_t sp_offset[8]; 220| 476| uint16_t g, i, sortloop, set, bitsread; 221| 476| /*uint16_t bitsleft, codewordsleft*/; 222| 476| uint8_t w_idx, sfb, this_CB, last_CB, this_sec_CB; 223| | 224| 476| const uint16_t nshort = hDecoder->frameLength/8; 225| 476| const uint16_t sp_data_len = ics->length_of_reordered_spectral_data; 226| | 227| 476| const uint8_t *PreSortCb; 228| | 229| | /* no data (e.g. silence) */ 230| 476| if (sp_data_len == 0) ------------------ | Branch (230:9): [True: 262, False: 214] ------------------ 231| 262| return 0; 232| | 233| | /* since there is spectral data, at least one codeword has nonzero length */ 234| 214| if (ics->length_of_longest_codeword == 0) ------------------ | Branch (234:9): [True: 0, False: 214] ------------------ 235| 0| return 10; 236| | 237| 214| if (sp_data_len < ics->length_of_longest_codeword) ------------------ | Branch (237:9): [True: 1, False: 213] ------------------ 238| 1| return 10; 239| | 240| 213| sp_offset[0] = 0; 241| 455| for (g = 1; g < ics->num_window_groups; g++) ------------------ | Branch (241:17): [True: 242, False: 213] ------------------ 242| 242| { 243| 242| sp_offset[g] = sp_offset[g-1] + nshort*ics->window_group_length[g-1]; 244| 242| } 245| | 246| 213| PCWs_done = 0; 247| 213| numberOfSegments = 0; 248| 213| numberOfCodewords = 0; 249| 213| bitsread = 0; 250| | 251| | /* VCB11 code books in use */ 252| 213| if (hDecoder->aacSectionDataResilienceFlag) ------------------ | Branch (252:9): [True: 189, False: 24] ------------------ 253| 189| { 254| 189| PreSortCb = PreSortCB_ER; 255| 189| last_CB = NUM_CB_ER; ------------------ | | 57| 189|#define NUM_CB_ER 22 ------------------ 256| 189| } else 257| 24| { 258| 24| PreSortCb = PreSortCB_STD; 259| 24| last_CB = NUM_CB; ------------------ | | 56| 24|#define NUM_CB 6 ------------------ 260| 24| } 261| | 262| | /* step 1: decode PCW's (set 0), and stuff data in easier-to-use format */ 263| 4.51k| for (sortloop = 0; sortloop < last_CB; sortloop++) ------------------ | Branch (263:24): [True: 4.30k, False: 213] ------------------ 264| 4.30k| { 265| | /* select codebook to process this pass */ 266| 4.30k| this_CB = PreSortCb[sortloop]; 267| | 268| | /* loop over sfbs */ 269| 87.0k| for (sfb = 0; sfb < ics->max_sfb; sfb++) ------------------ | Branch (269:23): [True: 82.7k, False: 4.30k] ------------------ 270| 82.7k| { 271| | /* loop over all in this sfb, 4 lines per loop */ 272| 411k| for (w_idx = 0; 4*w_idx < (min(ics->swb_offset[sfb+1], ics->swb_offset_max) - ics->swb_offset[sfb]); w_idx++) ------------------ | | 60| 411k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 409k, False: 1.51k] | | ------------------ ------------------ | Branch (272:29): [True: 328k, False: 82.7k] ------------------ 273| 328k| { 274| 694k| for(g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (274:28): [True: 365k, False: 328k] ------------------ 275| 365k| { 276| 4.58M| for (i = 0; i < ics->num_sec[g]; i++) ------------------ | Branch (276:33): [True: 4.22M, False: 365k] ------------------ 277| 4.22M| { 278| | /* check whether sfb used here is the one we want to process */ 279| 4.22M| if ((ics->sect_start[g][i] <= sfb) && (ics->sect_end[g][i] > sfb)) ------------------ | Branch (279:29): [True: 2.54M, False: 1.68M] | Branch (279:63): [True: 365k, False: 2.17M] ------------------ 280| 365k| { 281| | /* check whether codebook used here is the one we want to process */ 282| 365k| this_sec_CB = ics->sect_cb[g][i]; 283| | 284| 365k| if (is_good_cb(this_CB, this_sec_CB)) ------------------ | Branch (284:33): [True: 20.3k, False: 345k] ------------------ 285| 20.3k| { 286| | /* precalculate some stuff */ 287| 20.3k| uint16_t sect_sfb_size = ics->sect_sfb_offset[g][sfb+1] - ics->sect_sfb_offset[g][sfb]; 288| 20.3k| uint8_t inc = (this_sec_CB < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN; ------------------ | | 102| 20.3k|#define FIRST_PAIR_HCB 5 ------------------ uint8_t inc = (this_sec_CB < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN; ------------------ | | 104| 10.9k|#define QUAD_LEN 4 ------------------ uint8_t inc = (this_sec_CB < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN; ------------------ | | 105| 29.7k|#define PAIR_LEN 2 ------------------ | Branch (288:47): [True: 10.9k, False: 9.41k] ------------------ 289| 20.3k| uint16_t group_cws_count = (4*ics->window_group_length[g])/inc; 290| 20.3k| uint8_t segwidth = segmentWidth(this_sec_CB); ------------------ | | 73| 20.3k|#define segmentWidth(cb) min(maxCwLen[cb], ics->length_of_longest_codeword) | | ------------------ | | | | 60| 20.3k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | | | ------------------ | | | | | Branch (60:20): [True: 9.81k, False: 10.5k] | | | | ------------------ | | ------------------ ------------------ 291| 20.3k| uint16_t cws; 292| | 293| | /* read codewords until end of sfb or end of window group (shouldn't only 1 trigger?) */ 294| 56.4k| for (cws = 0; (cws < group_cws_count) && ((cws + w_idx*group_cws_count) < sect_sfb_size); cws++) ------------------ | Branch (294:47): [True: 36.1k, False: 20.3k] | Branch (294:74): [True: 36.1k, False: 0] ------------------ 295| 36.1k| { 296| 36.1k| uint16_t sp = sp_offset[g] + ics->sect_sfb_offset[g][sfb] + inc * (cws + w_idx*group_cws_count); 297| | 298| | /* read and decode PCW */ 299| 36.1k| if (!PCWs_done) ------------------ | Branch (299:41): [True: 19.2k, False: 16.8k] ------------------ 300| 19.2k| { 301| | /* read in normal segments */ 302| 19.2k| if (bitsread + segwidth <= sp_data_len) ------------------ | Branch (302:45): [True: 19.1k, False: 120] ------------------ 303| 19.1k| { 304| 19.1k| read_segment(&segment[numberOfSegments], segwidth, ld); 305| 19.1k| bitsread += segwidth; 306| | 307| 19.1k| huffman_spectral_data_2(this_sec_CB, &segment[numberOfSegments], &spectral_data[sp]); 308| | 309| | /* keep leftover bits */ 310| 19.1k| rewrev_bits(&segment[numberOfSegments]); 311| | 312| 19.1k| numberOfSegments++; 313| 19.1k| } else { // sp_data_len - bitsread < segwidth 314| | /* remaining stuff after last segment, we unfortunately couldn't read 315| | this in earlier because it might not fit in 64 bits. since we already 316| | decoded (and removed) the PCW it is now should fit */ 317| 120| if (bitsread < sp_data_len) ------------------ | Branch (317:49): [True: 96, False: 24] ------------------ 318| 96| { 319| 96| const uint8_t additional_bits = (uint8_t)(sp_data_len - bitsread); 320| | 321| 96| read_segment(&segment[numberOfSegments], additional_bits, ld); 322| 96| segment[numberOfSegments].len += segment[numberOfSegments-1].len; 323| 96| if (segment[numberOfSegments].len > 64) ------------------ | Branch (323:53): [True: 0, False: 96] ------------------ 324| 0| return 10; 325| 96| rewrev_bits(&segment[numberOfSegments]); 326| | 327| 96| if (segment[numberOfSegments-1].len > 32) ------------------ | Branch (327:53): [True: 15, False: 81] ------------------ 328| 15| { 329| 15| segment[numberOfSegments-1].bufb = segment[numberOfSegments].bufb + 330| 15| showbits_hcr(&segment[numberOfSegments-1], segment[numberOfSegments-1].len - 32); 331| 15| segment[numberOfSegments-1].bufa = segment[numberOfSegments].bufa + 332| 15| showbits_hcr(&segment[numberOfSegments-1], 32); 333| 81| } else { 334| 81| segment[numberOfSegments-1].bufa = segment[numberOfSegments].bufa + 335| 81| showbits_hcr(&segment[numberOfSegments-1], segment[numberOfSegments-1].len); 336| 81| segment[numberOfSegments-1].bufb = segment[numberOfSegments].bufb; 337| 81| } 338| 96| segment[numberOfSegments-1].len += additional_bits; 339| 96| } 340| 120| bitsread = sp_data_len; 341| 120| PCWs_done = 1; 342| | 343| 120| fill_in_codeword(codeword, 0, sp, this_sec_CB); 344| 120| } 345| 19.2k| } else { 346| 16.8k| fill_in_codeword(codeword, numberOfCodewords - numberOfSegments, sp, this_sec_CB); 347| 16.8k| } 348| 36.1k| numberOfCodewords++; 349| 36.1k| } 350| 20.3k| } 351| 365k| } 352| 4.22M| } 353| 365k| } 354| 328k| } 355| 82.7k| } 356| 4.30k| } 357| | 358| 213| if (numberOfSegments == 0) ------------------ | Branch (358:9): [True: 3, False: 210] ------------------ 359| 3| return 10; 360| | 361| 210| numberOfSets = numberOfCodewords / numberOfSegments; 362| | 363| | /* step 2: decode nonPCWs */ 364| 1.35k| for (set = 1; set <= numberOfSets; set++) ------------------ | Branch (364:19): [True: 1.14k, False: 210] ------------------ 365| 1.14k| { 366| 1.14k| uint16_t trial; 367| | 368| 33.2k| for (trial = 0; trial < numberOfSegments; trial++) ------------------ | Branch (368:25): [True: 32.1k, False: 1.14k] ------------------ 369| 32.1k| { 370| 32.1k| uint16_t codewordBase; 371| | 372| 1.48M| for (codewordBase = 0; codewordBase < numberOfSegments; codewordBase++) ------------------ | Branch (372:36): [True: 1.47M, False: 13.0k] ------------------ 373| 1.47M| { 374| 1.47M| const uint16_t segment_idx = (trial + codewordBase) % numberOfSegments; 375| 1.47M| const uint16_t codeword_idx = codewordBase + set*numberOfSegments - numberOfSegments; 376| | 377| | /* data up */ 378| 1.47M| if (codeword_idx >= numberOfCodewords - numberOfSegments) break; ------------------ | Branch (378:21): [True: 19.1k, False: 1.45M] ------------------ 379| | 380| 1.45M| if (!codeword[codeword_idx].decoded && segment[segment_idx].len > 0) ------------------ | Branch (380:21): [True: 309k, False: 1.14M] | Branch (380:56): [True: 15.7k, False: 293k] ------------------ 381| 15.7k| { 382| 15.7k| uint8_t tmplen = segment[segment_idx].len + codeword[codeword_idx].bits.len; 383| | 384| 15.7k| if (tmplen > 64) ------------------ | Branch (384:25): [True: 528, False: 15.1k] ------------------ 385| 528| { 386| | // Drop bits that do not fit concatenation result. 387| 528| flushbits_hcr(&codeword[codeword_idx].bits, tmplen - 64); 388| 528| } 389| | 390| 15.7k| if (codeword[codeword_idx].bits.len != 0) ------------------ | Branch (390:25): [True: 3.75k, False: 11.9k] ------------------ 391| 3.75k| concat_bits(&segment[segment_idx], &codeword[codeword_idx].bits); 392| | 393| 15.7k| tmplen = segment[segment_idx].len; 394| | 395| 15.7k| if (huffman_spectral_data_2(codeword[codeword_idx].cb, &segment[segment_idx], ------------------ | Branch (395:25): [True: 11.8k, False: 3.87k] ------------------ 396| 15.7k| &spectral_data[codeword[codeword_idx].sp_offset]) >= 0) 397| 11.8k| { 398| 11.8k| codeword[codeword_idx].decoded = 1; 399| 11.8k| } else 400| 3.87k| { 401| 3.87k| codeword[codeword_idx].bits = segment[segment_idx]; 402| 3.87k| codeword[codeword_idx].bits.len = tmplen; 403| 3.87k| } 404| | 405| 15.7k| } 406| 1.45M| } 407| 32.1k| } 408| 33.2k| for (i = 0; i < numberOfSegments; i++) ------------------ | Branch (408:21): [True: 32.1k, False: 1.14k] ------------------ 409| 32.1k| rewrev_bits(&segment[i]); 410| 1.14k| } 411| | 412| |#if 0 // Seems to give false errors 413| | bitsleft = 0; 414| | 415| | for (i = 0; i < numberOfSegments && !bitsleft; i++) 416| | bitsleft += segment[i].len; 417| | 418| | if (bitsleft) return 10; 419| | 420| | codewordsleft = 0; 421| | 422| | for (i = 0; (i < numberOfCodewords - numberOfSegments) && (!codewordsleft); i++) 423| | if (!codeword[i].decoded) 424| | codewordsleft++; 425| | 426| | if (codewordsleft) return 10; 427| |#endif 428| | 429| | 430| 210| return 0; 431| | 432| 213|} hcr.c:is_good_cb: 170| 365k|{ 171| | /* only want spectral data CB's */ 172| 365k| if ((this_sec_CB > ZERO_HCB && this_sec_CB <= ESC_HCB) || (this_sec_CB >= VCB11_FIRST && this_sec_CB <= VCB11_LAST)) ------------------ | | 101| 731k|#define ZERO_HCB 0 ------------------ if ((this_sec_CB > ZERO_HCB && this_sec_CB <= ESC_HCB) || (this_sec_CB >= VCB11_FIRST && this_sec_CB <= VCB11_LAST)) ------------------ | | 103| 362k|#define ESC_HCB 11 ------------------ if ((this_sec_CB > ZERO_HCB && this_sec_CB <= ESC_HCB) || (this_sec_CB >= VCB11_FIRST && this_sec_CB <= VCB11_LAST)) ------------------ | | 59| 187k|#define VCB11_FIRST 16 ------------------ if ((this_sec_CB > ZERO_HCB && this_sec_CB <= ESC_HCB) || (this_sec_CB >= VCB11_FIRST && this_sec_CB <= VCB11_LAST)) ------------------ | | 60| 87.6k|#define VCB11_LAST 31 ------------------ | Branch (172:10): [True: 362k, False: 3.82k] | Branch (172:36): [True: 272k, False: 90.0k] | Branch (172:64): [True: 87.6k, False: 6.24k] | Branch (172:94): [True: 87.6k, False: 0] ------------------ 173| 359k| { 174| 359k| if (this_CB < ESC_HCB) ------------------ | | 103| 359k|#define ESC_HCB 11 ------------------ | Branch (174:13): [True: 101k, False: 258k] ------------------ 175| 101k| { 176| | /* normal codebook pairs */ 177| 101k| return ((this_sec_CB == this_CB) || (this_sec_CB == this_CB + 1)); ------------------ | Branch (177:21): [True: 1.14k, False: 100k] | Branch (177:49): [True: 11.2k, False: 89.2k] ------------------ 178| 101k| } else 179| 258k| { 180| | /* escape codebook */ 181| 258k| return (this_sec_CB == this_CB); 182| 258k| } 183| 359k| } 184| 6.24k| return 0; 185| 365k|} hcr.c:read_segment: 188| 19.2k|{ 189| 19.2k| segment->len = segwidth; 190| | 191| 19.2k| if (segwidth > 32) ------------------ | Branch (191:10): [True: 4.82k, False: 14.4k] ------------------ 192| 4.82k| { 193| 4.82k| segment->bufb = faad_getbits(ld, segwidth - 32); 194| 4.82k| segment->bufa = faad_getbits(ld, 32); 195| | 196| 14.4k| } else { 197| 14.4k| segment->bufb = 0; 198| 14.4k| segment->bufa = faad_getbits(ld, segwidth); 199| 14.4k| } 200| 19.2k|} hcr.c:rewrev_bits: 99| 51.3k|{ 100| 51.3k| if (bits->len == 0) return; ------------------ | Branch (100:9): [True: 23.9k, False: 27.3k] ------------------ 101| 27.3k| if (bits->len <= 32) { ------------------ | Branch (101:9): [True: 22.4k, False: 4.93k] ------------------ 102| 22.4k| bits->bufb = 0; 103| 22.4k| bits->bufa = reverse_word(bits->bufa) >> (32 - bits->len); 104| 22.4k| } else { 105| | /* last 32<>32 bit swap via rename */ 106| 4.93k| uint32_t lo = reverse_word(bits->bufb); 107| 4.93k| uint32_t hi = reverse_word(bits->bufa); 108| | 109| 4.93k| if (bits->len == 64) { ------------------ | Branch (109:13): [True: 3, False: 4.93k] ------------------ 110| 3| bits->bufb = hi; 111| 3| bits->bufa = lo; 112| 4.93k| } else { 113| | /* shift off low bits (this is really only one 64 bit shift) */ 114| 4.93k| bits->bufb = hi >> (64 - bits->len); 115| 4.93k| bits->bufa = (lo >> (64 - bits->len)) | (hi << (bits->len - 32)); 116| 4.93k| } 117| 4.93k| } 118| 27.3k|} hcr.c:reverse_word: 88| 32.3k|{ 89| 32.3k| v = ((v >> S[0]) & B[0]) | ((v << S[0]) & ~B[0]); 90| 32.3k| v = ((v >> S[1]) & B[1]) | ((v << S[1]) & ~B[1]); 91| 32.3k| v = ((v >> S[2]) & B[2]) | ((v << S[2]) & ~B[2]); 92| 32.3k| v = ((v >> S[3]) & B[3]) | ((v << S[3]) & ~B[3]); 93| 32.3k| v = ((v >> S[4]) & B[4]) | ((v << S[4]) & ~B[4]); 94| 32.3k| return v; 95| 32.3k|} hcr.c:fill_in_codeword: 203| 16.9k|{ 204| 16.9k| codeword[index].sp_offset = sp; 205| 16.9k| codeword[index].cb = cb; 206| 16.9k| codeword[index].decoded = 0; 207| 16.9k| codeword[index].bits.len = 0; 208| 16.9k|} hcr.c:concat_bits: 124| 3.75k|{ 125| 3.75k| uint32_t bl, bh, al, ah; 126| | 127| | /* empty addend */ 128| 3.75k| if (a->len == 0) return; ------------------ | Branch (128:9): [True: 0, False: 3.75k] ------------------ 129| | 130| | /* addend becomes result */ 131| 3.75k| if (b->len == 0) ------------------ | Branch (131:9): [True: 0, False: 3.75k] ------------------ 132| 0| { 133| 0| *b = *a; 134| 0| return; 135| 0| } 136| | 137| 3.75k| al = a->bufa; 138| 3.75k| ah = a->bufb; 139| | 140| 3.75k| if (b->len > 32) ------------------ | Branch (140:9): [True: 652, False: 3.10k] ------------------ 141| 652| { 142| | /* (b->len - 32) is 1..31 */ 143| | /* maskoff superfluous high b bits */ 144| 652| bl = b->bufa; 145| 652| bh = b->bufb & ((1u << (b->len-32)) - 1); 146| | /* left shift a b->len bits */ 147| 652| ah = al << (b->len - 32); 148| 652| al = 0; 149| 3.10k| } else if (b->len == 32) { ------------------ | Branch (149:16): [True: 15, False: 3.08k] ------------------ 150| 15| bl = b->bufa; 151| 15| bh = 0; 152| 15| ah = al; 153| 15| al = 0; 154| 3.08k| } else { 155| | /* b->len is 1..31, (32 - b->len) is 1..31 */ 156| 3.08k| bl = b->bufa & ((1u << (b->len)) - 1); 157| 3.08k| bh = 0; 158| 3.08k| ah = (ah << (b->len)) | (al >> (32 - b->len)); 159| 3.08k| al = al << b->len; 160| 3.08k| } 161| | 162| | /* merge */ 163| 3.75k| b->bufa = bl | al; 164| 3.75k| b->bufb = bh | ah; 165| | 166| 3.75k| b->len += a->len; 167| 3.75k|} huffman_scale_factor: 61| 25.2k|{ 62| 25.2k| uint16_t offset = 0; 63| | 64| 79.3k| while (hcb_sf[offset][1]) ------------------ | Branch (64:12): [True: 54.0k, False: 25.2k] ------------------ 65| 54.0k| { 66| 54.0k| uint8_t b = faad_get1bit(ld 67| 54.0k| DEBUGVAR(1,255,"huffman_scale_factor()")); 68| 54.0k| offset += hcb_sf[offset][b]; 69| 54.0k| } 70| | 71| 25.2k| return hcb_sf[offset][0]; 72| 25.2k|} huffman_spectral_data: 338| 138k|{ 339| 138k| switch (cb) 340| 138k| { 341| 17.0k| case 1: /* 2-step method for data quadruples */ ------------------ | Branch (341:5): [True: 17.0k, False: 121k] ------------------ 342| 17.8k| case 2: ------------------ | Branch (342:5): [True: 779, False: 137k] ------------------ 343| 17.8k| return huffman_2step_quad(cb, ld, sp); 344| 8.44k| case 3: /* binary search for data quadruples */ ------------------ | Branch (344:5): [True: 8.44k, False: 129k] ------------------ 345| 8.44k| return huffman_binary_quad_sign(cb, ld, sp); 346| 10.4k| case 4: /* 2-step method for data quadruples */ ------------------ | Branch (346:5): [True: 10.4k, False: 127k] ------------------ 347| 10.4k| return huffman_2step_quad_sign(cb, ld, sp); 348| 8.16k| case 5: /* binary search for data pairs */ ------------------ | Branch (348:5): [True: 8.16k, False: 130k] ------------------ 349| 8.16k| return huffman_binary_pair(cb, ld, sp); 350| 23.4k| case 6: /* 2-step method for data pairs */ ------------------ | Branch (350:5): [True: 23.4k, False: 114k] ------------------ 351| 23.4k| return huffman_2step_pair(cb, ld, sp); 352| 10.1k| case 7: /* binary search for data pairs */ ------------------ | Branch (352:5): [True: 10.1k, False: 128k] ------------------ 353| 21.7k| case 9: ------------------ | Branch (353:5): [True: 11.5k, False: 126k] ------------------ 354| 21.7k| return huffman_binary_pair_sign(cb, ld, sp); 355| 2.50k| case 8: /* 2-step method for data pairs */ ------------------ | Branch (355:5): [True: 2.50k, False: 135k] ------------------ 356| 13.2k| case 10: ------------------ | Branch (356:5): [True: 10.7k, False: 127k] ------------------ 357| 13.2k| return huffman_2step_pair_sign(cb, ld, sp); 358| | /* Codebook 12 is disallowed, see `section_data` */ 359| |#if 0 360| | case 12: { 361| | uint8_t err = huffman_2step_pair(11, ld, sp); 362| | sp[0] = huffman_codebook(0); sp[1] = huffman_codebook(1); 363| | return err; } 364| |#endif 365| 28.3k| case 11: ------------------ | Branch (365:5): [True: 28.3k, False: 109k] ------------------ 366| 28.3k| { 367| 28.3k| uint8_t err = huffman_2step_pair_sign(11, ld, sp); 368| 28.3k| if (!err) ------------------ | Branch (368:13): [True: 28.3k, False: 0] ------------------ 369| 28.3k| err = huffman_getescape(ld, &sp[0]); 370| 28.3k| if (!err) ------------------ | Branch (370:13): [True: 28.3k, False: 1] ------------------ 371| 28.3k| err = huffman_getescape(ld, &sp[1]); 372| 28.3k| return err; 373| 2.50k| } 374| 0|#ifdef ERROR_RESILIENCE 375| | /* VCB11 uses codebook 11 */ 376| 3.29k| case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: ------------------ | Branch (376:5): [True: 994, False: 137k] | Branch (376:14): [True: 514, False: 137k] | Branch (376:23): [True: 226, False: 138k] | Branch (376:32): [True: 154, False: 138k] | Branch (376:41): [True: 462, False: 137k] | Branch (376:50): [True: 282, False: 137k] | Branch (376:59): [True: 396, False: 137k] | Branch (376:68): [True: 266, False: 137k] ------------------ 377| 6.57k| case 24: case 25: case 26: case 27: case 28: case 29: case 30: case 31: ------------------ | Branch (377:5): [True: 222, False: 138k] | Branch (377:14): [True: 154, False: 138k] | Branch (377:23): [True: 232, False: 137k] | Branch (377:32): [True: 132, False: 138k] | Branch (377:41): [True: 178, False: 138k] | Branch (377:50): [True: 150, False: 138k] | Branch (377:59): [True: 578, False: 137k] | Branch (377:68): [True: 1.63k, False: 136k] ------------------ 378| 6.57k| { 379| 6.57k| uint8_t err = huffman_2step_pair_sign(11, ld, sp); 380| 6.57k| if (!err) ------------------ | Branch (380:13): [True: 6.57k, False: 0] ------------------ 381| 6.57k| err = huffman_getescape(ld, &sp[0]); 382| 6.57k| if (!err) ------------------ | Branch (382:13): [True: 6.57k, False: 0] ------------------ 383| 6.57k| err = huffman_getescape(ld, &sp[1]); 384| | 385| | /* check LAV (Largest Absolute Value) */ 386| | /* this finds errors in the ESCAPE signal */ 387| 6.57k| vcb11_check_LAV(cb, sp); 388| | 389| 6.57k| return err; 390| 4.94k| } 391| 0|#endif 392| 0| default: ------------------ | Branch (392:5): [True: 0, False: 138k] ------------------ 393| | /* Non existent codebook number, something went wrong */ 394| 0| return 11; 395| 138k| } 396| | 397| | /* return 0; */ 398| 138k|} huffman_spectral_data_2: 409| 34.8k|{ 410| 34.8k| uint32_t cw; 411| 34.8k| uint16_t offset = 0; 412| 34.8k| uint8_t extra_bits; 413| 34.8k| uint8_t vcb11 = 0; 414| | 415| | 416| 34.8k| switch (cb) ------------------ | Branch (416:13): [True: 34.8k, False: 0] ------------------ 417| 34.8k| { 418| 191| case 1: /* 2-step method for data quadruples */ ------------------ | Branch (418:5): [True: 191, False: 34.6k] ------------------ 419| 5.61k| case 2: ------------------ | Branch (419:5): [True: 5.42k, False: 29.4k] ------------------ 420| 10.3k| case 4: { ------------------ | Branch (420:5): [True: 4.69k, False: 30.1k] ------------------ 421| 10.3k| const hcb* root; 422| 10.3k| uint8_t root_bits; 423| 10.3k| const hcb_2_quad* table; 424| 10.3k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 425| 10.3k| if (hcbN[cb] == 0) __builtin_trap(); ------------------ | Branch (425:13): [True: 0, False: 10.3k] ------------------ 426| 10.3k| if (hcb_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (426:13): [True: 0, False: 10.3k] ------------------ 427| 10.3k| if (hcb_2_quad_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (427:13): [True: 0, False: 10.3k] ------------------ 428| | // In other words, `cb` is one of [1, 2, 4]. 429| 10.3k|#endif 430| 10.3k| root = hcb_table[cb]; 431| 10.3k| root_bits = hcbN[cb]; 432| 10.3k| table = hcb_2_quad_table[cb]; 433| | 434| 10.3k| cw = showbits_hcr(ld, root_bits); 435| 10.3k| offset = root[cw].offset; 436| 10.3k| extra_bits = root[cw].extra_bits; 437| | 438| 10.3k| if (extra_bits) ------------------ | Branch (438:13): [True: 2.20k, False: 8.09k] ------------------ 439| 2.20k| { 440| | /* We know for sure it's more than root_bits bits long. */ 441| 2.20k| if (flushbits_hcr(ld, root_bits)) return -1; ------------------ | Branch (441:17): [True: 577, False: 1.62k] ------------------ 442| 1.62k| offset += (uint16_t)showbits_hcr(ld, extra_bits); 443| 1.62k| if (flushbits_hcr(ld, table[offset].bits - root_bits)) return -1; ------------------ | Branch (443:17): [True: 344, False: 1.28k] ------------------ 444| 8.09k| } else { 445| 8.09k| if (flushbits_hcr(ld, table[offset].bits)) return -1; ------------------ | Branch (445:17): [True: 269, False: 7.83k] ------------------ 446| 8.09k| } 447| | 448| 9.11k| sp[0] = table[offset].x; 449| 9.11k| sp[1] = table[offset].y; 450| 9.11k| sp[2] = table[offset].v; 451| 9.11k| sp[3] = table[offset].w; 452| 9.11k| break; 453| 10.3k| } 454| 336| case 6: /* 2-step method for data pairs */ ------------------ | Branch (454:5): [True: 336, False: 34.5k] ------------------ 455| 1.49k| case 8: ------------------ | Branch (455:5): [True: 1.15k, False: 33.6k] ------------------ 456| 1.49k| case 10: ------------------ | Branch (456:5): [True: 0, False: 34.8k] ------------------ 457| 10.6k| case 11: ------------------ | Branch (457:5): [True: 9.10k, False: 25.7k] ------------------ 458| | /* VCB11 uses codebook 11 */ 459| 18.0k| case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: ------------------ | Branch (459:5): [True: 3.17k, False: 31.6k] | Branch (459:14): [True: 224, False: 34.6k] | Branch (459:23): [True: 2.22k, False: 32.6k] | Branch (459:32): [True: 664, False: 34.1k] | Branch (459:41): [True: 705, False: 34.1k] | Branch (459:50): [True: 16, False: 34.8k] | Branch (459:59): [True: 76, False: 34.7k] | Branch (459:68): [True: 362, False: 34.4k] ------------------ 460| 22.8k| case 24: case 25: case 26: case 27: case 28: case 29: case 30: case 31: { ------------------ | Branch (460:5): [True: 215, False: 34.6k] | Branch (460:14): [True: 70, False: 34.7k] | Branch (460:23): [True: 157, False: 34.6k] | Branch (460:32): [True: 1.24k, False: 33.6k] | Branch (460:41): [True: 18, False: 34.8k] | Branch (460:50): [True: 84, False: 34.7k] | Branch (460:59): [True: 51, False: 34.8k] | Branch (460:68): [True: 3.00k, False: 31.8k] ------------------ 461| 22.8k| const hcb* root; 462| 22.8k| uint8_t root_bits; 463| 22.8k| const hcb_2_pair* table; 464| | 465| 22.8k| if (cb >= 16) ------------------ | Branch (465:13): [True: 12.2k, False: 10.6k] ------------------ 466| 12.2k| { 467| | /* store the virtual codebook */ 468| 12.2k| vcb11 = cb; 469| 12.2k| cb = 11; 470| 12.2k| } 471| 22.8k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 472| 22.8k| if (hcbN[cb] == 0) __builtin_trap(); ------------------ | Branch (472:13): [True: 0, False: 22.8k] ------------------ 473| 22.8k| if (hcb_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (473:13): [True: 0, False: 22.8k] ------------------ 474| 22.8k| if (hcb_2_pair_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (474:13): [True: 0, False: 22.8k] ------------------ 475| | // In other words, `cb` is one of [6, 8, 10, 11]. 476| 22.8k|#endif 477| 22.8k| root = hcb_table[cb]; 478| 22.8k| root_bits = hcbN[cb]; 479| 22.8k| table = hcb_2_pair_table[cb]; 480| | 481| 22.8k| cw = showbits_hcr(ld, root_bits); 482| 22.8k| offset = root[cw].offset; 483| 22.8k| extra_bits = root[cw].extra_bits; 484| | 485| 22.8k| if (extra_bits) ------------------ | Branch (485:13): [True: 8.42k, False: 14.4k] ------------------ 486| 8.42k| { 487| | /* we know for sure it's more than hcbN[cb] bits long */ 488| 8.42k| if (flushbits_hcr(ld, root_bits)) return -1; ------------------ | Branch (488:17): [True: 488, False: 7.93k] ------------------ 489| 7.93k| offset += (uint16_t)showbits_hcr(ld, extra_bits); 490| 7.93k| if (flushbits_hcr(ld, table[offset].bits - root_bits)) return -1; ------------------ | Branch (490:17): [True: 725, False: 7.21k] ------------------ 491| 14.4k| } else { 492| 14.4k| if ( flushbits_hcr(ld, table[offset].bits)) return -1; ------------------ | Branch (492:18): [True: 997, False: 13.4k] ------------------ 493| 14.4k| } 494| 20.6k| sp[0] = table[offset].x; 495| 20.6k| sp[1] = table[offset].y; 496| 20.6k| break; 497| 22.8k| } 498| 0| case 3: { /* binary search for data quadruples */ ------------------ | Branch (498:5): [True: 0, False: 34.8k] ------------------ 499| 0| const hcb_bin_quad* table = hcb3; 500| 0| while (!table[offset].is_leaf) ------------------ | Branch (500:16): [True: 0, False: 0] ------------------ 501| 0| { 502| 0| uint8_t b; 503| 0| if (get1bit_hcr(ld, &b)) return -1; ------------------ | Branch (503:17): [True: 0, False: 0] ------------------ 504| 0| offset += table[offset].data[b]; 505| 0| } 506| | 507| 0| sp[0] = table[offset].data[0]; 508| 0| sp[1] = table[offset].data[1]; 509| 0| sp[2] = table[offset].data[2]; 510| 0| sp[3] = table[offset].data[3]; 511| | 512| 0| break; 513| 0| } 514| | 515| 509| case 5: /* binary search for data pairs */ ------------------ | Branch (515:5): [True: 509, False: 34.3k] ------------------ 516| 509| case 7: ------------------ | Branch (516:5): [True: 0, False: 34.8k] ------------------ 517| 1.66k| case 9: { ------------------ | Branch (517:5): [True: 1.15k, False: 33.6k] ------------------ 518| 1.66k| const hcb_bin_pair* table = hcb_bin_table[cb]; 519| 4.55k| while (!table[offset].is_leaf) ------------------ | Branch (519:16): [True: 2.99k, False: 1.56k] ------------------ 520| 2.99k| { 521| 2.99k| uint8_t b; 522| | 523| 2.99k| if (get1bit_hcr(ld, &b) ) return -1; ------------------ | Branch (523:17): [True: 105, False: 2.89k] ------------------ 524| 2.89k| offset += table[offset].data[b]; 525| 2.89k| } 526| | 527| 1.56k| sp[0] = table[offset].data[0]; 528| 1.56k| sp[1] = table[offset].data[1]; 529| | 530| 1.56k| break; 531| 1.66k| }} 532| | 533| | /* decode sign bits */ 534| 31.3k| if (unsigned_cb[cb]) ------------------ | Branch (534:9): [True: 25.7k, False: 5.60k] ------------------ 535| 25.7k| { 536| 25.7k| uint8_t i; 537| 75.7k| for(i = 0; i < ((cb < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN); i++) ------------------ | | 73| 75.7k|#define FIRST_PAIR_HCB 5 ------------------ for(i = 0; i < ((cb < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN); i++) ------------------ | | 75| 13.9k|#define QUAD_LEN 4 ------------------ for(i = 0; i < ((cb < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN); i++) ------------------ | | 76| 61.7k|#define PAIR_LEN 2 ------------------ | Branch (537:20): [True: 53.8k, False: 21.9k] | Branch (537:25): [True: 13.9k, False: 61.7k] ------------------ 538| 53.8k| { 539| 53.8k| if(sp[i]) ------------------ | Branch (539:16): [True: 32.8k, False: 20.9k] ------------------ 540| 32.8k| { 541| 32.8k| uint8_t b; 542| 32.8k| if ( get1bit_hcr(ld, &b) ) return -1; ------------------ | Branch (542:22): [True: 3.82k, False: 29.0k] ------------------ 543| 29.0k| if (b != 0) { ------------------ | Branch (543:21): [True: 13.3k, False: 15.7k] ------------------ 544| 13.3k| sp[i] = -sp[i]; 545| 13.3k| } 546| 29.0k| } 547| 53.8k| } 548| 25.7k| } 549| | 550| | /* decode huffman escape bits */ 551| 27.5k| if ((cb == ESC_HCB) || (cb >= 16)) ------------------ | | 74| 27.5k|#define ESC_HCB 11 ------------------ | Branch (551:9): [True: 17.7k, False: 9.75k] | Branch (551:28): [True: 0, False: 9.75k] ------------------ 552| 17.7k| { 553| 17.7k| uint8_t k; 554| 50.9k| for (k = 0; k < 2; k++) ------------------ | Branch (554:21): [True: 34.5k, False: 16.4k] ------------------ 555| 34.5k| { 556| 34.5k| if ((sp[k] == 16) || (sp[k] == -16)) ------------------ | Branch (556:17): [True: 2.09k, False: 32.4k] | Branch (556:34): [True: 2.38k, False: 30.0k] ------------------ 557| 4.48k| { 558| 4.48k| uint8_t neg, i; 559| 4.48k| int32_t j; 560| 4.48k| uint32_t off; 561| | 562| 4.48k| neg = (sp[k] < 0) ? 1 : 0; ------------------ | Branch (562:23): [True: 2.38k, False: 2.09k] ------------------ 563| | 564| 14.1k| for (i = 4; i < 16; i++) ------------------ | Branch (564:29): [True: 13.6k, False: 440] ------------------ 565| 13.6k| { 566| 13.6k| uint8_t b; 567| 13.6k| if (get1bit_hcr(ld, &b)) ------------------ | Branch (567:25): [True: 393, False: 13.2k] ------------------ 568| 393| return -1; 569| 13.2k| if (b == 0) ------------------ | Branch (569:25): [True: 3.65k, False: 9.62k] ------------------ 570| 3.65k| break; 571| 13.2k| } 572| | 573| 4.09k| if (i >= 16) ------------------ | Branch (573:21): [True: 440, False: 3.65k] ------------------ 574| 440| return -1; 575| | 576| 3.65k| if (getbits_hcr(ld, i, &off)) ------------------ | Branch (576:21): [True: 521, False: 3.13k] ------------------ 577| 521| return -1; 578| 3.13k| j = off + (1<len; 591| 27.5k|} huffman.c:huffman_2step_quad: 151| 28.2k|{ 152| 28.2k| uint32_t cw; 153| 28.2k| uint16_t offset; 154| 28.2k| uint8_t extra_bits; 155| 28.2k| const hcb* root; 156| 28.2k| uint8_t root_bits; 157| 28.2k| const hcb_2_quad* table; 158| 28.2k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 159| 28.2k| if (hcbN[cb] == 0) __builtin_trap(); ------------------ | Branch (159:9): [True: 0, False: 28.2k] ------------------ 160| 28.2k| if (hcb_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (160:9): [True: 0, False: 28.2k] ------------------ 161| 28.2k| if (hcb_2_quad_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (161:9): [True: 0, False: 28.2k] ------------------ 162| | // In other words, `cb` is one of [1, 2, 4]. 163| 28.2k|#endif 164| 28.2k| root = hcb_table[cb]; 165| 28.2k| root_bits = hcbN[cb]; 166| 28.2k| table = hcb_2_quad_table[cb]; 167| | 168| 28.2k| cw = faad_showbits(ld, root_bits); 169| 28.2k| offset = root[cw].offset; 170| 28.2k| extra_bits = root[cw].extra_bits; 171| | 172| 28.2k| if (extra_bits) ------------------ | Branch (172:9): [True: 2.29k, False: 25.9k] ------------------ 173| 2.29k| { 174| | /* We know for sure it's more than `root_bits` bits long. */ 175| 2.29k| faad_flushbits(ld, root_bits); 176| 2.29k| offset += (uint16_t)faad_showbits(ld, extra_bits); 177| 2.29k| faad_flushbits(ld, table[offset].bits - root_bits); 178| 25.9k| } else { 179| 25.9k| faad_flushbits(ld, table[offset].bits); 180| 25.9k| } 181| | 182| 28.2k| sp[0] = table[offset].x; 183| 28.2k| sp[1] = table[offset].y; 184| 28.2k| sp[2] = table[offset].v; 185| 28.2k| sp[3] = table[offset].w; 186| | 187| 28.2k| return 0; 188| 28.2k|} huffman.c:huffman_binary_quad_sign: 269| 8.44k|{ 270| 8.44k| uint8_t err = huffman_binary_quad(cb, ld, sp); 271| 8.44k| huffman_sign_bits(ld, sp, QUAD_LEN); ------------------ | | 75| 8.44k|#define QUAD_LEN 4 ------------------ 272| | 273| 8.44k| return err; 274| 8.44k|} huffman.c:huffman_binary_quad: 245| 8.44k|{ 246| 8.44k| uint16_t offset = 0; 247| 8.44k| const hcb_bin_quad* table = hcb3; 248| | 249| 8.44k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 250| 8.44k| if (cb != 3) __builtin_trap(); ------------------ | Branch (250:9): [True: 0, False: 8.44k] ------------------ 251| 8.44k|#endif 252| | 253| 21.3k| while (!table[offset].is_leaf) ------------------ | Branch (253:12): [True: 12.8k, False: 8.44k] ------------------ 254| 12.8k| { 255| 12.8k| uint8_t b = faad_get1bit(ld 256| 12.8k| DEBUGVAR(1,255,"huffman_spectral_data():3")); 257| 12.8k| offset += table[offset].data[b]; 258| 12.8k| } 259| | 260| 8.44k| sp[0] = table[offset].data[0]; 261| 8.44k| sp[1] = table[offset].data[1]; 262| 8.44k| sp[2] = table[offset].data[2]; 263| 8.44k| sp[3] = table[offset].data[3]; 264| | 265| 8.44k| return 0; 266| 8.44k|} huffman.c:huffman_sign_bits: 94| 88.8k|{ 95| 88.8k| uint8_t i; 96| | 97| 304k| for (i = 0; i < len; i++) ------------------ | Branch (97:17): [True: 215k, False: 88.8k] ------------------ 98| 215k| { 99| 215k| if(sp[i]) ------------------ | Branch (99:12): [True: 90.1k, False: 125k] ------------------ 100| 90.1k| { 101| 90.1k| if(faad_get1bit(ld ------------------ | Branch (101:16): [True: 28.9k, False: 61.2k] ------------------ 102| 90.1k| DEBUGVAR(1,5,"huffman_sign_bits(): sign bit")) & 1) 103| 28.9k| { 104| 28.9k| sp[i] = -sp[i]; 105| 28.9k| } 106| 90.1k| } 107| 215k| } 108| 88.8k|} huffman.c:huffman_2step_quad_sign: 191| 10.4k|{ 192| 10.4k| uint8_t err = huffman_2step_quad(cb, ld, sp); 193| 10.4k| huffman_sign_bits(ld, sp, QUAD_LEN); ------------------ | | 75| 10.4k|#define QUAD_LEN 4 ------------------ 194| | 195| 10.4k| return err; 196| 10.4k|} huffman.c:huffman_binary_pair: 277| 29.9k|{ 278| 29.9k| uint16_t offset = 0; 279| 29.9k| const hcb_bin_pair* table; 280| 29.9k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 281| 29.9k| if (hcb_bin_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (281:9): [True: 0, False: 29.9k] ------------------ 282| 29.9k| if (cb == 3) __builtin_trap(); ------------------ | Branch (282:9): [True: 0, False: 29.9k] ------------------ 283| | // In other words, `cb` is one of [5, 7, 9]. 284| 29.9k|#endif 285| 29.9k| table = hcb_bin_table[cb]; 286| | 287| 82.7k| while (!table[offset].is_leaf) ------------------ | Branch (287:12): [True: 52.8k, False: 29.9k] ------------------ 288| 52.8k| { 289| 52.8k| uint8_t b = faad_get1bit(ld 290| 52.8k| DEBUGVAR(1,255,"huffman_spectral_data():9")); 291| 52.8k| offset += table[offset].data[b]; 292| 52.8k| } 293| | 294| 29.9k| sp[0] = table[offset].data[0]; 295| 29.9k| sp[1] = table[offset].data[1]; 296| | 297| 29.9k| return 0; 298| 29.9k|} huffman.c:huffman_2step_pair: 199| 71.6k|{ 200| 71.6k| uint32_t cw; 201| 71.6k| uint16_t offset; 202| 71.6k| uint8_t extra_bits; 203| 71.6k| const hcb* root; 204| 71.6k| uint8_t root_bits; 205| 71.6k| const hcb_2_pair* table; 206| 71.6k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 207| 71.6k| if (hcbN[cb] == 0) __builtin_trap(); ------------------ | Branch (207:9): [True: 0, False: 71.6k] ------------------ 208| 71.6k| if (hcb_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (208:9): [True: 0, False: 71.6k] ------------------ 209| 71.6k| if (hcb_2_pair_table[cb] == NULL) __builtin_trap(); ------------------ | Branch (209:9): [True: 0, False: 71.6k] ------------------ 210| | // In other words, `cb` is one of [6, 8, 10, 11]. 211| 71.6k|#endif 212| 71.6k| root = hcb_table[cb]; 213| 71.6k| root_bits = hcbN[cb]; 214| 71.6k| table = hcb_2_pair_table[cb]; 215| | 216| 71.6k| cw = faad_showbits(ld, root_bits); 217| 71.6k| offset = root[cw].offset; 218| 71.6k| extra_bits = root[cw].extra_bits; 219| | 220| 71.6k| if (extra_bits) ------------------ | Branch (220:9): [True: 11.4k, False: 60.1k] ------------------ 221| 11.4k| { 222| | /* we know for sure it's more than hcbN[cb] bits long */ 223| 11.4k| faad_flushbits(ld, root_bits); 224| 11.4k| offset += (uint16_t)faad_showbits(ld, extra_bits); 225| 11.4k| faad_flushbits(ld, table[offset].bits - root_bits); 226| 60.1k| } else { 227| 60.1k| faad_flushbits(ld, table[offset].bits); 228| 60.1k| } 229| | 230| 71.6k| sp[0] = table[offset].x; 231| 71.6k| sp[1] = table[offset].y; 232| | 233| 71.6k| return 0; 234| 71.6k|} huffman.c:huffman_binary_pair_sign: 301| 21.7k|{ 302| 21.7k| uint8_t err = huffman_binary_pair(cb, ld, sp); 303| 21.7k| huffman_sign_bits(ld, sp, PAIR_LEN); ------------------ | | 76| 21.7k|#define PAIR_LEN 2 ------------------ 304| | 305| 21.7k| return err; 306| 21.7k|} huffman.c:huffman_2step_pair_sign: 237| 48.1k|{ 238| 48.1k| uint8_t err = huffman_2step_pair(cb, ld, sp); 239| 48.1k| huffman_sign_bits(ld, sp, PAIR_LEN); ------------------ | | 76| 48.1k|#define PAIR_LEN 2 ------------------ 240| | 241| 48.1k| return err; 242| 48.1k|} huffman.c:huffman_getescape: 111| 69.8k|{ 112| 69.8k| uint8_t neg, i; 113| 69.8k| int16_t j; 114| 69.8k| int16_t off; 115| 69.8k| int16_t x = *sp; 116| | 117| 69.8k| if (x < 0) ------------------ | Branch (117:9): [True: 14.9k, False: 54.8k] ------------------ 118| 14.9k| { 119| 14.9k| if (x != -16) ------------------ | Branch (119:13): [True: 11.0k, False: 3.90k] ------------------ 120| 11.0k| return 0; 121| 3.90k| neg = 1; 122| 54.8k| } else { 123| 54.8k| if (x != 16) ------------------ | Branch (123:13): [True: 52.0k, False: 2.81k] ------------------ 124| 52.0k| return 0; 125| 2.81k| neg = 0; 126| 2.81k| } 127| | 128| 13.7k| for (i = 4; i < 16; i++) ------------------ | Branch (128:17): [True: 13.7k, False: 1] ------------------ 129| 13.7k| { 130| 13.7k| if (faad_get1bit(ld ------------------ | Branch (130:13): [True: 6.71k, False: 7.00k] ------------------ 131| 13.7k| DEBUGVAR(1,6,"huffman_getescape(): escape size")) == 0) 132| 6.71k| { 133| 6.71k| break; 134| 6.71k| } 135| 13.7k| } 136| 6.71k| if (i >= 16) ------------------ | Branch (136:9): [True: 1, False: 6.71k] ------------------ 137| 1| return 10; 138| | 139| 6.71k| off = (int16_t)faad_getbits(ld, i 140| 6.71k| DEBUGVAR(1,9,"huffman_getescape(): escape")); 141| | 142| 6.71k| j = off | (1< 31) ------------------ | Branch (325:9): [True: 0, False: 15.7k] | Branch (325:20): [True: 0, False: 15.7k] ------------------ 326| 0| return; 327| | 328| 15.7k| max = vcb11_LAV_tab[cb - 16]; 329| | 330| 15.7k| if ((abs(sp[0]) > max) || (abs(sp[1]) > max)) ------------------ | Branch (330:9): [True: 317, False: 15.4k] | Branch (330:31): [True: 292, False: 15.1k] ------------------ 331| 609| { 332| 609| sp[0] = 0; 333| 609| sp[1] = 0; 334| 609| } 335| 15.7k|} is_decode: 48| 8.84k|{ 49| 8.84k| uint8_t g, sfb, b; 50| 8.84k| uint16_t i; 51| 8.84k| real_t scale; 52| 8.84k|#ifdef FIXED_POINT 53| 8.84k| int32_t exp, frac; 54| 8.84k|#endif 55| | 56| 8.84k| uint16_t nshort = frame_len/8; 57| 8.84k| uint8_t group = 0; 58| | 59| 36.2k| for (g = 0; g < icsr->num_window_groups; g++) ------------------ | Branch (59:17): [True: 27.3k, False: 8.84k] ------------------ 60| 27.3k| { 61| | /* Do intensity stereo decoding */ 62| 60.6k| for (b = 0; b < icsr->window_group_length[g]; b++) ------------------ | Branch (62:21): [True: 33.2k, False: 27.3k] ------------------ 63| 33.2k| { 64| 53.7k| for (sfb = 0; sfb < icsr->max_sfb; sfb++) ------------------ | Branch (64:27): [True: 20.5k, False: 33.2k] ------------------ 65| 20.5k| { 66| 20.5k| if (is_intensity(icsr, g, sfb)) ------------------ | Branch (66:21): [True: 4.48k, False: 16.0k] ------------------ 67| 4.48k| { 68| 4.48k| int16_t scale_factor = icsr->scale_factors[g][sfb]; 69| |#ifdef MAIN_DEC 70| | /* For scalefactor bands coded in intensity stereo the 71| | corresponding predictors in the right channel are 72| | switched to "off". 73| | */ 74| | ics->pred.prediction_used[sfb] = 0; 75| | icsr->pred.prediction_used[sfb] = 0; 76| |#endif 77| | 78| |#ifndef FIXED_POINT 79| | scale_factor = min(max(scale_factor, -120), 120); 80| | scale = (real_t)pow(0.5, (0.25*scale_factor)); 81| |#else 82| 4.48k| scale_factor = min(max(scale_factor, -60), 60); ------------------ | | 60| 8.97k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 4.45k, False: 28] | | | Branch (60:22): [True: 4.37k, False: 110] | | | Branch (60:35): [True: 4.34k, False: 110] | | ------------------ ------------------ 83| 4.48k| exp = scale_factor >> 2; /* exp is -15..15 */ 84| 4.48k| frac = scale_factor & 3; 85| 4.48k| scale = pow05_table[frac]; 86| 4.48k| exp += COEF_BITS - REAL_BITS; /* exp is -1..29 */ ------------------ | | 43| 4.48k|#define COEF_BITS 28 ------------------ exp += COEF_BITS - REAL_BITS; /* exp is -1..29 */ ------------------ | | 45| 4.48k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 87| 4.48k| if (exp < 0) ------------------ | Branch (87:25): [True: 110, False: 4.37k] ------------------ 88| 110| scale <<= -exp; 89| 4.37k| else 90| 4.37k| scale >>= exp; 91| 4.48k|#endif 92| | 93| | /* Scale from left to right channel, 94| | do not touch left channel */ 95| 26.9k| for (i = icsr->swb_offset[sfb]; i < min(icsr->swb_offset[sfb+1], ics->swb_offset_max); i++) ------------------ | | 60| 26.9k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 26.6k, False: 238] | | ------------------ ------------------ | Branch (95:53): [True: 22.4k, False: 4.48k] ------------------ 96| 22.4k| { 97| 22.4k| r_spec[(group*nshort)+i] = MUL_R(l_spec[(group*nshort)+i], scale); ------------------ | | 239| 22.4k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 22.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 22.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 98| 22.4k| if (is_intensity(icsr, g, sfb) != invert_intensity(ics, g, sfb)) ------------------ | Branch (98:29): [True: 12.0k, False: 10.3k] ------------------ 99| 12.0k| r_spec[(group*nshort)+i] = -r_spec[(group*nshort)+i]; 100| 22.4k| } 101| 4.48k| } 102| 20.5k| } 103| 33.2k| group++; 104| 33.2k| } 105| 27.3k| } 106| 8.84k|} specrec.c:is_intensity: 44| 2.56M|{ 45| 2.56M| switch (ics->sfb_cb[group][sfb]) 46| 2.56M| { 47| 449| case INTENSITY_HCB: ------------------ | | 108| 449|#define INTENSITY_HCB 15 ------------------ | Branch (47:5): [True: 449, False: 2.56M] ------------------ 48| 449| return 1; 49| 1.92k| case INTENSITY_HCB2: ------------------ | | 107| 1.92k|#define INTENSITY_HCB2 14 ------------------ | Branch (49:5): [True: 1.92k, False: 2.56M] ------------------ 50| 1.92k| return -1; 51| 2.56M| default: ------------------ | Branch (51:5): [True: 2.56M, False: 2.37k] ------------------ 52| 2.56M| return 0; 53| 2.56M| } 54| 2.56M|} ms.c:is_intensity: 44| 7.01k|{ 45| 7.01k| switch (ics->sfb_cb[group][sfb]) 46| 7.01k| { 47| 250| case INTENSITY_HCB: ------------------ | | 108| 250|#define INTENSITY_HCB 15 ------------------ | Branch (47:5): [True: 250, False: 6.76k] ------------------ 48| 250| return 1; 49| 1.52k| case INTENSITY_HCB2: ------------------ | | 107| 1.52k|#define INTENSITY_HCB2 14 ------------------ | Branch (49:5): [True: 1.52k, False: 5.48k] ------------------ 50| 1.52k| return -1; 51| 5.23k| default: ------------------ | Branch (51:5): [True: 5.23k, False: 1.77k] ------------------ 52| 5.23k| return 0; 53| 7.01k| } 54| 7.01k|} is.c:is_intensity: 44| 42.9k|{ 45| 42.9k| switch (ics->sfb_cb[group][sfb]) 46| 42.9k| { 47| 3.66k| case INTENSITY_HCB: ------------------ | | 108| 3.66k|#define INTENSITY_HCB 15 ------------------ | Branch (47:5): [True: 3.66k, False: 39.2k] ------------------ 48| 3.66k| return 1; 49| 23.2k| case INTENSITY_HCB2: ------------------ | | 107| 23.2k|#define INTENSITY_HCB2 14 ------------------ | Branch (49:5): [True: 23.2k, False: 19.7k] ------------------ 50| 23.2k| return -1; 51| 16.0k| default: ------------------ | Branch (51:5): [True: 16.0k, False: 26.9k] ------------------ 52| 16.0k| return 0; 53| 42.9k| } 54| 42.9k|} is.c:invert_intensity: 57| 22.4k|{ 58| 22.4k| if (ics->ms_mask_present == 1) ------------------ | Branch (58:9): [True: 13.4k, False: 9.01k] ------------------ 59| 13.4k| return (1-2*ics->ms_used[group][sfb]); 60| 9.01k| return 1; 61| 22.4k|} faad_mdct_init: 63| 3.29k|{ 64| 3.29k| mdct_info *mdct = (mdct_info*)faad_malloc(sizeof(mdct_info)); 65| | 66| 3.29k| assert(N % 8 == 0); ------------------ | Branch (66:5): [True: 0, False: 3.29k] | Branch (66:5): [True: 3.29k, False: 0] ------------------ 67| | 68| 3.29k| mdct->N = N; 69| | 70| | /* NOTE: For "small framelengths" in FIXED_POINT the coefficients need to be 71| | * scaled by sqrt("(nearest power of 2) > N" / N) */ 72| | 73| | /* RE(mdct->sincos[k]) = scale*(real_t)(cos(2.0*M_PI*(k+1./8.) / (real_t)N)); 74| | * IM(mdct->sincos[k]) = scale*(real_t)(sin(2.0*M_PI*(k+1./8.) / (real_t)N)); */ 75| | /* scale is 1 for fixed point, sqrt(N) for floating point */ 76| 3.29k| switch (N) ------------------ | Branch (76:13): [True: 3.29k, False: 0] ------------------ 77| 3.29k| { 78| 1.10k| case 2048: mdct->sincos = (complex_t*)mdct_tab_2048; break; ------------------ | Branch (78:5): [True: 1.10k, False: 2.19k] ------------------ 79| 1.10k| case 256: mdct->sincos = (complex_t*)mdct_tab_256; break; ------------------ | Branch (79:5): [True: 1.10k, False: 2.19k] ------------------ 80| |#ifdef LD_DEC 81| | case 1024: mdct->sincos = (complex_t*)mdct_tab_1024; break; 82| |#endif 83| 0|#ifdef ALLOW_SMALL_FRAMELENGTH 84| 542| case 1920: mdct->sincos = (complex_t*)mdct_tab_1920; break; ------------------ | Branch (84:5): [True: 542, False: 2.75k] ------------------ 85| 542| case 240: mdct->sincos = (complex_t*)mdct_tab_240; break; ------------------ | Branch (85:5): [True: 542, False: 2.75k] ------------------ 86| |#ifdef LD_DEC 87| | case 960: mdct->sincos = (complex_t*)mdct_tab_960; break; 88| |#endif 89| 3.29k|#endif 90| |#ifdef SSR_DEC 91| | case 512: mdct->sincos = (complex_t*)mdct_tab_512; break; 92| | case 64: mdct->sincos = (complex_t*)mdct_tab_64; break; 93| |#endif 94| 3.29k| } 95| | 96| | /* initialise fft */ 97| 3.29k| mdct->cfft = cffti(N/4); 98| | 99| |#ifdef PROFILE 100| | mdct->cycles = 0; 101| | mdct->fft_cycles = 0; 102| |#endif 103| | 104| 3.29k| return mdct; 105| 3.29k|} faad_mdct_end: 108| 3.29k|{ 109| 3.29k| if (mdct != NULL) ------------------ | Branch (109:9): [True: 3.29k, False: 0] ------------------ 110| 3.29k| { 111| |#ifdef PROFILE 112| | printf("MDCT[%.4d]: %I64d cycles\n", mdct->N, mdct->cycles); 113| | printf("CFFT[%.4d]: %I64d cycles\n", mdct->N/4, mdct->fft_cycles); 114| |#endif 115| | 116| 3.29k| cfftu(mdct->cfft); 117| | 118| 3.29k| faad_free(mdct); 119| 3.29k| } 120| 3.29k|} faad_imdct: 123| 130k|{ 124| 130k| uint16_t k; 125| | 126| 130k| complex_t x; 127| 130k|#ifdef ALLOW_SMALL_FRAMELENGTH 128| 130k|#ifdef FIXED_POINT 129| 130k| real_t scale = 0, b_scale = 0; 130| 130k|#endif 131| 130k|#endif 132| 130k| ALIGN complex_t Z1[512]; 133| 130k| complex_t *sincos = mdct->sincos; 134| | 135| 130k| uint16_t N = mdct->N; 136| 130k| uint16_t N2 = N >> 1; 137| 130k| uint16_t N4 = N >> 2; 138| 130k| uint16_t N8 = N >> 3; 139| | 140| |#ifdef PROFILE 141| | int64_t count1, count2 = faad_get_ts(); 142| |#endif 143| | 144| 130k|#ifdef ALLOW_SMALL_FRAMELENGTH 145| 130k|#ifdef FIXED_POINT 146| | /* detect non-power of 2 */ 147| 130k| if (N & (N-1)) ------------------ | Branch (147:9): [True: 27.1k, False: 103k] ------------------ 148| 27.1k| { 149| | /* adjust scale for non-power of 2 MDCT */ 150| | /* 2048/1920 */ 151| 27.1k| b_scale = 1; 152| 27.1k| scale = COEF_CONST(1.0666666666666667); ------------------ | | 60| 27.1k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 27.1k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 27.1k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 27.1k, Folded] | | ------------------ ------------------ 153| 27.1k| } 154| 130k|#endif 155| 130k|#endif 156| | 157| | /* pre-IFFT complex multiplication */ 158| 22.9M| for (k = 0; k < N4; k++) ------------------ | Branch (158:17): [True: 22.8M, False: 130k] ------------------ 159| 22.8M| { 160| 22.8M| ComplexMult(&IM(Z1[k]), &RE(Z1[k]), ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(Z1[k]), &RE(Z1[k]), ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ 161| 22.8M| X_in[2*k], X_in[N2 - 1 - 2*k], RE(sincos[k]), IM(sincos[k])); ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ X_in[2*k], X_in[N2 - 1 - 2*k], RE(sincos[k]), IM(sincos[k])); ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ 162| 22.8M| } 163| | 164| |#ifdef PROFILE 165| | count1 = faad_get_ts(); 166| |#endif 167| | 168| | /* complex IFFT, any non-scaling FFT can be used here */ 169| 130k| cfftb(mdct->cfft, Z1); 170| | 171| |#ifdef PROFILE 172| | count1 = faad_get_ts() - count1; 173| |#endif 174| | 175| | /* post-IFFT complex multiplication */ 176| 22.9M| for (k = 0; k < N4; k++) ------------------ | Branch (176:17): [True: 22.8M, False: 130k] ------------------ 177| 22.8M| { 178| 22.8M| RE(x) = RE(Z1[k]); ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ RE(x) = RE(Z1[k]); ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ 179| 22.8M| IM(x) = IM(Z1[k]); ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ IM(x) = IM(Z1[k]); ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ 180| 22.8M| ComplexMult(&IM(Z1[k]), &RE(Z1[k]), ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ ComplexMult(&IM(Z1[k]), &RE(Z1[k]), ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ 181| 22.8M| IM(x), RE(x), RE(sincos[k]), IM(sincos[k])); ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ IM(x), RE(x), RE(sincos[k]), IM(sincos[k])); ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ IM(x), RE(x), RE(sincos[k]), IM(sincos[k])); ------------------ | | 391| 22.8M|#define RE(A) (A)[0] ------------------ IM(x), RE(x), RE(sincos[k]), IM(sincos[k])); ------------------ | | 392| 22.8M|#define IM(A) (A)[1] ------------------ 182| | 183| 22.8M|#ifdef ALLOW_SMALL_FRAMELENGTH 184| 22.8M|#ifdef FIXED_POINT 185| | /* non-power of 2 MDCT scaling */ 186| 22.8M| if (b_scale) ------------------ | Branch (186:13): [True: 5.95M, False: 16.8M] ------------------ 187| 5.95M| { 188| 5.95M| RE(Z1[k]) = MUL_C(RE(Z1[k]), scale); ------------------ | | 391| 5.95M|#define RE(A) (A)[0] ------------------ RE(Z1[k]) = MUL_C(RE(Z1[k]), scale); ------------------ | | 241| 5.95M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 5.95M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 5.95M|#define COEF_BITS 28 | | ------------------ ------------------ 189| 5.95M| IM(Z1[k]) = MUL_C(IM(Z1[k]), scale); ------------------ | | 392| 5.95M|#define IM(A) (A)[1] ------------------ IM(Z1[k]) = MUL_C(IM(Z1[k]), scale); ------------------ | | 241| 5.95M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 5.95M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 5.95M|#define COEF_BITS 28 | | ------------------ ------------------ 190| 5.95M| } 191| 22.8M|#endif 192| 22.8M|#endif 193| 22.8M| } 194| | 195| | /* reordering */ 196| 5.83M| for (k = 0; k < N8; k+=2) ------------------ | Branch (196:17): [True: 5.70M, False: 130k] ------------------ 197| 5.70M| { 198| 5.70M| X_out[ 2*k] = IM(Z1[N8 + k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 199| 5.70M| X_out[ 2 + 2*k] = IM(Z1[N8 + 1 + k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 200| | 201| 5.70M| X_out[ 1 + 2*k] = -RE(Z1[N8 - 1 - k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 202| 5.70M| X_out[ 3 + 2*k] = -RE(Z1[N8 - 2 - k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 203| | 204| 5.70M| X_out[N4 + 2*k] = RE(Z1[ k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 205| 5.70M| X_out[N4 + + 2 + 2*k] = RE(Z1[ 1 + k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 206| | 207| 5.70M| X_out[N4 + 1 + 2*k] = -IM(Z1[N4 - 1 - k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 208| 5.70M| X_out[N4 + 3 + 2*k] = -IM(Z1[N4 - 2 - k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 209| | 210| 5.70M| X_out[N2 + 2*k] = RE(Z1[N8 + k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 211| 5.70M| X_out[N2 + + 2 + 2*k] = RE(Z1[N8 + 1 + k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 212| | 213| 5.70M| X_out[N2 + 1 + 2*k] = -IM(Z1[N8 - 1 - k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 214| 5.70M| X_out[N2 + 3 + 2*k] = -IM(Z1[N8 - 2 - k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 215| | 216| 5.70M| X_out[N2 + N4 + 2*k] = -IM(Z1[ k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 217| 5.70M| X_out[N2 + N4 + 2 + 2*k] = -IM(Z1[ 1 + k]); ------------------ | | 392| 5.70M|#define IM(A) (A)[1] ------------------ 218| | 219| 5.70M| X_out[N2 + N4 + 1 + 2*k] = RE(Z1[N4 - 1 - k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 220| 5.70M| X_out[N2 + N4 + 3 + 2*k] = RE(Z1[N4 - 2 - k]); ------------------ | | 391| 5.70M|#define RE(A) (A)[0] ------------------ 221| 5.70M| } 222| | 223| |#ifdef PROFILE 224| | count2 = faad_get_ts() - count2; 225| | mdct->fft_cycles += count1; 226| | mdct->cycles += (count2 - count1); 227| |#endif 228| 130k|} AudioSpecificConfigFromBitfile: 130| 474|{ 131| 474| int8_t result = 0; 132| 474| uint32_t startpos = faad_get_processed_bits(ld); 133| 474|#ifdef SBR_DEC 134| 474| int8_t bits_to_decode = 0; 135| 474|#endif 136| | 137| 474| if (mp4ASC == NULL) ------------------ | Branch (137:9): [True: 0, False: 474] ------------------ 138| 0| return -8; 139| | 140| 474| memset(mp4ASC, 0, sizeof(mp4AudioSpecificConfig)); 141| | 142| 474| mp4ASC->objectTypeIndex = (uint8_t)faad_getbits(ld, 5 143| 474| DEBUGVAR(1,1,"parse_audio_decoder_specific_info(): ObjectTypeIndex")); 144| | 145| 474| mp4ASC->samplingFrequencyIndex = (uint8_t)faad_getbits(ld, 4 146| 474| DEBUGVAR(1,2,"parse_audio_decoder_specific_info(): SamplingFrequencyIndex")); 147| 474| if(mp4ASC->samplingFrequencyIndex==0x0f) ------------------ | Branch (147:5): [True: 0, False: 474] ------------------ 148| 0| faad_getbits(ld, 24); 149| | 150| 474| mp4ASC->channelsConfiguration = (uint8_t)faad_getbits(ld, 4 151| 474| DEBUGVAR(1,3,"parse_audio_decoder_specific_info(): ChannelsConfiguration")); 152| | 153| 474| mp4ASC->samplingFrequency = get_sample_rate(mp4ASC->samplingFrequencyIndex); 154| | 155| 474| if (ObjectTypesTable[mp4ASC->objectTypeIndex] != 1) ------------------ | Branch (155:9): [True: 1, False: 473] ------------------ 156| 1| { 157| 1| return -1; 158| 1| } 159| | 160| 473| if (mp4ASC->samplingFrequency == 0) ------------------ | Branch (160:9): [True: 0, False: 473] ------------------ 161| 0| { 162| 0| return -2; 163| 0| } 164| | 165| 473| if (mp4ASC->channelsConfiguration > 7) ------------------ | Branch (165:9): [True: 0, False: 473] ------------------ 166| 0| { 167| 0| return -3; 168| 0| } 169| | 170| 473|#if (defined(PS_DEC) || defined(DRM_PS)) 171| | /* check if we have a mono file */ 172| 473| if (mp4ASC->channelsConfiguration == 1) ------------------ | Branch (172:9): [True: 3, False: 470] ------------------ 173| 3| { 174| | /* upMatrix to 2 channels for implicit signalling of PS */ 175| 3| mp4ASC->channelsConfiguration = 2; 176| 3| } 177| 473|#endif 178| | 179| 473|#ifdef SBR_DEC 180| 473| mp4ASC->sbr_present_flag = -1; 181| 473| if (mp4ASC->objectTypeIndex == 5 || mp4ASC->objectTypeIndex == 29) ------------------ | Branch (181:9): [True: 208, False: 265] | Branch (181:41): [True: 5, False: 260] ------------------ 182| 213| { 183| 213| uint8_t tmp; 184| | 185| 213| mp4ASC->sbr_present_flag = 1; 186| 213| tmp = (uint8_t)faad_getbits(ld, 4 187| 213| DEBUGVAR(1,5,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); 188| | /* check for downsampled SBR */ 189| 213| if (tmp == mp4ASC->samplingFrequencyIndex) ------------------ | Branch (189:13): [True: 46, False: 167] ------------------ 190| 46| mp4ASC->downSampledSBR = 1; 191| 213| mp4ASC->samplingFrequencyIndex = tmp; 192| 213| if (mp4ASC->samplingFrequencyIndex == 15) ------------------ | Branch (192:13): [True: 0, False: 213] ------------------ 193| 0| { 194| 0| mp4ASC->samplingFrequency = (uint32_t)faad_getbits(ld, 24 195| 0| DEBUGVAR(1,6,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); 196| 213| } else { 197| 213| mp4ASC->samplingFrequency = get_sample_rate(mp4ASC->samplingFrequencyIndex); 198| 213| } 199| 213| mp4ASC->objectTypeIndex = (uint8_t)faad_getbits(ld, 5 200| 213| DEBUGVAR(1,7,"parse_audio_decoder_specific_info(): ObjectTypeIndex")); 201| 213| } 202| 473|#endif 203| | 204| | /* get GASpecificConfig */ 205| 473| if (mp4ASC->objectTypeIndex == 1 || mp4ASC->objectTypeIndex == 2 || ------------------ | Branch (205:9): [True: 104, False: 369] | Branch (205:41): [True: 112, False: 257] ------------------ 206| 257| mp4ASC->objectTypeIndex == 3 || mp4ASC->objectTypeIndex == 4 || ------------------ | Branch (206:9): [True: 14, False: 243] | Branch (206:41): [True: 4, False: 239] ------------------ 207| 239| mp4ASC->objectTypeIndex == 6 || mp4ASC->objectTypeIndex == 7) ------------------ | Branch (207:9): [True: 0, False: 239] | Branch (207:41): [True: 5, False: 234] ------------------ 208| 239| { 209| 239| result = GASpecificConfig(ld, mp4ASC, pce); 210| | 211| 239|#ifdef ERROR_RESILIENCE 212| 239| } else if (mp4ASC->objectTypeIndex >= ER_OBJECT_START) { /* ER */ ------------------ | | 71| 234|#define ER_OBJECT_START 17 ------------------ | Branch (212:16): [True: 234, False: 0] ------------------ 213| 234| result = GASpecificConfig(ld, mp4ASC, pce); 214| 234| mp4ASC->epConfig = (uint8_t)faad_getbits(ld, 2 215| 234| DEBUGVAR(1,143,"parse_audio_decoder_specific_info(): epConfig")); 216| | 217| 234| if (mp4ASC->epConfig != 0) ------------------ | Branch (217:13): [True: 0, False: 234] ------------------ 218| 0| result = -5; 219| 234|#endif 220| | 221| 234| } else { 222| 0| result = -4; 223| 0| } 224| | 225| |#ifdef SSR_DEC 226| | /* shorter frames not allowed for SSR */ 227| | if ((mp4ASC->objectTypeIndex == 4) && mp4ASC->frameLengthFlag) 228| | return -6; 229| |#endif 230| | 231| | 232| 473|#ifdef SBR_DEC 233| 473| if(short_form) ------------------ | Branch (233:8): [True: 0, False: 473] ------------------ 234| 0| bits_to_decode = 0; 235| 473| else 236| 473| bits_to_decode = (int8_t)(buffer_size*8 + faad_get_processed_bits(ld) - startpos); 237| | 238| 473| if ((mp4ASC->objectTypeIndex != 5 && mp4ASC->objectTypeIndex != 29) && (bits_to_decode >= 16)) ------------------ | Branch (238:10): [True: 473, False: 0] | Branch (238:42): [True: 472, False: 1] | Branch (238:76): [True: 258, False: 214] ------------------ 239| 258| { 240| 258| int16_t syncExtensionType = (int16_t)faad_getbits(ld, 11 241| 258| DEBUGVAR(1,9,"parse_audio_decoder_specific_info(): syncExtensionType")); 242| | 243| 258| if (syncExtensionType == 0x2b7) ------------------ | Branch (243:13): [True: 42, False: 216] ------------------ 244| 42| { 245| 42| uint8_t tmp_OTi = (uint8_t)faad_getbits(ld, 5 246| 42| DEBUGVAR(1,10,"parse_audio_decoder_specific_info(): extensionAudioObjectType")); 247| | 248| 42| if (tmp_OTi == 5) ------------------ | Branch (248:17): [True: 41, False: 1] ------------------ 249| 41| { 250| 41| mp4ASC->sbr_present_flag = (uint8_t)faad_get1bit(ld 251| 41| DEBUGVAR(1,11,"parse_audio_decoder_specific_info(): sbr_present_flag")); 252| | 253| 41| if (mp4ASC->sbr_present_flag) ------------------ | Branch (253:21): [True: 41, False: 0] ------------------ 254| 41| { 255| 41| uint8_t tmp; 256| | 257| | /* Don't set OT to SBR until checked that it is actually there */ 258| 41| mp4ASC->objectTypeIndex = tmp_OTi; 259| | 260| 41| tmp = (uint8_t)faad_getbits(ld, 4 261| 41| DEBUGVAR(1,12,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); 262| | 263| | /* check for downsampled SBR */ 264| 41| if (tmp == mp4ASC->samplingFrequencyIndex) ------------------ | Branch (264:25): [True: 0, False: 41] ------------------ 265| 0| mp4ASC->downSampledSBR = 1; 266| 41| mp4ASC->samplingFrequencyIndex = tmp; 267| | 268| 41| if (mp4ASC->samplingFrequencyIndex == 15) ------------------ | Branch (268:25): [True: 5, False: 36] ------------------ 269| 5| { 270| 5| mp4ASC->samplingFrequency = (uint32_t)faad_getbits(ld, 24 271| 5| DEBUGVAR(1,13,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); 272| 36| } else { 273| 36| mp4ASC->samplingFrequency = get_sample_rate(mp4ASC->samplingFrequencyIndex); 274| 36| } 275| 41| } 276| 41| } 277| 42| } 278| 258| } 279| | 280| | /* no SBR signalled, this could mean either implicit signalling or no SBR in this file */ 281| | /* MPEG specification states: assume SBR on files with samplerate <= 24000 Hz */ 282| 473| if (mp4ASC->sbr_present_flag == (char)-1) /* cannot be -1 on systems with unsigned char */ ------------------ | Branch (282:9): [True: 260, False: 213] ------------------ 283| 260| { 284| 260| if (mp4ASC->samplingFrequency <= 24000) ------------------ | Branch (284:13): [True: 76, False: 184] ------------------ 285| 76| { 286| 76| mp4ASC->samplingFrequency *= 2; 287| 76| mp4ASC->forceUpSampling = 1; 288| 184| } else /* > 24000*/ { 289| 184| mp4ASC->downSampledSBR = 1; 290| 184| } 291| 260| } 292| 473|#endif 293| | 294| 473| faad_endbits(ld); 295| | 296| 473| return result; 297| 473|} AudioSpecificConfig2: 304| 474|{ 305| 474| uint8_t ret = 0; 306| 474| bitfile ld; 307| 474| faad_initbits(&ld, pBuffer, buffer_size); 308| 474| if (ld.error != 0) ------------------ | Branch (308:9): [True: 0, False: 474] ------------------ 309| 0| return -7; 310| 474| ret = AudioSpecificConfigFromBitfile(&ld, mp4ASC, pce, buffer_size, short_form); 311| 474| faad_endbits(&ld); 312| 474| return ret; 313| 474|} ms_decode: 41| 8.84k|{ 42| 8.84k| uint8_t g, b, sfb; 43| 8.84k| uint8_t group = 0; 44| 8.84k| uint16_t nshort = frame_len/8; 45| | 46| 8.84k| uint16_t i, k; 47| 8.84k| real_t tmp; 48| | 49| 8.84k| if (ics->ms_mask_present >= 1) ------------------ | Branch (49:9): [True: 1.28k, False: 7.55k] ------------------ 50| 1.28k| { 51| 5.27k| for (g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (51:21): [True: 3.99k, False: 1.28k] ------------------ 52| 3.99k| { 53| 10.5k| for (b = 0; b < ics->window_group_length[g]; b++) ------------------ | Branch (53:25): [True: 6.51k, False: 3.99k] ------------------ 54| 6.51k| { 55| 17.7k| for (sfb = 0; sfb < ics->max_sfb; sfb++) ------------------ | Branch (55:31): [True: 11.2k, False: 6.51k] ------------------ 56| 11.2k| { 57| | /* If intensity stereo coding or noise substitution is on 58| | for a particular scalefactor band, no M/S stereo decoding 59| | is carried out. 60| | */ 61| 11.2k| if ((ics->ms_used[g][sfb] || ics->ms_mask_present == 2) && ------------------ | Branch (61:26): [True: 5.88k, False: 5.38k] | Branch (61:50): [True: 1.12k, False: 4.26k] ------------------ 62| 7.01k| !is_intensity(icsr, g, sfb) && !is_noise(ics, g, sfb)) ------------------ | Branch (62:25): [True: 5.23k, False: 1.77k] | Branch (62:56): [True: 5.23k, False: 0] ------------------ 63| 5.23k| { 64| 62.6k| for (i = ics->swb_offset[sfb]; i < min(ics->swb_offset[sfb+1], ics->swb_offset_max); i++) ------------------ | | 60| 62.6k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 62.3k, False: 293] | | ------------------ ------------------ | Branch (64:56): [True: 57.3k, False: 5.23k] ------------------ 65| 57.3k| { 66| 57.3k| k = (group*nshort) + i; 67| 57.3k| tmp = l_spec[k] - r_spec[k]; 68| 57.3k| l_spec[k] = l_spec[k] + r_spec[k]; 69| 57.3k| r_spec[k] = tmp; 70| 57.3k| } 71| 5.23k| } 72| 11.2k| } 73| 6.51k| group++; 74| 6.51k| } 75| 3.99k| } 76| 1.28k| } 77| 8.84k|} output_to_PCM: 472| 385|{ 473| 385| uint8_t ch; 474| 385| uint16_t i; 475| 385| int16_t *short_sample_buffer = (int16_t*)sample_buffer; 476| 385| int32_t *int_sample_buffer = (int32_t*)sample_buffer; 477| 385| int32_t exp, half, sat_shift_mask; 478| | 479| | /* Copy output to a standard PCM buffer */ 480| 5.73k| for (ch = 0; ch < channels; ch++) ------------------ | Branch (480:18): [True: 5.35k, False: 385] ------------------ 481| 5.35k| { 482| 5.35k| switch (format) ------------------ | Branch (482:17): [True: 5.35k, False: 0] ------------------ 483| 5.35k| { 484| 644| case FAAD_FMT_16BIT: ------------------ | | 98| 644|#define FAAD_FMT_16BIT 1 ------------------ | Branch (484:9): [True: 644, False: 4.71k] ------------------ 485| 871k| for(i = 0; i < frame_len; i++) ------------------ | Branch (485:24): [True: 870k, False: 644] ------------------ 486| 870k| { 487| 870k| int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix, 488| 870k| hDecoder->internal_channel); 489| 870k| if (tmp >= 0) ------------------ | Branch (489:21): [True: 681k, False: 189k] ------------------ 490| 681k| { 491| 681k| tmp += (1 << (REAL_BITS-1)); ------------------ | | 45| 681k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 492| 681k| if (tmp >= REAL_CONST(32767)) ------------------ | | 59| 681k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 681k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 681k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 681k, Folded] | | ------------------ ------------------ | Branch (492:25): [True: 5.77k, False: 675k] ------------------ 493| 5.77k| { 494| 5.77k| tmp = REAL_CONST(32767); ------------------ | | 59| 5.77k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 5.77k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 5.77k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 5.77k, Folded] | | ------------------ ------------------ 495| 5.77k| } 496| 681k| } else { 497| 189k| tmp += -(1 << (REAL_BITS-1)); ------------------ | | 45| 189k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 498| 189k| if (tmp <= REAL_CONST(-32768)) ------------------ | | 59| 189k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 189k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 189k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [Folded, False: 189k] | | ------------------ ------------------ | Branch (498:25): [True: 5.87k, False: 183k] ------------------ 499| 5.87k| { 500| 5.87k| tmp = REAL_CONST(-32768); ------------------ | | 59| 5.87k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 5.87k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 5.87k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [Folded, False: 5.87k] | | ------------------ ------------------ 501| 5.87k| } 502| 189k| } 503| 870k| tmp >>= REAL_BITS; ------------------ | | 45| 870k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 504| 870k| short_sample_buffer[(i*channels)+ch] = (int16_t)tmp; 505| 870k| } 506| 644| break; 507| 1.49k| case FAAD_FMT_24BIT: ------------------ | | 99| 1.49k|#define FAAD_FMT_24BIT 2 ------------------ | Branch (507:9): [True: 1.49k, False: 3.85k] ------------------ 508| 2.20M| for(i = 0; i < frame_len; i++) ------------------ | Branch (508:24): [True: 2.20M, False: 1.49k] ------------------ 509| 2.20M| { 510| 2.20M| int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix, 511| 2.20M| hDecoder->internal_channel); 512| 2.20M| if (tmp >= 0) ------------------ | Branch (512:21): [True: 2.01M, False: 187k] ------------------ 513| 2.01M| { 514| 2.01M| tmp += (1 << (REAL_BITS-9)); ------------------ | | 45| 2.01M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 515| 2.01M| tmp >>= (REAL_BITS-8); ------------------ | | 45| 2.01M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 516| 2.01M| if (tmp >= 8388607) ------------------ | Branch (516:25): [True: 4.56k, False: 2.01M] ------------------ 517| 4.56k| { 518| 4.56k| tmp = 8388607; 519| 4.56k| } 520| 2.01M| } else { 521| 187k| tmp += -(1 << (REAL_BITS-9)); ------------------ | | 45| 187k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 522| 187k| tmp >>= (REAL_BITS-8); ------------------ | | 45| 187k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 523| 187k| if (tmp <= -8388608) ------------------ | Branch (523:25): [True: 4.47k, False: 183k] ------------------ 524| 4.47k| { 525| 4.47k| tmp = -8388608; 526| 4.47k| } 527| 187k| } 528| 2.20M| int_sample_buffer[(i*channels)+ch] = (int32_t)tmp; 529| 2.20M| } 530| 1.49k| break; 531| 1.10k| case FAAD_FMT_32BIT: ------------------ | | 100| 1.10k|#define FAAD_FMT_32BIT 3 ------------------ | Branch (531:9): [True: 1.10k, False: 4.24k] ------------------ 532| 1.10k| exp = 16 - REAL_BITS; ------------------ | | 45| 1.10k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 533| 1.10k| half = 1 << (exp - 1); 534| 1.10k| sat_shift_mask = SAT_SHIFT_MASK(exp); ------------------ | | 286| 1.10k|#define SAT_SHIFT_MASK(E) (~0u << (31u - (E))) ------------------ 535| 1.32M| for(i = 0; i < frame_len; i++) ------------------ | Branch (535:24): [True: 1.32M, False: 1.10k] ------------------ 536| 1.32M| { 537| 1.32M| int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix, 538| 1.32M| hDecoder->internal_channel); 539| 1.32M| if (tmp >= 0) ------------------ | Branch (539:21): [True: 1.27M, False: 45.2k] ------------------ 540| 1.27M| { 541| 1.27M| tmp += half; 542| 1.27M| } else { 543| 45.2k| tmp += -half; 544| 45.2k| } 545| 1.32M| tmp = SAT_SHIFT(tmp, exp, sat_shift_mask); ------------------ | | 287| 1.32M|#define SAT_SHIFT(V,E,M) (((((V) >> ((E) + 1)) ^ (V)) & (M)) \ | | ------------------ | | | Branch (287:27): [True: 4.41k, False: 1.31M] | | ------------------ | | 288| 1.32M| ? (((V) < 0) ? (int32_t)0x80000000 : 0x7FFFFFFF) \ | | ------------------ | | | Branch (288:8): [True: 2.24k, False: 2.16k] | | ------------------ | | 289| 1.32M| : ((int32_t)((uint32_t)(V) << (E)))) ------------------ 546| 1.32M| int_sample_buffer[(i*channels)+ch] = tmp; 547| 1.32M| } 548| 1.10k| break; 549| 2.10k| case FAAD_FMT_FIXED: ------------------ | | 102| 2.10k|#define FAAD_FMT_FIXED FAAD_FMT_FLOAT | | ------------------ | | | | 101| 2.10k|#define FAAD_FMT_FLOAT 4 | | ------------------ ------------------ | Branch (549:9): [True: 2.10k, False: 3.24k] ------------------ 550| 3.17M| for(i = 0; i < frame_len; i++) ------------------ | Branch (550:24): [True: 3.17M, False: 2.10k] ------------------ 551| 3.17M| { 552| 3.17M| real_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix, 553| 3.17M| hDecoder->internal_channel); 554| 3.17M| int_sample_buffer[(i*channels)+ch] = (int32_t)tmp; 555| 3.17M| } 556| 2.10k| break; 557| 5.35k| } 558| 5.35k| } 559| | 560| 385| return sample_buffer; 561| 385|} output.c:get_sample: 448| 7.57M|{ 449| 7.57M| real_t C; 450| 7.57M| if (up_matrix == 1) ------------------ | Branch (450:9): [True: 0, False: 7.57M] ------------------ 451| 0| return input[internal_channel[0]][sample]; 452| | 453| 7.57M| if (!down_matrix) ------------------ | Branch (453:9): [True: 7.39M, False: 181k] ------------------ 454| 7.39M| return input[internal_channel[channel]][sample]; 455| | 456| 181k| C = MUL_F(input[internal_channel[0]][sample], BOTH); ------------------ | | 268| 726k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 181k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 181k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 181k, Folded] | | | Branch (268:55): [Folded, False: 181k] | | ------------------ ------------------ 457| 181k| if (channel == 0) ------------------ | Branch (457:9): [True: 90.7k, False: 90.7k] ------------------ 458| 90.7k| { 459| 90.7k| real_t L_S = MUL_F(input[internal_channel[3]][sample], BOTH); ------------------ | | 268| 363k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 90.7k, Folded] | | | Branch (268:55): [Folded, False: 90.7k] | | ------------------ ------------------ 460| 90.7k| real_t core = MUL_F(input[internal_channel[1]][sample], DM_MUL); ------------------ | | 268| 363k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 90.7k, Folded] | | | Branch (268:55): [Folded, False: 90.7k] | | ------------------ ------------------ 461| 90.7k| return core + C + L_S; 462| 90.7k| } else { 463| 90.7k| real_t R_S = MUL_F(input[internal_channel[4]][sample], BOTH); ------------------ | | 268| 363k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 90.7k, Folded] | | | Branch (268:55): [Folded, False: 90.7k] | | ------------------ ------------------ 464| 90.7k| real_t core = MUL_F(input[internal_channel[2]][sample], DM_MUL); ------------------ | | 268| 363k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 90.7k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 90.7k, Folded] | | | Branch (268:55): [Folded, False: 90.7k] | | ------------------ ------------------ 465| 90.7k| return core + C + R_S; 466| 90.7k| } 467| 181k|} pns_decode: 154| 36.4k|{ 155| 36.4k| uint8_t g, sfb, b; 156| 36.4k| uint16_t begin, end; 157| | 158| 36.4k| uint8_t group = 0; 159| 36.4k| uint16_t nshort = frame_len >> 3; 160| | 161| 36.4k| uint8_t sub = 0; 162| | 163| 36.4k|#ifdef FIXED_POINT 164| | /* IMDCT scaling */ 165| 36.4k| if (object_type == LD) ------------------ | | 45| 36.4k|#define LD 23 ------------------ | Branch (165:9): [True: 0, False: 36.4k] ------------------ 166| 0| { 167| 0| sub = 9 /*9*/; 168| 36.4k| } else { 169| 36.4k| if (ics_left->window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 36.4k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (169:13): [True: 8.72k, False: 27.7k] ------------------ 170| 8.72k| sub = 7 /*7*/; 171| 27.7k| else 172| 27.7k| sub = 10 /*10*/; 173| 36.4k| } 174| |#else 175| | (void)object_type; 176| |#endif 177| | 178| 123k| for (g = 0; g < ics_left->num_window_groups; g++) ------------------ | Branch (178:17): [True: 87.2k, False: 36.4k] ------------------ 179| 87.2k| { 180| | /* Do perceptual noise substitution decoding */ 181| 184k| for (b = 0; b < ics_left->window_group_length[g]; b++) ------------------ | Branch (181:21): [True: 97.5k, False: 87.2k] ------------------ 182| 97.5k| { 183| 97.5k| uint16_t base = group * nshort; 184| 133k| for (sfb = 0; sfb < ics_left->max_sfb; sfb++) ------------------ | Branch (184:27): [True: 36.1k, False: 97.5k] ------------------ 185| 36.1k| { 186| 36.1k| uint32_t r1_dep = 0, r2_dep = 0; 187| | 188| 36.1k| if (is_noise(ics_left, g, sfb)) ------------------ | Branch (188:21): [True: 0, False: 36.1k] ------------------ 189| 0| { 190| |#ifdef LTP_DEC 191| | /* Simultaneous use of LTP and PNS is not prevented in the 192| | syntax. If both LTP, and PNS are enabled on the same 193| | scalefactor band, PNS takes precedence, and no prediction 194| | is applied to this band. 195| | */ 196| | ics_left->ltp.long_used[sfb] = 0; 197| | ics_left->ltp2.long_used[sfb] = 0; 198| |#endif 199| | 200| |#ifdef MAIN_DEC 201| | /* For scalefactor bands coded using PNS the corresponding 202| | predictors are switched to "off". 203| | */ 204| | ics_left->pred.prediction_used[sfb] = 0; 205| |#endif 206| 0| begin = min(base + ics_left->swb_offset[sfb], ics_left->swb_offset_max); ------------------ | | 60| 0|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 0] | | ------------------ ------------------ 207| 0| end = min(base + ics_left->swb_offset[sfb+1], ics_left->swb_offset_max); ------------------ | | 60| 0|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 0] | | ------------------ ------------------ 208| | 209| 0| r1_dep = *__r1; 210| 0| r2_dep = *__r2; 211| | 212| | /* Generate random vector */ 213| 0| gen_rand_vector(&spec_left[begin], 214| 0| ics_left->scale_factors[g][sfb], end - begin, sub, __r1, __r2); 215| 0| } 216| | 217| |/* From the spec: 218| | If the same scalefactor band and group is coded by perceptual noise 219| | substitution in both channels of a channel pair, the correlation of 220| | the noise signal can be controlled by means of the ms_used field: While 221| | the default noise generation process works independently for each channel 222| | (separate generation of random vectors), the same random vector is used 223| | for both channels if ms_used[] is set for a particular scalefactor band 224| | and group. In this case, no M/S stereo coding is carried out (because M/S 225| | stereo coding and noise substitution coding are mutually exclusive). 226| | If the same scalefactor band and group is coded by perceptual noise 227| | substitution in only one channel of a channel pair the setting of ms_used[] 228| | is not evaluated. 229| |*/ 230| 36.1k| if ((ics_right != NULL) ------------------ | Branch (230:21): [True: 17.6k, False: 18.5k] ------------------ 231| 17.6k| && is_noise(ics_right, g, sfb)) ------------------ | Branch (231:24): [True: 0, False: 17.6k] ------------------ 232| 0| { 233| |#ifdef LTP_DEC 234| | /* See comment above. */ 235| | ics_right->ltp.long_used[sfb] = 0; 236| | ics_right->ltp2.long_used[sfb] = 0; 237| |#endif 238| |#ifdef MAIN_DEC 239| | /* See comment above. */ 240| | ics_right->pred.prediction_used[sfb] = 0; 241| |#endif 242| | 243| 0| if (channel_pair && is_noise(ics_left, g, sfb) && ------------------ | Branch (243:25): [True: 0, False: 0] | Branch (243:41): [True: 0, False: 0] ------------------ 244| 0| (((ics_left->ms_mask_present == 1) && ------------------ | Branch (244:27): [True: 0, False: 0] ------------------ 245| 0| (ics_left->ms_used[g][sfb])) || ------------------ | Branch (245:25): [True: 0, False: 0] ------------------ 246| 0| (ics_left->ms_mask_present == 2))) ------------------ | Branch (246:25): [True: 0, False: 0] ------------------ 247| 0| { 248| | /*uint16_t c;*/ 249| | 250| 0| begin = min(base + ics_right->swb_offset[sfb], ics_right->swb_offset_max); ------------------ | | 60| 0|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 0] | | ------------------ ------------------ 251| 0| end = min(base + ics_right->swb_offset[sfb+1], ics_right->swb_offset_max); ------------------ | | 60| 0|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 0] | | ------------------ ------------------ 252| | 253| | /* Generate random vector dependent on left channel*/ 254| 0| gen_rand_vector(&spec_right[begin], 255| 0| ics_right->scale_factors[g][sfb], end - begin, sub, &r1_dep, &r2_dep); 256| | 257| 0| } else /*if (ics_left->ms_mask_present == 0)*/ { 258| 0| begin = min(base + ics_right->swb_offset[sfb], ics_right->swb_offset_max); ------------------ | | 60| 0|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 0] | | ------------------ ------------------ 259| 0| end = min(base + ics_right->swb_offset[sfb+1], ics_right->swb_offset_max); ------------------ | | 60| 0|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 0] | | ------------------ ------------------ 260| | 261| | /* Generate random vector */ 262| 0| gen_rand_vector(&spec_right[begin], 263| 0| ics_right->scale_factors[g][sfb], end - begin, sub, __r1, __r2); 264| 0| } 265| 0| } 266| 36.1k| } /* sfb */ 267| 97.5k| group++; 268| 97.5k| } /* b */ 269| 87.2k| } /* g */ 270| 36.4k|} specrec.c:is_noise: 48| 2.56M|{ 49| 2.56M| if (ics->sfb_cb[group][sfb] == NOISE_HCB) ------------------ | | 106| 2.56M|#define NOISE_HCB 13 ------------------ | Branch (49:9): [True: 0, False: 2.56M] ------------------ 50| 0| return 1; 51| 2.56M| return 0; 52| 2.56M|} pns.c:is_noise: 48| 53.8k|{ 49| 53.8k| if (ics->sfb_cb[group][sfb] == NOISE_HCB) ------------------ | | 106| 53.8k|#define NOISE_HCB 13 ------------------ | Branch (49:9): [True: 0, False: 53.8k] ------------------ 50| 0| return 1; 51| 53.8k| return 0; 52| 53.8k|} ms.c:is_noise: 48| 5.23k|{ 49| 5.23k| if (ics->sfb_cb[group][sfb] == NOISE_HCB) ------------------ | | 106| 5.23k|#define NOISE_HCB 13 ------------------ | Branch (49:9): [True: 0, False: 5.23k] ------------------ 50| 0| return 1; 51| 5.23k| return 0; 52| 5.23k|} ps_free: 1889| 5.31k|{ 1890| | /* free hybrid filterbank structures */ 1891| 5.31k| hybrid_free(ps->hyb); 1892| | 1893| 5.31k| faad_free(ps); 1894| 5.31k|} ps_init: 1897| 5.31k|{ 1898| 5.31k| uint8_t i; 1899| 5.31k| uint8_t short_delay_band; 1900| | 1901| 5.31k| ps_info *ps = (ps_info*)faad_malloc(sizeof(ps_info)); 1902| 5.31k| memset(ps, 0, sizeof(ps_info)); 1903| | 1904| 5.31k| ps->hyb = hybrid_init(numTimeSlotsRate); 1905| 5.31k| ps->numTimeSlotsRate = numTimeSlotsRate; 1906| | 1907| 5.31k| ps->ps_data_available = 0; 1908| | 1909| | /* delay stuff*/ 1910| 5.31k| ps->saved_delay = 0; 1911| | 1912| 345k| for (i = 0; i < 64; i++) ------------------ | Branch (1912:17): [True: 340k, False: 5.31k] ------------------ 1913| 340k| { 1914| 340k| ps->delay_buf_index_delay[i] = 0; 1915| 340k| } 1916| | 1917| 21.2k| for (i = 0; i < NO_ALLPASS_LINKS; i++) ------------------ | | 43| 21.2k|#define NO_ALLPASS_LINKS 3 ------------------ | Branch (1917:17): [True: 15.9k, False: 5.31k] ------------------ 1918| 15.9k| { 1919| 15.9k| ps->delay_buf_index_ser[i] = 0; 1920| |#ifdef PARAM_32KHZ 1921| | if (sr_index <= 5) /* >= 32 kHz*/ 1922| | { 1923| | ps->num_sample_delay_ser[i] = delay_length_d[1][i]; 1924| | } else { 1925| | ps->num_sample_delay_ser[i] = delay_length_d[0][i]; 1926| | } 1927| |#else 1928| 15.9k| (void)sr_index; 1929| | /* THESE ARE CONSTANTS NOW */ 1930| 15.9k| ps->num_sample_delay_ser[i] = delay_length_d[i]; 1931| 15.9k|#endif 1932| 15.9k| } 1933| | 1934| |#ifdef PARAM_32KHZ 1935| | if (sr_index <= 5) /* >= 32 kHz*/ 1936| | { 1937| | short_delay_band = 35; 1938| | ps->nr_allpass_bands = 22; 1939| | ps->alpha_decay = FRAC_CONST(0.76592833836465); 1940| | ps->alpha_smooth = FRAC_CONST(0.25); 1941| | } else { 1942| | short_delay_band = 64; 1943| | ps->nr_allpass_bands = 45; 1944| | ps->alpha_decay = FRAC_CONST(0.58664621951003); 1945| | ps->alpha_smooth = FRAC_CONST(0.6); 1946| | } 1947| |#else 1948| | /* THESE ARE CONSTANTS NOW */ 1949| 5.31k| short_delay_band = 35; 1950| 5.31k| ps->nr_allpass_bands = 22; 1951| 5.31k| ps->alpha_decay = FRAC_CONST(0.76592833836465); ------------------ | | 61| 5.31k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 5.31k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 5.31k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 5.31k] | | | Branch (61:62): [True: 5.31k, Folded] | | ------------------ ------------------ 1952| 5.31k| ps->alpha_smooth = FRAC_CONST(0.25); ------------------ | | 61| 5.31k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 5.31k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 5.31k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 5.31k] | | | Branch (61:62): [True: 5.31k, Folded] | | ------------------ ------------------ 1953| 5.31k|#endif 1954| | 1955| | /* THESE ARE CONSTANT NOW IF PS IS INDEPENDANT OF SAMPLERATE */ 1956| 191k| for (i = 0; i < short_delay_band; i++) ------------------ | Branch (1956:17): [True: 185k, False: 5.31k] ------------------ 1957| 185k| { 1958| 185k| ps->delay_D[i] = 14; 1959| 185k| } 1960| 159k| for (i = short_delay_band; i < 64; i++) ------------------ | Branch (1960:32): [True: 154k, False: 5.31k] ------------------ 1961| 154k| { 1962| 154k| ps->delay_D[i] = 1; 1963| 154k| } 1964| | 1965| | /* mixing and phase */ 1966| 270k| for (i = 0; i < 50; i++) ------------------ | Branch (1966:17): [True: 265k, False: 5.31k] ------------------ 1967| 265k| { 1968| 265k| RE(ps->h11_prev[i]) = 1; ------------------ | | 391| 265k|#define RE(A) (A)[0] ------------------ 1969| 265k| IM(ps->h11_prev[i]) = 1; ------------------ | | 392| 265k|#define IM(A) (A)[1] ------------------ 1970| 265k| RE(ps->h12_prev[i]) = 1; ------------------ | | 391| 265k|#define RE(A) (A)[0] ------------------ 1971| 265k| IM(ps->h12_prev[i]) = 1; ------------------ | | 392| 265k|#define IM(A) (A)[1] ------------------ 1972| 265k| } 1973| | 1974| 5.31k| ps->phase_hist = 0; 1975| | 1976| 111k| for (i = 0; i < 20; i++) ------------------ | Branch (1976:17): [True: 106k, False: 5.31k] ------------------ 1977| 106k| { 1978| 106k| RE(ps->ipd_prev[i][0]) = 0; ------------------ | | 391| 106k|#define RE(A) (A)[0] ------------------ 1979| 106k| IM(ps->ipd_prev[i][0]) = 0; ------------------ | | 392| 106k|#define IM(A) (A)[1] ------------------ 1980| 106k| RE(ps->ipd_prev[i][1]) = 0; ------------------ | | 391| 106k|#define RE(A) (A)[0] ------------------ 1981| 106k| IM(ps->ipd_prev[i][1]) = 0; ------------------ | | 392| 106k|#define IM(A) (A)[1] ------------------ 1982| 106k| RE(ps->opd_prev[i][0]) = 0; ------------------ | | 391| 106k|#define RE(A) (A)[0] ------------------ 1983| 106k| IM(ps->opd_prev[i][0]) = 0; ------------------ | | 392| 106k|#define IM(A) (A)[1] ------------------ 1984| 106k| RE(ps->opd_prev[i][1]) = 0; ------------------ | | 391| 106k|#define RE(A) (A)[0] ------------------ 1985| 106k| IM(ps->opd_prev[i][1]) = 0; ------------------ | | 392| 106k|#define IM(A) (A)[1] ------------------ 1986| 106k| } 1987| | 1988| 5.31k| return ps; 1989| 5.31k|} ps_decode: 1993| 3.76k|{ 1994| 3.76k| qmf_t X_hybrid_left[32][32] = {{{0}}}; ------------------ | | 167| 3.76k|#define qmf_t complex_t ------------------ 1995| 3.76k| qmf_t X_hybrid_right[32][32] = {{{0}}}; ------------------ | | 167| 3.76k|#define qmf_t complex_t ------------------ 1996| | 1997| | /* delta decoding of the bitstream data */ 1998| 3.76k| ps_data_decode(ps); 1999| | 2000| | /* set up some parameters depending on filterbank type */ 2001| 3.76k| if (ps->use34hybrid_bands) ------------------ | Branch (2001:9): [True: 1.40k, False: 2.36k] ------------------ 2002| 1.40k| { 2003| 1.40k| ps->group_border = (uint8_t*)group_border34; 2004| 1.40k| ps->map_group2bk = (uint16_t*)map_group2bk34; 2005| 1.40k| ps->num_groups = 32+18; 2006| 1.40k| ps->num_hybrid_groups = 32; 2007| 1.40k| ps->nr_par_bands = 34; 2008| 1.40k| ps->decay_cutoff = 5; 2009| 2.36k| } else { 2010| 2.36k| ps->group_border = (uint8_t*)group_border20; 2011| 2.36k| ps->map_group2bk = (uint16_t*)map_group2bk20; 2012| 2.36k| ps->num_groups = 10+12; 2013| 2.36k| ps->num_hybrid_groups = 10; 2014| 2.36k| ps->nr_par_bands = 20; 2015| 2.36k| ps->decay_cutoff = 3; 2016| 2.36k| } 2017| | 2018| | /* Perform further analysis on the lowest subbands to get a higher 2019| | * frequency resolution 2020| | */ 2021| 3.76k| hybrid_analysis((hyb_info*)ps->hyb, X_left, X_hybrid_left, 2022| 3.76k| ps->use34hybrid_bands, ps->numTimeSlotsRate); 2023| | 2024| | /* decorrelate mono signal */ 2025| 3.76k| ps_decorrelate(ps, X_left, X_right, X_hybrid_left, X_hybrid_right); 2026| | 2027| | /* apply mixing and phase parameters */ 2028| 3.76k| ps_mix_phase(ps, X_left, X_right, X_hybrid_left, X_hybrid_right); 2029| | 2030| | /* hybrid synthesis, to rebuild the SBR QMF matrices */ 2031| 3.76k| hybrid_synthesis((hyb_info*)ps->hyb, X_left, X_hybrid_left, 2032| 3.76k| ps->use34hybrid_bands, ps->numTimeSlotsRate); 2033| | 2034| 3.76k| hybrid_synthesis((hyb_info*)ps->hyb, X_right, X_hybrid_right, 2035| 3.76k| ps->use34hybrid_bands, ps->numTimeSlotsRate); 2036| | 2037| 3.76k| return 0; 2038| 3.76k|} ps_dec.c:hybrid_free: 234| 5.31k|{ 235| 5.31k| uint8_t i; 236| | 237| 5.31k| if (!hyb) return; ------------------ | Branch (237:6): [True: 0, False: 5.31k] ------------------ 238| | 239| 5.31k| if (hyb->work) ------------------ | Branch (239:9): [True: 5.31k, False: 0] ------------------ 240| 5.31k| faad_free(hyb->work); 241| | 242| 31.8k| for (i = 0; i < 5; i++) ------------------ | Branch (242:17): [True: 26.5k, False: 5.31k] ------------------ 243| 26.5k| { 244| 26.5k| if (hyb->buffer[i]) ------------------ | Branch (244:13): [True: 26.5k, False: 0] ------------------ 245| 26.5k| faad_free(hyb->buffer[i]); 246| 26.5k| } 247| 5.31k| if (hyb->buffer) ------------------ | Branch (247:9): [True: 5.31k, False: 0] ------------------ 248| 5.31k| faad_free(hyb->buffer); 249| | 250| 173k| for (i = 0; i < hyb->frame_len; i++) ------------------ | Branch (250:17): [True: 168k, False: 5.31k] ------------------ 251| 168k| { 252| 168k| if (hyb->temp[i]) ------------------ | Branch (252:13): [True: 168k, False: 0] ------------------ 253| 168k| faad_free(hyb->temp[i]); 254| 168k| } 255| 5.31k| if (hyb->temp) ------------------ | Branch (255:9): [True: 5.31k, False: 0] ------------------ 256| 5.31k| faad_free(hyb->temp); 257| | 258| 5.31k| faad_free(hyb); 259| 5.31k|} ps_dec.c:hybrid_init: 197| 5.31k|{ 198| 5.31k| uint8_t i; 199| | 200| 5.31k| hyb_info *hyb = (hyb_info*)faad_malloc(sizeof(hyb_info)); 201| | 202| 5.31k| hyb->resolution34[0] = 12; 203| 5.31k| hyb->resolution34[1] = 8; 204| 5.31k| hyb->resolution34[2] = 4; 205| 5.31k| hyb->resolution34[3] = 4; 206| 5.31k| hyb->resolution34[4] = 4; 207| | 208| 5.31k| hyb->resolution20[0] = 8; 209| 5.31k| hyb->resolution20[1] = 2; 210| 5.31k| hyb->resolution20[2] = 2; 211| | 212| 5.31k| hyb->frame_len = numTimeSlotsRate; 213| | 214| 5.31k| hyb->work = (qmf_t*)faad_malloc((hyb->frame_len+12) * sizeof(qmf_t)); 215| 5.31k| memset(hyb->work, 0, (hyb->frame_len+12) * sizeof(qmf_t)); 216| | 217| 5.31k| hyb->buffer = (qmf_t**)faad_malloc(5 * sizeof(qmf_t*)); 218| 31.8k| for (i = 0; i < 5; i++) ------------------ | Branch (218:17): [True: 26.5k, False: 5.31k] ------------------ 219| 26.5k| { 220| 26.5k| hyb->buffer[i] = (qmf_t*)faad_malloc(hyb->frame_len * sizeof(qmf_t)); 221| 26.5k| memset(hyb->buffer[i], 0, hyb->frame_len * sizeof(qmf_t)); 222| 26.5k| } 223| | 224| 5.31k| hyb->temp = (qmf_t**)faad_malloc(hyb->frame_len * sizeof(qmf_t*)); 225| 173k| for (i = 0; i < hyb->frame_len; i++) ------------------ | Branch (225:17): [True: 168k, False: 5.31k] ------------------ 226| 168k| { 227| 168k| hyb->temp[i] = (qmf_t*)faad_malloc(12 /*max*/ * sizeof(qmf_t)); 228| 168k| } 229| | 230| 5.31k| return hyb; 231| 5.31k|} ps_dec.c:ps_data_decode: 808| 3.76k|{ 809| 3.76k| uint8_t env, bin; 810| | 811| | /* ps data not available, use data from previous frame */ 812| 3.76k| if (ps->ps_data_available == 0) ------------------ | Branch (812:9): [True: 916, False: 2.84k] ------------------ 813| 916| { 814| 916| ps->num_env = 0; 815| 916| } 816| | 817| 10.3k| for (env = 0; env < ps->num_env; env++) ------------------ | Branch (817:19): [True: 6.55k, False: 3.76k] ------------------ 818| 6.55k| { 819| 6.55k| int8_t *iid_index_prev; 820| 6.55k| int8_t *icc_index_prev; 821| 6.55k| int8_t *ipd_index_prev; 822| 6.55k| int8_t *opd_index_prev; 823| | 824| 6.55k| int8_t num_iid_steps = (ps->iid_mode < 3) ? 7 : 15 /*fine quant*/; ------------------ | Branch (824:32): [True: 4.02k, False: 2.52k] ------------------ 825| | 826| 6.55k| if (env == 0) ------------------ | Branch (826:13): [True: 1.81k, False: 4.73k] ------------------ 827| 1.81k| { 828| | /* take last envelope from previous frame */ 829| 1.81k| iid_index_prev = ps->iid_index_prev; 830| 1.81k| icc_index_prev = ps->icc_index_prev; 831| 1.81k| ipd_index_prev = ps->ipd_index_prev; 832| 1.81k| opd_index_prev = ps->opd_index_prev; 833| 4.73k| } else { 834| | /* take index values from previous envelope */ 835| 4.73k| iid_index_prev = ps->iid_index[env - 1]; 836| 4.73k| icc_index_prev = ps->icc_index[env - 1]; 837| 4.73k| ipd_index_prev = ps->ipd_index[env - 1]; 838| 4.73k| opd_index_prev = ps->opd_index[env - 1]; 839| 4.73k| } 840| | 841| |// iid = 1; 842| | /* delta decode iid parameters */ 843| 6.55k| delta_decode(ps->enable_iid, ps->iid_index[env], iid_index_prev, 844| 6.55k| ps->iid_dt[env], ps->nr_iid_par, 845| 6.55k| (ps->iid_mode == 0 || ps->iid_mode == 3) ? 2 : 1, ------------------ | Branch (845:14): [True: 3.62k, False: 2.93k] | Branch (845:35): [True: 1.60k, False: 1.32k] ------------------ 846| 6.55k| -num_iid_steps, num_iid_steps); 847| |// iid = 0; 848| | 849| | /* delta decode icc parameters */ 850| 6.55k| delta_decode(ps->enable_icc, ps->icc_index[env], icc_index_prev, 851| 6.55k| ps->icc_dt[env], ps->nr_icc_par, 852| 6.55k| (ps->icc_mode == 0 || ps->icc_mode == 3) ? 2 : 1, ------------------ | Branch (852:14): [True: 3.20k, False: 3.34k] | Branch (852:35): [True: 1.19k, False: 2.15k] ------------------ 853| 6.55k| 0, 7); 854| | 855| | /* delta modulo decode ipd parameters */ 856| 6.55k| delta_modulo_decode(ps->enable_ipdopd, ps->ipd_index[env], ipd_index_prev, 857| 6.55k| ps->ipd_dt[env], ps->nr_ipdopd_par, 1, 7); 858| | 859| | /* delta modulo decode opd parameters */ 860| 6.55k| delta_modulo_decode(ps->enable_ipdopd, ps->opd_index[env], opd_index_prev, 861| 6.55k| ps->opd_dt[env], ps->nr_ipdopd_par, 1, 7); 862| 6.55k| } 863| | 864| | /* handle error case */ 865| 3.76k| if (ps->num_env == 0) ------------------ | Branch (865:9): [True: 1.94k, False: 1.81k] ------------------ 866| 1.94k| { 867| | /* force to 1 */ 868| 1.94k| ps->num_env = 1; 869| | 870| 1.94k| if (ps->enable_iid) ------------------ | Branch (870:13): [True: 1.64k, False: 294] ------------------ 871| 1.64k| { 872| 57.6k| for (bin = 0; bin < 34; bin++) ------------------ | Branch (872:27): [True: 56.0k, False: 1.64k] ------------------ 873| 56.0k| ps->iid_index[0][bin] = ps->iid_index_prev[bin]; 874| 1.64k| } else { 875| 10.2k| for (bin = 0; bin < 34; bin++) ------------------ | Branch (875:27): [True: 9.99k, False: 294] ------------------ 876| 9.99k| ps->iid_index[0][bin] = 0; 877| 294| } 878| | 879| 1.94k| if (ps->enable_icc) ------------------ | Branch (879:13): [True: 886, False: 1.05k] ------------------ 880| 886| { 881| 31.0k| for (bin = 0; bin < 34; bin++) ------------------ | Branch (881:27): [True: 30.1k, False: 886] ------------------ 882| 30.1k| ps->icc_index[0][bin] = ps->icc_index_prev[bin]; 883| 1.05k| } else { 884| 36.9k| for (bin = 0; bin < 34; bin++) ------------------ | Branch (884:27): [True: 35.9k, False: 1.05k] ------------------ 885| 35.9k| ps->icc_index[0][bin] = 0; 886| 1.05k| } 887| | 888| 1.94k| if (ps->enable_ipdopd) ------------------ | Branch (888:13): [True: 331, False: 1.61k] ------------------ 889| 331| { 890| 5.95k| for (bin = 0; bin < 17; bin++) ------------------ | Branch (890:27): [True: 5.62k, False: 331] ------------------ 891| 5.62k| { 892| 5.62k| ps->ipd_index[0][bin] = ps->ipd_index_prev[bin]; 893| 5.62k| ps->opd_index[0][bin] = ps->opd_index_prev[bin]; 894| 5.62k| } 895| 1.61k| } else { 896| 28.9k| for (bin = 0; bin < 17; bin++) ------------------ | Branch (896:27): [True: 27.3k, False: 1.61k] ------------------ 897| 27.3k| { 898| 27.3k| ps->ipd_index[0][bin] = 0; 899| 27.3k| ps->opd_index[0][bin] = 0; 900| 27.3k| } 901| 1.61k| } 902| 1.94k| } 903| | 904| | /* update previous indices */ 905| 131k| for (bin = 0; bin < 34; bin++) ------------------ | Branch (905:19): [True: 127k, False: 3.76k] ------------------ 906| 127k| ps->iid_index_prev[bin] = ps->iid_index[ps->num_env-1][bin]; 907| 131k| for (bin = 0; bin < 34; bin++) ------------------ | Branch (907:19): [True: 127k, False: 3.76k] ------------------ 908| 127k| ps->icc_index_prev[bin] = ps->icc_index[ps->num_env-1][bin]; 909| 67.6k| for (bin = 0; bin < 17; bin++) ------------------ | Branch (909:19): [True: 63.9k, False: 3.76k] ------------------ 910| 63.9k| { 911| 63.9k| ps->ipd_index_prev[bin] = ps->ipd_index[ps->num_env-1][bin]; 912| 63.9k| ps->opd_index_prev[bin] = ps->opd_index[ps->num_env-1][bin]; 913| 63.9k| } 914| | 915| 3.76k| ps->ps_data_available = 0; 916| | 917| 3.76k| if (ps->frame_class == 0) ------------------ | Branch (917:9): [True: 2.13k, False: 1.62k] ------------------ 918| 2.13k| { 919| 2.13k| ps->border_position[0] = 0; 920| 3.36k| for (env = 1; env < ps->num_env; env++) ------------------ | Branch (920:23): [True: 1.22k, False: 2.13k] ------------------ 921| 1.22k| { 922| 1.22k| ps->border_position[env] = (env * ps->numTimeSlotsRate) / ps->num_env; 923| 1.22k| } 924| 2.13k| ps->border_position[ps->num_env] = ps->numTimeSlotsRate; 925| 2.13k| } else { 926| 1.62k| ps->border_position[0] = 0; 927| | 928| 1.62k| if (ps->border_position[ps->num_env] < ps->numTimeSlotsRate) ------------------ | Branch (928:13): [True: 1.26k, False: 364] ------------------ 929| 1.26k| { 930| 44.2k| for (bin = 0; bin < 34; bin++) ------------------ | Branch (930:27): [True: 42.9k, False: 1.26k] ------------------ 931| 42.9k| { 932| 42.9k| ps->iid_index[ps->num_env][bin] = ps->iid_index[ps->num_env-1][bin]; 933| 42.9k| ps->icc_index[ps->num_env][bin] = ps->icc_index[ps->num_env-1][bin]; 934| 42.9k| } 935| 22.7k| for (bin = 0; bin < 17; bin++) ------------------ | Branch (935:27): [True: 21.4k, False: 1.26k] ------------------ 936| 21.4k| { 937| 21.4k| ps->ipd_index[ps->num_env][bin] = ps->ipd_index[ps->num_env-1][bin]; 938| 21.4k| ps->opd_index[ps->num_env][bin] = ps->opd_index[ps->num_env-1][bin]; 939| 21.4k| } 940| 1.26k| ps->num_env++; 941| 1.26k| ps->border_position[ps->num_env] = ps->numTimeSlotsRate; 942| 1.26k| } 943| | 944| 6.39k| for (env = 1; env < ps->num_env; env++) ------------------ | Branch (944:23): [True: 4.77k, False: 1.62k] ------------------ 945| 4.77k| { 946| 4.77k| int8_t thr = ps->numTimeSlotsRate - (ps->num_env - env); 947| | 948| 4.77k| if (ps->border_position[env] > thr) ------------------ | Branch (948:17): [True: 1.00k, False: 3.76k] ------------------ 949| 1.00k| { 950| 1.00k| ps->border_position[env] = thr; 951| 3.76k| } else { 952| 3.76k| thr = ps->border_position[env-1]+1; 953| 3.76k| if (ps->border_position[env] < thr) ------------------ | Branch (953:21): [True: 1.89k, False: 1.87k] ------------------ 954| 1.89k| { 955| 1.89k| ps->border_position[env] = thr; 956| 1.89k| } 957| 3.76k| } 958| 4.77k| } 959| 1.62k| } 960| | 961| | /* make sure that the indices of all parameters can be mapped 962| | * to the same hybrid synthesis filterbank 963| | */ 964| |#ifdef PS_LOW_POWER 965| | for (env = 0; env < ps->num_env; env++) 966| | { 967| | if (ps->iid_mode == 2 || ps->iid_mode == 5) 968| | map34indexto20(ps->iid_index[env], 34); 969| | if (ps->icc_mode == 2 || ps->icc_mode == 5) 970| | map34indexto20(ps->icc_index[env], 34); 971| | 972| | /* disable ipd/opd */ 973| | for (bin = 0; bin < 17; bin++) 974| | { 975| | ps->aaIpdIndex[env][bin] = 0; 976| | ps->aaOpdIndex[env][bin] = 0; 977| | } 978| | } 979| |#else 980| 3.76k| if (ps->use34hybrid_bands) ------------------ | Branch (980:9): [True: 1.40k, False: 2.36k] ------------------ 981| 1.40k| { 982| 3.28k| for (env = 0; env < ps->num_env; env++) ------------------ | Branch (982:23): [True: 1.88k, False: 1.40k] ------------------ 983| 1.88k| { 984| 1.88k| if (ps->iid_mode != 2 && ps->iid_mode != 5) ------------------ | Branch (984:17): [True: 1.05k, False: 829] | Branch (984:38): [True: 660, False: 399] ------------------ 985| 660| map20indexto34(ps->iid_index[env], 34); 986| 1.88k| if (ps->icc_mode != 2 && ps->icc_mode != 5) ------------------ | Branch (986:17): [True: 1.10k, False: 780] | Branch (986:38): [True: 856, False: 252] ------------------ 987| 856| map20indexto34(ps->icc_index[env], 34); 988| 1.88k| if (ps->ipd_mode != 2 && ps->ipd_mode != 5) ------------------ | Branch (988:17): [True: 1.05k, False: 829] | Branch (988:38): [True: 660, False: 399] ------------------ 989| 660| { 990| 660| map20indexto34(ps->ipd_index[env], 17); 991| 660| map20indexto34(ps->opd_index[env], 17); 992| 660| } 993| 1.88k| } 994| 1.40k| } 995| 3.76k|#endif 996| | 997| |#if 0 998| | for (env = 0; env < ps->num_env; env++) 999| | { 1000| | printf("iid[env:%d]:", env); 1001| | for (bin = 0; bin < 34; bin++) 1002| | { 1003| | printf(" %d", ps->iid_index[env][bin]); 1004| | } 1005| | printf("\n"); 1006| | } 1007| | for (env = 0; env < ps->num_env; env++) 1008| | { 1009| | printf("icc[env:%d]:", env); 1010| | for (bin = 0; bin < 34; bin++) 1011| | { 1012| | printf(" %d", ps->icc_index[env][bin]); 1013| | } 1014| | printf("\n"); 1015| | } 1016| | for (env = 0; env < ps->num_env; env++) 1017| | { 1018| | printf("ipd[env:%d]:", env); 1019| | for (bin = 0; bin < 17; bin++) 1020| | { 1021| | printf(" %d", ps->ipd_index[env][bin]); 1022| | } 1023| | printf("\n"); 1024| | } 1025| | for (env = 0; env < ps->num_env; env++) 1026| | { 1027| | printf("opd[env:%d]:", env); 1028| | for (bin = 0; bin < 17; bin++) 1029| | { 1030| | printf(" %d", ps->opd_index[env][bin]); 1031| | } 1032| | printf("\n"); 1033| | } 1034| | printf("\n"); 1035| |#endif 1036| 3.76k|} ps_dec.c:delta_decode: 629| 13.1k|{ 630| 13.1k| int8_t i; 631| | 632| 13.1k| if (enable == 1) ------------------ | Branch (632:9): [True: 7.01k, False: 6.09k] ------------------ 633| 7.01k| { 634| 7.01k| if (dt_flag == 0) ------------------ | Branch (634:13): [True: 3.92k, False: 3.09k] ------------------ 635| 3.92k| { 636| | /* delta coded in frequency direction */ 637| 3.92k| index[0] = 0 + index[0]; 638| 3.92k| index[0] = delta_clip(index[0], min_index, max_index); 639| | 640| 48.3k| for (i = 1; i < nr_par; i++) ------------------ | Branch (640:25): [True: 44.3k, False: 3.92k] ------------------ 641| 44.3k| { 642| 44.3k| index[i] = index[i-1] + index[i]; 643| 44.3k| index[i] = delta_clip(index[i], min_index, max_index); 644| 44.3k| } 645| 3.92k| } else { 646| | /* delta coded in time direction */ 647| 28.9k| for (i = 0; i < nr_par; i++) ------------------ | Branch (647:25): [True: 25.8k, False: 3.09k] ------------------ 648| 25.8k| { 649| | //int8_t tmp2; 650| | //int8_t tmp = index[i]; 651| | 652| | //printf("%d %d\n", index_prev[i*stride], index[i]); 653| | //printf("%d\n", index[i]); 654| | 655| 25.8k| index[i] = index_prev[i*stride] + index[i]; 656| | //tmp2 = index[i]; 657| 25.8k| index[i] = delta_clip(index[i], min_index, max_index); 658| | 659| | //if (iid) 660| | //{ 661| | // if (index[i] == 7) 662| | // { 663| | // printf("%d %d %d\n", index_prev[i*stride], tmp, tmp2); 664| | // } 665| | //} 666| 25.8k| } 667| 3.09k| } 668| 7.01k| } else { 669| | /* set indices to zero */ 670| 13.9k| for (i = 0; i < nr_par; i++) ------------------ | Branch (670:21): [True: 7.82k, False: 6.09k] ------------------ 671| 7.82k| { 672| 7.82k| index[i] = 0; 673| 7.82k| } 674| 6.09k| } 675| | 676| | /* coarse */ 677| 13.1k| if (stride == 2) ------------------ | Branch (677:9): [True: 9.63k, False: 3.47k] ------------------ 678| 9.63k| { 679| 82.4k| for (i = (nr_par<<1)-1; i > 0; i--) ------------------ | Branch (679:33): [True: 72.7k, False: 9.63k] ------------------ 680| 72.7k| { 681| 72.7k| index[i] = index[i>>1]; 682| 72.7k| } 683| 9.63k| } 684| 13.1k|} ps_dec.c:delta_clip: 614| 74.1k|{ 615| 74.1k| if (i < min) ------------------ | Branch (615:9): [True: 4.85k, False: 69.3k] ------------------ 616| 4.85k| return min; 617| 69.3k| else if (i > max) ------------------ | Branch (617:14): [True: 550, False: 68.7k] ------------------ 618| 550| return max; 619| 68.7k| else 620| 68.7k| return i; 621| 74.1k|} ps_dec.c:delta_modulo_decode: 691| 13.1k|{ 692| 13.1k| int8_t i; 693| | 694| 13.1k| if (enable == 1) ------------------ | Branch (694:9): [True: 4.69k, False: 8.41k] ------------------ 695| 4.69k| { 696| 4.69k| if (dt_flag == 0) ------------------ | Branch (696:13): [True: 3.14k, False: 1.55k] ------------------ 697| 3.14k| { 698| | /* delta coded in frequency direction */ 699| 3.14k| index[0] = 0 + index[0]; 700| 3.14k| index[0] &= and_modulo; 701| | 702| 15.5k| for (i = 1; i < nr_par; i++) ------------------ | Branch (702:25): [True: 12.3k, False: 3.14k] ------------------ 703| 12.3k| { 704| 12.3k| index[i] = index[i-1] + index[i]; 705| 12.3k| index[i] &= and_modulo; 706| 12.3k| } 707| 3.14k| } else { 708| | /* delta coded in time direction */ 709| 4.33k| for (i = 0; i < nr_par; i++) ------------------ | Branch (709:25): [True: 2.77k, False: 1.55k] ------------------ 710| 2.77k| { 711| 2.77k| index[i] = index_prev[i*stride] + index[i]; 712| 2.77k| index[i] &= and_modulo; 713| 2.77k| } 714| 1.55k| } 715| 8.41k| } else { 716| | /* set indices to zero */ 717| 29.2k| for (i = 0; i < nr_par; i++) ------------------ | Branch (717:21): [True: 20.7k, False: 8.41k] ------------------ 718| 20.7k| { 719| 20.7k| index[i] = 0; 720| 20.7k| } 721| 8.41k| } 722| | 723| | /* coarse */ 724| 13.1k| if (stride == 2) ------------------ | Branch (724:9): [True: 0, False: 13.1k] ------------------ 725| 0| { 726| 0| index[0] = 0; 727| 0| for (i = (nr_par<<1)-1; i > 0; i--) ------------------ | Branch (727:33): [True: 0, False: 0] ------------------ 728| 0| { 729| 0| index[i] = index[i>>1]; 730| 0| } 731| 0| } 732| 13.1k|} ps_dec.c:map20indexto34: 765| 2.83k|{ 766| 2.83k| index[0] = index[0]; 767| 2.83k| index[1] = (index[0] + index[1])/2; 768| 2.83k| index[2] = index[1]; 769| 2.83k| index[3] = index[2]; 770| 2.83k| index[4] = (index[2] + index[3])/2; 771| 2.83k| index[5] = index[3]; 772| 2.83k| index[6] = index[4]; 773| 2.83k| index[7] = index[4]; 774| 2.83k| index[8] = index[5]; 775| 2.83k| index[9] = index[5]; 776| 2.83k| index[10] = index[6]; 777| 2.83k| index[11] = index[7]; 778| 2.83k| index[12] = index[8]; 779| 2.83k| index[13] = index[8]; 780| 2.83k| index[14] = index[9]; 781| 2.83k| index[15] = index[9]; 782| 2.83k| index[16] = index[10]; 783| | 784| 2.83k| if (bins == 34) ------------------ | Branch (784:9): [True: 1.51k, False: 1.32k] ------------------ 785| 1.51k| { 786| 1.51k| index[17] = index[11]; 787| 1.51k| index[18] = index[12]; 788| 1.51k| index[19] = index[13]; 789| 1.51k| index[20] = index[14]; 790| 1.51k| index[21] = index[14]; 791| 1.51k| index[22] = index[15]; 792| 1.51k| index[23] = index[15]; 793| 1.51k| index[24] = index[16]; 794| 1.51k| index[25] = index[16]; 795| 1.51k| index[26] = index[17]; 796| 1.51k| index[27] = index[17]; 797| 1.51k| index[28] = index[18]; 798| 1.51k| index[29] = index[18]; 799| 1.51k| index[30] = index[18]; 800| 1.51k| index[31] = index[18]; 801| 1.51k| index[32] = index[19]; 802| 1.51k| index[33] = index[19]; 803| 1.51k| } 804| 2.83k|} ps_dec.c:hybrid_analysis: 514| 3.76k|{ 515| 3.76k| uint8_t k, n, band; 516| 3.76k| uint8_t offset = 0; 517| 3.76k| uint8_t qmf_bands = (use34) ? 5 : 3; ------------------ | Branch (517:25): [True: 1.40k, False: 2.36k] ------------------ 518| 3.76k| uint8_t *resolution = (use34) ? hyb->resolution34 : hyb->resolution20; ------------------ | Branch (518:27): [True: 1.40k, False: 2.36k] ------------------ 519| | 520| 17.8k| for (band = 0; band < qmf_bands; band++) ------------------ | Branch (520:20): [True: 14.0k, False: 3.76k] ------------------ 521| 14.0k| { 522| | /* build working buffer */ 523| 14.0k| memcpy(hyb->work, hyb->buffer[band], 12 * sizeof(qmf_t)); 524| | 525| | /* add new samples */ 526| 454k| for (n = 0; n < hyb->frame_len; n++) ------------------ | Branch (526:21): [True: 439k, False: 14.0k] ------------------ 527| 439k| { 528| 439k| QMF_RE(hyb->work[12 + n]) = QMF_RE(X[n + 6 /*delay*/][band]); ------------------ | | 168| 439k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 439k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(hyb->work[12 + n]) = QMF_RE(X[n + 6 /*delay*/][band]); ------------------ | | 168| 439k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 439k|#define RE(A) (A)[0] | | ------------------ ------------------ 529| 439k| QMF_IM(hyb->work[12 + n]) = QMF_IM(X[n + 6 /*delay*/][band]); ------------------ | | 169| 439k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 439k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(hyb->work[12 + n]) = QMF_IM(X[n + 6 /*delay*/][band]); ------------------ | | 169| 439k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 439k|#define IM(A) (A)[1] | | ------------------ ------------------ 530| 439k| } 531| | 532| | /* store samples */ 533| 14.0k| memcpy(hyb->buffer[band], hyb->work + hyb->frame_len, 12 * sizeof(qmf_t)); 534| | 535| | 536| 14.0k| switch(resolution[band]) ------------------ | Branch (536:16): [True: 14.0k, False: 0] ------------------ 537| 14.0k| { 538| 4.72k| case 2: ------------------ | Branch (538:9): [True: 4.72k, False: 9.36k] ------------------ 539| | /* Type B real filter, Q[p] = 2 */ 540| 4.72k| channel_filter2(hyb, hyb->frame_len, p2_13_20, hyb->work, hyb->temp); 541| 4.72k| break; 542| 4.20k| case 4: ------------------ | Branch (542:9): [True: 4.20k, False: 9.88k] ------------------ 543| | /* Type A complex filter, Q[p] = 4 */ 544| 4.20k| channel_filter4(hyb, hyb->frame_len, p4_13_34, hyb->work, hyb->temp); 545| 4.20k| break; 546| 3.76k| case 8: ------------------ | Branch (546:9): [True: 3.76k, False: 10.3k] ------------------ 547| | /* Type A complex filter, Q[p] = 8 */ 548| 3.76k| channel_filter8(hyb, hyb->frame_len, (use34) ? p8_13_34 : p8_13_20, ------------------ | Branch (548:50): [True: 1.40k, False: 2.36k] ------------------ 549| 3.76k| hyb->work, hyb->temp); 550| 3.76k| break; 551| 1.40k| case 12: ------------------ | Branch (551:9): [True: 1.40k, False: 12.6k] ------------------ 552| | /* Type A complex filter, Q[p] = 12 */ 553| 1.40k| channel_filter12(hyb, hyb->frame_len, p12_13_34, hyb->work, hyb->temp); 554| 1.40k| break; 555| 14.0k| } 556| | 557| 454k| for (n = 0; n < hyb->frame_len; n++) ------------------ | Branch (557:21): [True: 439k, False: 14.0k] ------------------ 558| 439k| { 559| 2.72M| for (k = 0; k < resolution[band]; k++) ------------------ | Branch (559:25): [True: 2.28M, False: 439k] ------------------ 560| 2.28M| { 561| 2.28M| QMF_RE(X_hybrid[n][offset + k]) = QMF_RE(hyb->temp[n][k]); ------------------ | | 168| 2.28M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 2.28M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_hybrid[n][offset + k]) = QMF_RE(hyb->temp[n][k]); ------------------ | | 168| 2.28M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 2.28M|#define RE(A) (A)[0] | | ------------------ ------------------ 562| 2.28M| QMF_IM(X_hybrid[n][offset + k]) = QMF_IM(hyb->temp[n][k]); ------------------ | | 169| 2.28M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 2.28M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_hybrid[n][offset + k]) = QMF_IM(hyb->temp[n][k]); ------------------ | | 169| 2.28M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 2.28M|#define IM(A) (A)[1] | | ------------------ ------------------ 563| 2.28M| } 564| 439k| } 565| 14.0k| offset += resolution[band]; 566| 14.0k| } 567| | 568| | /* group hybrid channels */ 569| 3.76k| if (!use34) ------------------ | Branch (569:9): [True: 2.36k, False: 1.40k] ------------------ 570| 2.36k| { 571| 76.5k| for (n = 0; n < numTimeSlotsRate; n++) ------------------ | Branch (571:21): [True: 74.1k, False: 2.36k] ------------------ 572| 74.1k| { 573| 74.1k| QMF_RE(X_hybrid[n][3]) += QMF_RE(X_hybrid[n][4]); ------------------ | | 168| 74.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 74.1k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_hybrid[n][3]) += QMF_RE(X_hybrid[n][4]); ------------------ | | 168| 74.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 74.1k|#define RE(A) (A)[0] | | ------------------ ------------------ 574| 74.1k| QMF_IM(X_hybrid[n][3]) += QMF_IM(X_hybrid[n][4]); ------------------ | | 169| 74.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 74.1k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_hybrid[n][3]) += QMF_IM(X_hybrid[n][4]); ------------------ | | 169| 74.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 74.1k|#define IM(A) (A)[1] | | ------------------ ------------------ 575| 74.1k| QMF_RE(X_hybrid[n][4]) = 0; ------------------ | | 168| 74.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 74.1k|#define RE(A) (A)[0] | | ------------------ ------------------ 576| 74.1k| QMF_IM(X_hybrid[n][4]) = 0; ------------------ | | 169| 74.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 74.1k|#define IM(A) (A)[1] | | ------------------ ------------------ 577| | 578| 74.1k| QMF_RE(X_hybrid[n][2]) += QMF_RE(X_hybrid[n][5]); ------------------ | | 168| 74.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 74.1k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_hybrid[n][2]) += QMF_RE(X_hybrid[n][5]); ------------------ | | 168| 74.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 74.1k|#define RE(A) (A)[0] | | ------------------ ------------------ 579| 74.1k| QMF_IM(X_hybrid[n][2]) += QMF_IM(X_hybrid[n][5]); ------------------ | | 169| 74.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 74.1k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_hybrid[n][2]) += QMF_IM(X_hybrid[n][5]); ------------------ | | 169| 74.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 74.1k|#define IM(A) (A)[1] | | ------------------ ------------------ 580| 74.1k| QMF_RE(X_hybrid[n][5]) = 0; ------------------ | | 168| 74.1k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 74.1k|#define RE(A) (A)[0] | | ------------------ ------------------ 581| 74.1k| QMF_IM(X_hybrid[n][5]) = 0; ------------------ | | 169| 74.1k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 74.1k|#define IM(A) (A)[1] | | ------------------ ------------------ 582| 74.1k| } 583| 2.36k| } 584| 3.76k|} ps_dec.c:channel_filter2: 264| 4.72k|{ 265| 4.72k| uint8_t i; 266| 4.72k| (void)hyb; /* TODO: remove parameter? */ 267| | 268| 153k| for (i = 0; i < frame_len; i++) ------------------ | Branch (268:17): [True: 148k, False: 4.72k] ------------------ 269| 148k| { 270| 148k| real_t r0 = MUL_F(filter[0],(QMF_RE(buffer[0+i]) + QMF_RE(buffer[12+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 271| 148k| real_t r1 = MUL_F(filter[1],(QMF_RE(buffer[1+i]) + QMF_RE(buffer[11+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 272| 148k| real_t r2 = MUL_F(filter[2],(QMF_RE(buffer[2+i]) + QMF_RE(buffer[10+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 273| 148k| real_t r3 = MUL_F(filter[3],(QMF_RE(buffer[3+i]) + QMF_RE(buffer[9+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 274| 148k| real_t r4 = MUL_F(filter[4],(QMF_RE(buffer[4+i]) + QMF_RE(buffer[8+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 275| 148k| real_t r5 = MUL_F(filter[5],(QMF_RE(buffer[5+i]) + QMF_RE(buffer[7+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 276| 148k| real_t r6 = MUL_F(filter[6],QMF_RE(buffer[6+i])); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 277| 148k| real_t i0 = MUL_F(filter[0],(QMF_IM(buffer[0+i]) + QMF_IM(buffer[12+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 278| 148k| real_t i1 = MUL_F(filter[1],(QMF_IM(buffer[1+i]) + QMF_IM(buffer[11+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 279| 148k| real_t i2 = MUL_F(filter[2],(QMF_IM(buffer[2+i]) + QMF_IM(buffer[10+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 280| 148k| real_t i3 = MUL_F(filter[3],(QMF_IM(buffer[3+i]) + QMF_IM(buffer[9+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 281| 148k| real_t i4 = MUL_F(filter[4],(QMF_IM(buffer[4+i]) + QMF_IM(buffer[8+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 282| 148k| real_t i5 = MUL_F(filter[5],(QMF_IM(buffer[5+i]) + QMF_IM(buffer[7+i]))); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 283| 148k| real_t i6 = MUL_F(filter[6],QMF_IM(buffer[6+i])); ------------------ | | 268| 148k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 148k|#define FRAC_BITS 31 | | ------------------ ------------------ 284| | 285| | /* q = 0 */ 286| 148k| QMF_RE(X_hybrid[i][0]) = r0 + r1 + r2 + r3 + r4 + r5 + r6; ------------------ | | 168| 148k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 148k|#define RE(A) (A)[0] | | ------------------ ------------------ 287| 148k| QMF_IM(X_hybrid[i][0]) = i0 + i1 + i2 + i3 + i4 + i5 + i6; ------------------ | | 169| 148k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 148k|#define IM(A) (A)[1] | | ------------------ ------------------ 288| | 289| | /* q = 1 */ 290| 148k| QMF_RE(X_hybrid[i][1]) = r0 - r1 + r2 - r3 + r4 - r5 + r6; ------------------ | | 168| 148k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 148k|#define RE(A) (A)[0] | | ------------------ ------------------ 291| 148k| QMF_IM(X_hybrid[i][1]) = i0 - i1 + i2 - i3 + i4 - i5 + i6; ------------------ | | 169| 148k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 148k|#define IM(A) (A)[1] | | ------------------ ------------------ 292| 148k| } 293| 4.72k|} ps_dec.c:channel_filter4: 298| 4.20k|{ 299| 4.20k| uint8_t i; 300| 4.20k| real_t input_re1[2], input_re2[2], input_im1[2], input_im2[2]; 301| 4.20k| (void)hyb; /* TODO: remove parameter? */ 302| | 303| 134k| for (i = 0; i < frame_len; i++) ------------------ | Branch (303:17): [True: 130k, False: 4.20k] ------------------ 304| 130k| { 305| 130k| input_re1[0] = -MUL_F(filter[2], (QMF_RE(buffer[i+2]) + QMF_RE(buffer[i+10]))) + ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 306| 130k| MUL_F(filter[6], QMF_RE(buffer[i+6])); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 307| 130k| input_re1[1] = MUL_F(FRAC_CONST(-0.70710678118655), ------------------ | | 268| 521k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 130k] | | | Branch (268:42): [Folded, False: 130k] | | ------------------ ------------------ 308| 130k| (MUL_F(filter[1], (QMF_RE(buffer[i+1]) + QMF_RE(buffer[i+11]))) + 309| 130k| MUL_F(filter[3], (QMF_RE(buffer[i+3]) + QMF_RE(buffer[i+9]))) - 310| 130k| MUL_F(filter[5], (QMF_RE(buffer[i+5]) + QMF_RE(buffer[i+7]))))); 311| | 312| 130k| input_im1[0] = MUL_F(filter[0], (QMF_IM(buffer[i+0]) - QMF_IM(buffer[i+12]))) - ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 313| 130k| MUL_F(filter[4], (QMF_IM(buffer[i+4]) - QMF_IM(buffer[i+8]))); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 314| 130k| input_im1[1] = MUL_F(FRAC_CONST(0.70710678118655), ------------------ | | 268| 521k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 130k, Folded] | | | Branch (268:42): [Folded, False: 130k] | | ------------------ ------------------ 315| 130k| (MUL_F(filter[1], (QMF_IM(buffer[i+1]) - QMF_IM(buffer[i+11]))) - 316| 130k| MUL_F(filter[3], (QMF_IM(buffer[i+3]) - QMF_IM(buffer[i+9]))) - 317| 130k| MUL_F(filter[5], (QMF_IM(buffer[i+5]) - QMF_IM(buffer[i+7]))))); 318| | 319| 130k| input_re2[0] = MUL_F(filter[0], (QMF_RE(buffer[i+0]) - QMF_RE(buffer[i+12]))) - ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 320| 130k| MUL_F(filter[4], (QMF_RE(buffer[i+4]) - QMF_RE(buffer[i+8]))); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 321| 130k| input_re2[1] = MUL_F(FRAC_CONST(0.70710678118655), ------------------ | | 268| 521k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 130k, Folded] | | | Branch (268:42): [Folded, False: 130k] | | ------------------ ------------------ 322| 130k| (MUL_F(filter[1], (QMF_RE(buffer[i+1]) - QMF_RE(buffer[i+11]))) - 323| 130k| MUL_F(filter[3], (QMF_RE(buffer[i+3]) - QMF_RE(buffer[i+9]))) - 324| 130k| MUL_F(filter[5], (QMF_RE(buffer[i+5]) - QMF_RE(buffer[i+7]))))); 325| | 326| 130k| input_im2[0] = -MUL_F(filter[2], (QMF_IM(buffer[i+2]) + QMF_IM(buffer[i+10]))) + ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 327| 130k| MUL_F(filter[6], QMF_IM(buffer[i+6])); ------------------ | | 268| 130k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ ------------------ 328| 130k| input_im2[1] = MUL_F(FRAC_CONST(-0.70710678118655), ------------------ | | 268| 521k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 130k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 130k] | | | Branch (268:42): [Folded, False: 130k] | | ------------------ ------------------ 329| 130k| (MUL_F(filter[1], (QMF_IM(buffer[i+1]) + QMF_IM(buffer[i+11]))) + 330| 130k| MUL_F(filter[3], (QMF_IM(buffer[i+3]) + QMF_IM(buffer[i+9]))) - 331| 130k| MUL_F(filter[5], (QMF_IM(buffer[i+5]) + QMF_IM(buffer[i+7]))))); 332| | 333| | /* q == 0 */ 334| 130k| QMF_RE(X_hybrid[i][0]) = input_re1[0] + input_re1[1] + input_im1[0] + input_im1[1]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 335| 130k| QMF_IM(X_hybrid[i][0]) = -input_re2[0] - input_re2[1] + input_im2[0] + input_im2[1]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 336| | 337| | /* q == 1 */ 338| 130k| QMF_RE(X_hybrid[i][1]) = input_re1[0] - input_re1[1] - input_im1[0] + input_im1[1]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 339| 130k| QMF_IM(X_hybrid[i][1]) = input_re2[0] - input_re2[1] + input_im2[0] - input_im2[1]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 340| | 341| | /* q == 2 */ 342| 130k| QMF_RE(X_hybrid[i][2]) = input_re1[0] - input_re1[1] + input_im1[0] - input_im1[1]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 343| 130k| QMF_IM(X_hybrid[i][2]) = -input_re2[0] + input_re2[1] + input_im2[0] - input_im2[1]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 344| | 345| | /* q == 3 */ 346| 130k| QMF_RE(X_hybrid[i][3]) = input_re1[0] + input_re1[1] - input_im1[0] - input_im1[1]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 347| 130k| QMF_IM(X_hybrid[i][3]) = input_re2[0] + input_re2[1] + input_im2[0] + input_im2[1]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 348| 130k| } 349| 4.20k|} ps_dec.c:channel_filter8: 373| 3.76k|{ 374| 3.76k| uint8_t i, n; 375| 3.76k| real_t input_re1[4], input_re2[4], input_im1[4], input_im2[4]; 376| 3.76k| real_t x[4]; 377| 3.76k| (void)hyb; /* TODO: remove parameter? */ 378| | 379| 121k| for (i = 0; i < frame_len; i++) ------------------ | Branch (379:17): [True: 117k, False: 3.76k] ------------------ 380| 117k| { 381| 117k| input_re1[0] = MUL_F(filter[6],QMF_RE(buffer[6+i])); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 382| 117k| input_re1[1] = MUL_F(filter[5],(QMF_RE(buffer[5+i]) + QMF_RE(buffer[7+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 383| 117k| input_re1[2] = -MUL_F(filter[0],(QMF_RE(buffer[0+i]) + QMF_RE(buffer[12+i]))) + MUL_F(filter[4],(QMF_RE(buffer[4+i]) + QMF_RE(buffer[8+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_re1[2] = -MUL_F(filter[0],(QMF_RE(buffer[0+i]) + QMF_RE(buffer[12+i]))) + MUL_F(filter[4],(QMF_RE(buffer[4+i]) + QMF_RE(buffer[8+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 384| 117k| input_re1[3] = -MUL_F(filter[1],(QMF_RE(buffer[1+i]) + QMF_RE(buffer[11+i]))) + MUL_F(filter[3],(QMF_RE(buffer[3+i]) + QMF_RE(buffer[9+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_re1[3] = -MUL_F(filter[1],(QMF_RE(buffer[1+i]) + QMF_RE(buffer[11+i]))) + MUL_F(filter[3],(QMF_RE(buffer[3+i]) + QMF_RE(buffer[9+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 385| | 386| 117k| input_im1[0] = MUL_F(filter[5],(QMF_IM(buffer[7+i]) - QMF_IM(buffer[5+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 387| 117k| input_im1[1] = MUL_F(filter[0],(QMF_IM(buffer[12+i]) - QMF_IM(buffer[0+i]))) + MUL_F(filter[4],(QMF_IM(buffer[8+i]) - QMF_IM(buffer[4+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_im1[1] = MUL_F(filter[0],(QMF_IM(buffer[12+i]) - QMF_IM(buffer[0+i]))) + MUL_F(filter[4],(QMF_IM(buffer[8+i]) - QMF_IM(buffer[4+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 388| 117k| input_im1[2] = MUL_F(filter[1],(QMF_IM(buffer[11+i]) - QMF_IM(buffer[1+i]))) + MUL_F(filter[3],(QMF_IM(buffer[9+i]) - QMF_IM(buffer[3+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_im1[2] = MUL_F(filter[1],(QMF_IM(buffer[11+i]) - QMF_IM(buffer[1+i]))) + MUL_F(filter[3],(QMF_IM(buffer[9+i]) - QMF_IM(buffer[3+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 389| 117k| input_im1[3] = MUL_F(filter[2],(QMF_IM(buffer[10+i]) - QMF_IM(buffer[2+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 390| | 391| 588k| for (n = 0; n < 4; n++) ------------------ | Branch (391:21): [True: 470k, False: 117k] ------------------ 392| 470k| { 393| 470k| x[n] = input_re1[n] - input_im1[3-n]; 394| 470k| } 395| 117k| DCT3_4_unscaled(x, x); 396| 117k| QMF_RE(X_hybrid[i][7]) = x[0]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 397| 117k| QMF_RE(X_hybrid[i][5]) = x[2]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 398| 117k| QMF_RE(X_hybrid[i][3]) = x[3]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 399| 117k| QMF_RE(X_hybrid[i][1]) = x[1]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 400| | 401| 588k| for (n = 0; n < 4; n++) ------------------ | Branch (401:21): [True: 470k, False: 117k] ------------------ 402| 470k| { 403| 470k| x[n] = input_re1[n] + input_im1[3-n]; 404| 470k| } 405| 117k| DCT3_4_unscaled(x, x); 406| 117k| QMF_RE(X_hybrid[i][6]) = x[1]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 407| 117k| QMF_RE(X_hybrid[i][4]) = x[3]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 408| 117k| QMF_RE(X_hybrid[i][2]) = x[2]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 409| 117k| QMF_RE(X_hybrid[i][0]) = x[0]; ------------------ | | 168| 117k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 117k|#define RE(A) (A)[0] | | ------------------ ------------------ 410| | 411| 117k| input_im2[0] = MUL_F(filter[6],QMF_IM(buffer[6+i])); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 412| 117k| input_im2[1] = MUL_F(filter[5],(QMF_IM(buffer[5+i]) + QMF_IM(buffer[7+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 413| 117k| input_im2[2] = -MUL_F(filter[0],(QMF_IM(buffer[0+i]) + QMF_IM(buffer[12+i]))) + MUL_F(filter[4],(QMF_IM(buffer[4+i]) + QMF_IM(buffer[8+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_im2[2] = -MUL_F(filter[0],(QMF_IM(buffer[0+i]) + QMF_IM(buffer[12+i]))) + MUL_F(filter[4],(QMF_IM(buffer[4+i]) + QMF_IM(buffer[8+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 414| 117k| input_im2[3] = -MUL_F(filter[1],(QMF_IM(buffer[1+i]) + QMF_IM(buffer[11+i]))) + MUL_F(filter[3],(QMF_IM(buffer[3+i]) + QMF_IM(buffer[9+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_im2[3] = -MUL_F(filter[1],(QMF_IM(buffer[1+i]) + QMF_IM(buffer[11+i]))) + MUL_F(filter[3],(QMF_IM(buffer[3+i]) + QMF_IM(buffer[9+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 415| | 416| 117k| input_re2[0] = MUL_F(filter[5],(QMF_RE(buffer[7+i]) - QMF_RE(buffer[5+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 417| 117k| input_re2[1] = MUL_F(filter[0],(QMF_RE(buffer[12+i]) - QMF_RE(buffer[0+i]))) + MUL_F(filter[4],(QMF_RE(buffer[8+i]) - QMF_RE(buffer[4+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_re2[1] = MUL_F(filter[0],(QMF_RE(buffer[12+i]) - QMF_RE(buffer[0+i]))) + MUL_F(filter[4],(QMF_RE(buffer[8+i]) - QMF_RE(buffer[4+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 418| 117k| input_re2[2] = MUL_F(filter[1],(QMF_RE(buffer[11+i]) - QMF_RE(buffer[1+i]))) + MUL_F(filter[3],(QMF_RE(buffer[9+i]) - QMF_RE(buffer[3+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ input_re2[2] = MUL_F(filter[1],(QMF_RE(buffer[11+i]) - QMF_RE(buffer[1+i]))) + MUL_F(filter[3],(QMF_RE(buffer[9+i]) - QMF_RE(buffer[3+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 419| 117k| input_re2[3] = MUL_F(filter[2],(QMF_RE(buffer[10+i]) - QMF_RE(buffer[2+i]))); ------------------ | | 268| 117k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 117k|#define FRAC_BITS 31 | | ------------------ ------------------ 420| | 421| 588k| for (n = 0; n < 4; n++) ------------------ | Branch (421:21): [True: 470k, False: 117k] ------------------ 422| 470k| { 423| 470k| x[n] = input_im2[n] + input_re2[3-n]; 424| 470k| } 425| 117k| DCT3_4_unscaled(x, x); 426| 117k| QMF_IM(X_hybrid[i][7]) = x[0]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 427| 117k| QMF_IM(X_hybrid[i][5]) = x[2]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 428| 117k| QMF_IM(X_hybrid[i][3]) = x[3]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 429| 117k| QMF_IM(X_hybrid[i][1]) = x[1]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 430| | 431| 588k| for (n = 0; n < 4; n++) ------------------ | Branch (431:21): [True: 470k, False: 117k] ------------------ 432| 470k| { 433| 470k| x[n] = input_im2[n] - input_re2[3-n]; 434| 470k| } 435| 117k| DCT3_4_unscaled(x, x); 436| 117k| QMF_IM(X_hybrid[i][6]) = x[1]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 437| 117k| QMF_IM(X_hybrid[i][4]) = x[3]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 438| 117k| QMF_IM(X_hybrid[i][2]) = x[2]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 439| 117k| QMF_IM(X_hybrid[i][0]) = x[0]; ------------------ | | 169| 117k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 117k|#define IM(A) (A)[1] | | ------------------ ------------------ 440| 117k| } 441| 3.76k|} ps_dec.c:DCT3_4_unscaled: 352| 470k|{ 353| 470k| real_t f0, f1, f2, f3, f4, f5, f6, f7, f8; 354| | 355| 470k| f0 = MUL_F(x[2], FRAC_CONST(0.7071067811865476)); ------------------ | | 268| 1.88M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 470k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 470k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 470k, Folded] | | | Branch (268:55): [Folded, False: 470k] | | ------------------ ------------------ 356| 470k| f1 = x[0] - f0; 357| 470k| f2 = x[0] + f0; 358| 470k| f3 = x[1] + x[3]; 359| 470k| f4 = MUL_C(x[1], COEF_CONST(1.3065629648763766)); ------------------ | | 241| 941k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 470k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 470k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:55): [True: 470k, Folded] | | ------------------ ------------------ 360| 470k| f5 = MUL_F(f3, FRAC_CONST(-0.9238795325112866)); ------------------ | | 268| 1.88M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 470k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 470k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [Folded, False: 470k] | | | Branch (268:55): [Folded, False: 470k] | | ------------------ ------------------ 361| 470k| f6 = MUL_F(x[3], FRAC_CONST(-0.5411961001461967)); ------------------ | | 268| 1.88M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 470k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 470k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [Folded, False: 470k] | | | Branch (268:55): [Folded, False: 470k] | | ------------------ ------------------ 362| 470k| f7 = f4 + f5; 363| 470k| f8 = f6 - f5; 364| 470k| y[3] = f2 - f8; 365| 470k| y[0] = f2 + f8; 366| 470k| y[2] = f1 - f7; 367| 470k| y[1] = f1 + f7; 368| 470k|} ps_dec.c:channel_filter12: 466| 1.40k|{ 467| 1.40k| uint8_t i, n; 468| 1.40k| real_t input_re1[6], input_re2[6], input_im1[6], input_im2[6]; 469| 1.40k| real_t out_re1[6], out_re2[6], out_im1[6], out_im2[6]; 470| 1.40k| (void)hyb; /* TODO: remove parameter? */ 471| | 472| 44.8k| for (i = 0; i < frame_len; i++) ------------------ | Branch (472:17): [True: 43.4k, False: 1.40k] ------------------ 473| 43.4k| { 474| 304k| for (n = 0; n < 6; n++) ------------------ | Branch (474:21): [True: 260k, False: 43.4k] ------------------ 475| 260k| { 476| 260k| if (n == 0) ------------------ | Branch (476:17): [True: 43.4k, False: 217k] ------------------ 477| 43.4k| { 478| 43.4k| input_re1[0] = MUL_F(QMF_RE(buffer[6+i]), filter[6]); ------------------ | | 268| 43.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 479| 43.4k| input_re2[0] = MUL_F(QMF_IM(buffer[6+i]), filter[6]); ------------------ | | 268| 43.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 43.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 480| 217k| } else { 481| 217k| input_re1[6-n] = MUL_F((QMF_RE(buffer[n+i]) + QMF_RE(buffer[12-n+i])), filter[n]); ------------------ | | 268| 217k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 217k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 217k|#define FRAC_BITS 31 | | ------------------ ------------------ 482| 217k| input_re2[6-n] = MUL_F((QMF_IM(buffer[n+i]) + QMF_IM(buffer[12-n+i])), filter[n]); ------------------ | | 268| 217k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 217k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 217k|#define FRAC_BITS 31 | | ------------------ ------------------ 483| 217k| } 484| 260k| input_im2[n] = MUL_F((QMF_RE(buffer[n+i]) - QMF_RE(buffer[12-n+i])), filter[n]); ------------------ | | 268| 260k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 260k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 260k|#define FRAC_BITS 31 | | ------------------ ------------------ 485| 260k| input_im1[n] = MUL_F((QMF_IM(buffer[n+i]) - QMF_IM(buffer[12-n+i])), filter[n]); ------------------ | | 268| 260k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 260k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 260k|#define FRAC_BITS 31 | | ------------------ ------------------ 486| 260k| } 487| | 488| 43.4k| DCT3_6_unscaled(out_re1, input_re1); 489| 43.4k| DCT3_6_unscaled(out_re2, input_re2); 490| | 491| 43.4k| DCT3_6_unscaled(out_im1, input_im1); 492| 43.4k| DCT3_6_unscaled(out_im2, input_im2); 493| | 494| 173k| for (n = 0; n < 6; n += 2) ------------------ | Branch (494:21): [True: 130k, False: 43.4k] ------------------ 495| 130k| { 496| 130k| QMF_RE(X_hybrid[i][n]) = out_re1[n] - out_im1[n]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 497| 130k| QMF_IM(X_hybrid[i][n]) = out_re2[n] + out_im2[n]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 498| 130k| QMF_RE(X_hybrid[i][n+1]) = out_re1[n+1] + out_im1[n+1]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 499| 130k| QMF_IM(X_hybrid[i][n+1]) = out_re2[n+1] - out_im2[n+1]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 500| | 501| 130k| QMF_RE(X_hybrid[i][10-n]) = out_re1[n+1] - out_im1[n+1]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 502| 130k| QMF_IM(X_hybrid[i][10-n]) = out_re2[n+1] + out_im2[n+1]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 503| 130k| QMF_RE(X_hybrid[i][11-n]) = out_re1[n] + out_im1[n]; ------------------ | | 168| 130k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 130k|#define RE(A) (A)[0] | | ------------------ ------------------ 504| 130k| QMF_IM(X_hybrid[i][11-n]) = out_re2[n] - out_im2[n]; ------------------ | | 169| 130k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 130k|#define IM(A) (A)[1] | | ------------------ ------------------ 505| 130k| } 506| 43.4k| } 507| 1.40k|} ps_dec.c:DCT3_6_unscaled: 444| 173k|{ 445| 173k| real_t f0, f1, f2, f3, f4, f5, f6, f7; 446| | 447| 173k| f0 = MUL_F(x[3], FRAC_CONST(0.70710678118655)); ------------------ | | 268| 695k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 173k, Folded] | | | Branch (268:55): [Folded, False: 173k] | | ------------------ ------------------ 448| 173k| f1 = x[0] + f0; 449| 173k| f2 = x[0] - f0; 450| 173k| f3 = MUL_F((x[1] - x[5]), FRAC_CONST(0.70710678118655)); ------------------ | | 268| 695k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 173k, Folded] | | | Branch (268:55): [Folded, False: 173k] | | ------------------ ------------------ 451| 173k| f4 = MUL_F(x[2], FRAC_CONST(0.86602540378444)) + MUL_F(x[4], FRAC_CONST(0.5)); ------------------ | | 268| 695k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 173k, Folded] | | | Branch (268:55): [Folded, False: 173k] | | ------------------ ------------------ f4 = MUL_F(x[2], FRAC_CONST(0.86602540378444)) + MUL_F(x[4], FRAC_CONST(0.5)); ------------------ | | 268| 695k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 173k, Folded] | | | Branch (268:55): [Folded, False: 173k] | | ------------------ ------------------ 452| 173k| f5 = f4 - x[4]; 453| 173k| f6 = MUL_F(x[1], FRAC_CONST(0.96592582628907)) + MUL_F(x[5], FRAC_CONST(0.25881904510252)); ------------------ | | 268| 695k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 173k, Folded] | | | Branch (268:55): [Folded, False: 173k] | | ------------------ ------------------ f6 = MUL_F(x[1], FRAC_CONST(0.96592582628907)) + MUL_F(x[5], FRAC_CONST(0.25881904510252)); ------------------ | | 268| 695k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 173k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 173k, Folded] | | | Branch (268:55): [Folded, False: 173k] | | ------------------ ------------------ 454| 173k| f7 = f6 - f3; 455| 173k| y[0] = f1 + f6 + f4; 456| 173k| y[1] = f2 + f3 - x[4]; 457| 173k| y[2] = f7 + f2 - f5; 458| 173k| y[3] = f1 - f7 - f5; 459| 173k| y[4] = f1 - f3 - x[4]; 460| 173k| y[5] = f2 - f6 + f4; 461| 173k|} ps_dec.c:ps_decorrelate: 1041| 3.76k|{ 1042| 3.76k| uint8_t gr, n, bk; 1043| 3.76k| uint8_t temp_delay = 0; 1044| 3.76k| uint8_t sb, maxsb; 1045| 3.76k| const complex_t *Phi_Fract_SubQmf; 1046| 3.76k| uint8_t temp_delay_ser[NO_ALLPASS_LINKS]; 1047| 3.76k| real_t P_SmoothPeakDecayDiffNrg, nrg; 1048| 3.76k| real_t P[32][34]; 1049| 3.76k| real_t G_TransientRatio[32][34] = {{0}}; 1050| 3.76k| complex_t inputLeft; 1051| | 1052| | 1053| | /* chose hybrid filterbank: 20 or 34 band case */ 1054| 3.76k| if (ps->use34hybrid_bands) ------------------ | Branch (1054:9): [True: 1.40k, False: 2.36k] ------------------ 1055| 1.40k| { 1056| 1.40k| Phi_Fract_SubQmf = Phi_Fract_SubQmf34; 1057| 2.36k| } else{ 1058| 2.36k| Phi_Fract_SubQmf = Phi_Fract_SubQmf20; 1059| 2.36k| } 1060| | 1061| | /* clear the energy values */ 1062| 124k| for (n = 0; n < 32; n++) ------------------ | Branch (1062:17): [True: 120k, False: 3.76k] ------------------ 1063| 120k| { 1064| 4.21M| for (bk = 0; bk < 34; bk++) ------------------ | Branch (1064:22): [True: 4.09M, False: 120k] ------------------ 1065| 4.09M| { 1066| 4.09M| P[n][bk] = 0; 1067| 4.09M| } 1068| 120k| } 1069| | 1070| | /* calculate the energy in each parameter band b(k) */ 1071| 125k| for (gr = 0; gr < ps->num_groups; gr++) ------------------ | Branch (1071:18): [True: 121k, False: 3.76k] ------------------ 1072| 121k| { 1073| | /* select the parameter index b(k) to which this group belongs */ 1074| 121k| bk = (~NEGATE_IPD_MASK) & ps->map_group2bk[gr]; ------------------ | | 41| 121k|#define NEGATE_IPD_MASK (0x1000) ------------------ 1075| | 1076| | /* select the upper subband border for this group */ 1077| 121k| maxsb = (gr < ps->num_hybrid_groups) ? ps->group_border[gr]+1 : ps->group_border[gr+1]; ------------------ | Branch (1077:17): [True: 68.4k, False: 53.5k] ------------------ 1078| | 1079| 417k| for (sb = ps->group_border[gr]; sb < maxsb; sb++) ------------------ | Branch (1079:41): [True: 295k, False: 121k] ------------------ 1080| 295k| { 1081| 9.54M| for (n = ps->border_position[0]; n < ps->border_position[ps->num_env]; n++) ------------------ | Branch (1081:46): [True: 9.24M, False: 295k] ------------------ 1082| 9.24M| { 1083| 9.24M|#ifdef FIXED_POINT 1084| 9.24M| uint32_t in_re, in_im; 1085| 9.24M|#endif 1086| | 1087| | /* input from hybrid subbands or QMF subbands */ 1088| 9.24M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1088:21): [True: 2.13M, False: 7.10M] ------------------ 1089| 2.13M| { 1090| 2.13M| RE(inputLeft) = QMF_RE(X_hybrid_left[n][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(inputLeft) = QMF_RE(X_hybrid_left[n][sb]); ------------------ | | 168| 2.13M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 2.13M|#define RE(A) (A)[0] | | ------------------ ------------------ 1091| 2.13M| IM(inputLeft) = QMF_IM(X_hybrid_left[n][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(inputLeft) = QMF_IM(X_hybrid_left[n][sb]); ------------------ | | 169| 2.13M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 2.13M|#define IM(A) (A)[1] | | ------------------ ------------------ 1092| 7.10M| } else { 1093| 7.10M| RE(inputLeft) = QMF_RE(X_left[n][sb]); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ RE(inputLeft) = QMF_RE(X_left[n][sb]); ------------------ | | 168| 7.10M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 7.10M|#define RE(A) (A)[0] | | ------------------ ------------------ 1094| 7.10M| IM(inputLeft) = QMF_IM(X_left[n][sb]); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ IM(inputLeft) = QMF_IM(X_left[n][sb]); ------------------ | | 169| 7.10M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 7.10M|#define IM(A) (A)[1] | | ------------------ ------------------ 1095| 7.10M| } 1096| | 1097| | /* accumulate energy */ 1098| 9.24M|#ifdef FIXED_POINT 1099| | /* NOTE: all input is scaled by 2^(-5) because of fixed point QMF 1100| | * meaning that P will be scaled by 2^(-10) compared to floating point version 1101| | */ 1102| 9.24M| in_re = ((abs(RE(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 391| 9.24M|#define RE(A) (A)[0] ------------------ in_re = ((abs(RE(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ in_re = ((abs(RE(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 1103| 9.24M| in_im = ((abs(IM(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 392| 9.24M|#define IM(A) (A)[1] ------------------ in_im = ((abs(IM(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ in_im = ((abs(IM(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS); ------------------ | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 1104| 9.24M| P[n][bk] += in_re*in_re + in_im*in_im; 1105| |#else 1106| | P[n][bk] += MUL_R(RE(inputLeft),RE(inputLeft)) + MUL_R(IM(inputLeft),IM(inputLeft)); 1107| |#endif 1108| 9.24M| } 1109| 295k| } 1110| 121k| } 1111| | 1112| |#if 0 1113| | for (n = 0; n < 32; n++) 1114| | { 1115| | for (bk = 0; bk < 34; bk++) 1116| | { 1117| |#ifdef FIXED_POINT 1118| | printf("%d %d: %d\n", n, bk, P[n][bk] /*/(float)REAL_PRECISION*/); 1119| |#else 1120| | printf("%d %d: %f\n", n, bk, P[n][bk]/1024.0); 1121| |#endif 1122| | } 1123| | } 1124| |#endif 1125| | 1126| | /* calculate transient reduction ratio for each parameter band b(k) */ 1127| 98.5k| for (bk = 0; bk < ps->nr_par_bands; bk++) ------------------ | Branch (1127:18): [True: 94.8k, False: 3.76k] ------------------ 1128| 94.8k| { 1129| 3.06M| for (n = ps->border_position[0]; n < ps->border_position[ps->num_env]; n++) ------------------ | Branch (1129:42): [True: 2.96M, False: 94.8k] ------------------ 1130| 2.96M| { 1131| 2.96M| const real_t gamma = COEF_CONST(1.5); ------------------ | | 60| 2.96M|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 2.96M|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 2.96M|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 2.96M, Folded] | | ------------------ ------------------ 1132| | 1133| 2.96M| ps->P_PeakDecayNrg[bk] = MUL_F(ps->P_PeakDecayNrg[bk], ps->alpha_decay); ------------------ | | 268| 2.96M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 2.96M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 2.96M|#define FRAC_BITS 31 | | ------------------ ------------------ 1134| 2.96M| if (ps->P_PeakDecayNrg[bk] < P[n][bk]) ------------------ | Branch (1134:17): [True: 2.73k, False: 2.96M] ------------------ 1135| 2.73k| ps->P_PeakDecayNrg[bk] = P[n][bk]; 1136| | 1137| | /* apply smoothing filter to peak decay energy */ 1138| 2.96M| P_SmoothPeakDecayDiffNrg = ps->P_SmoothPeakDecayDiffNrg_prev[bk]; 1139| 2.96M| P_SmoothPeakDecayDiffNrg += MUL_F((ps->P_PeakDecayNrg[bk] - P[n][bk] - ps->P_SmoothPeakDecayDiffNrg_prev[bk]), ps->alpha_smooth); ------------------ | | 268| 2.96M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 2.96M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 2.96M|#define FRAC_BITS 31 | | ------------------ ------------------ 1140| 2.96M| ps->P_SmoothPeakDecayDiffNrg_prev[bk] = P_SmoothPeakDecayDiffNrg; 1141| | 1142| | /* apply smoothing filter to energy */ 1143| 2.96M| nrg = ps->P_prev[bk]; 1144| 2.96M| nrg += MUL_F((P[n][bk] - ps->P_prev[bk]), ps->alpha_smooth); ------------------ | | 268| 2.96M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 2.96M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 2.96M|#define FRAC_BITS 31 | | ------------------ ------------------ 1145| 2.96M| ps->P_prev[bk] = nrg; 1146| | 1147| | /* calculate transient ratio */ 1148| 2.96M| if (MUL_C(P_SmoothPeakDecayDiffNrg, gamma) <= nrg) ------------------ | | 241| 2.96M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 2.96M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 2.96M|#define COEF_BITS 28 | | ------------------ ------------------ | Branch (1148:17): [True: 2.96M, False: 1.30k] ------------------ 1149| 2.96M| { 1150| 2.96M| G_TransientRatio[n][bk] = REAL_CONST(1.0); ------------------ | | 59| 2.96M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 2.96M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 2.96M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 2.96M, Folded] | | ------------------ ------------------ 1151| 2.96M| } else { 1152| 1.30k| G_TransientRatio[n][bk] = DIV_R(nrg, (MUL_C(P_SmoothPeakDecayDiffNrg, gamma))); ------------------ | | 157| 1.30k|#define DIV_R(A, B) (((int64_t)A * REAL_PRECISION)/B) | | ------------------ | | | | 46| 1.30k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 1.30k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ ------------------ 1153| 1.30k| } 1154| 2.96M| } 1155| 94.8k| } 1156| | 1157| |#if 0 1158| | for (n = 0; n < 32; n++) 1159| | { 1160| | for (bk = 0; bk < 34; bk++) 1161| | { 1162| |#ifdef FIXED_POINT 1163| | printf("%d %d: %f\n", n, bk, G_TransientRatio[n][bk]/(float)REAL_PRECISION); 1164| |#else 1165| | printf("%d %d: %f\n", n, bk, G_TransientRatio[n][bk]); 1166| |#endif 1167| | } 1168| | } 1169| |#endif 1170| | 1171| | /* apply stereo decorrelation filter to the signal */ 1172| 125k| for (gr = 0; gr < ps->num_groups; gr++) ------------------ | Branch (1172:18): [True: 121k, False: 3.76k] ------------------ 1173| 121k| { 1174| 121k| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1174:13): [True: 68.4k, False: 53.5k] ------------------ 1175| 68.4k| maxsb = ps->group_border[gr] + 1; 1176| 53.5k| else 1177| 53.5k| maxsb = ps->group_border[gr + 1]; 1178| | 1179| | /* QMF channel */ 1180| 417k| for (sb = ps->group_border[gr]; sb < maxsb; sb++) ------------------ | Branch (1180:41): [True: 295k, False: 121k] ------------------ 1181| 295k| { 1182| 295k| real_t g_DecaySlope; 1183| 295k| real_t g_DecaySlope_filt[NO_ALLPASS_LINKS]; 1184| | 1185| | /* g_DecaySlope: [0..1] */ 1186| 295k| if (gr < ps->num_hybrid_groups || sb <= ps->decay_cutoff) ------------------ | Branch (1186:17): [True: 68.4k, False: 226k] | Branch (1186:47): [True: 3.76k, False: 222k] ------------------ 1187| 72.1k| { 1188| 72.1k| g_DecaySlope = FRAC_CONST(1.0); ------------------ | | 61| 72.1k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 72.1k|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [True: 72.1k, Folded] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 1189| 222k| } else { 1190| 222k| int8_t decay = ps->decay_cutoff - sb; 1191| 222k| if (decay <= -20 /* -1/DECAY_SLOPE */) ------------------ | Branch (1191:21): [True: 151k, False: 71.4k] ------------------ 1192| 151k| { 1193| 151k| g_DecaySlope = 0; 1194| 151k| } else { 1195| | /* decay(int)*decay_slope(frac) = g_DecaySlope(frac) */ 1196| 71.4k| g_DecaySlope = FRAC_CONST(1.0) + DECAY_SLOPE * decay; ------------------ | | 61| 71.4k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 71.4k|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [True: 71.4k, Folded] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ g_DecaySlope = FRAC_CONST(1.0) + DECAY_SLOPE * decay; ------------------ | | 42| 71.4k|#define DECAY_SLOPE FRAC_CONST(0.05) | | ------------------ | | | | 61| 71.4k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | | | ------------------ | | | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | | | ------------------ | | | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | | | ------------------ | | | | | | 53| 71.4k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | | | ------------------ | | | | | | | | 50| 71.4k|#define FRAC_BITS 31 | | | | | | ------------------ | | | | ------------------ | | | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | | | ------------------ | | | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | | | ------------------ | | | | | | | | 50| 0|#define FRAC_BITS 31 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (61:24): [Folded, False: 71.4k] | | | | | Branch (61:62): [True: 71.4k, Folded] | | | | ------------------ | | ------------------ ------------------ 1197| 71.4k| } 1198| 222k| } 1199| | 1200| | /* calculate g_DecaySlope_filt for every n multiplied by filter_a[n] */ 1201| 1.18M| for (n = 0; n < NO_ALLPASS_LINKS; n++) ------------------ | | 43| 1.18M|#define NO_ALLPASS_LINKS 3 ------------------ | Branch (1201:25): [True: 885k, False: 295k] ------------------ 1202| 885k| { 1203| 885k| g_DecaySlope_filt[n] = MUL_F(g_DecaySlope, filter_a[n]); ------------------ | | 268| 885k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 885k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 885k|#define FRAC_BITS 31 | | ------------------ ------------------ 1204| 885k| } 1205| | 1206| | 1207| | /* set delay indices */ 1208| 295k| temp_delay = ps->saved_delay; 1209| 1.18M| for (n = 0; n < NO_ALLPASS_LINKS; n++) ------------------ | | 43| 1.18M|#define NO_ALLPASS_LINKS 3 ------------------ | Branch (1209:25): [True: 885k, False: 295k] ------------------ 1210| 885k| temp_delay_ser[n] = ps->delay_buf_index_ser[n]; 1211| | 1212| 9.54M| for (n = ps->border_position[0]; n < ps->border_position[ps->num_env]; n++) ------------------ | Branch (1212:46): [True: 9.24M, False: 295k] ------------------ 1213| 9.24M| { 1214| 9.24M| complex_t tmp, tmp0, R0; 1215| 9.24M| uint8_t m; 1216| | 1217| 9.24M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1217:21): [True: 2.13M, False: 7.10M] ------------------ 1218| 2.13M| { 1219| | /* hybrid filterbank input */ 1220| 2.13M| RE(inputLeft) = QMF_RE(X_hybrid_left[n][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(inputLeft) = QMF_RE(X_hybrid_left[n][sb]); ------------------ | | 168| 2.13M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 2.13M|#define RE(A) (A)[0] | | ------------------ ------------------ 1221| 2.13M| IM(inputLeft) = QMF_IM(X_hybrid_left[n][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(inputLeft) = QMF_IM(X_hybrid_left[n][sb]); ------------------ | | 169| 2.13M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 2.13M|#define IM(A) (A)[1] | | ------------------ ------------------ 1222| 7.10M| } else { 1223| | /* QMF filterbank input */ 1224| 7.10M| RE(inputLeft) = QMF_RE(X_left[n][sb]); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ RE(inputLeft) = QMF_RE(X_left[n][sb]); ------------------ | | 168| 7.10M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 7.10M|#define RE(A) (A)[0] | | ------------------ ------------------ 1225| 7.10M| IM(inputLeft) = QMF_IM(X_left[n][sb]); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ IM(inputLeft) = QMF_IM(X_left[n][sb]); ------------------ | | 169| 7.10M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 7.10M|#define IM(A) (A)[1] | | ------------------ ------------------ 1226| 7.10M| } 1227| | 1228| 9.24M| if (sb > ps->nr_allpass_bands && gr >= ps->num_hybrid_groups) ------------------ | Branch (1228:21): [True: 5.22M, False: 4.01M] | Branch (1228:50): [True: 4.83M, False: 392k] ------------------ 1229| 4.83M| { 1230| | /* delay */ 1231| | 1232| | /* never hybrid subbands here, always QMF subbands */ 1233| 4.83M| RE(tmp) = RE(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]); ------------------ | | 391| 4.83M|#define RE(A) (A)[0] ------------------ RE(tmp) = RE(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]); ------------------ | | 391| 4.83M|#define RE(A) (A)[0] ------------------ 1234| 4.83M| IM(tmp) = IM(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]); ------------------ | | 392| 4.83M|#define IM(A) (A)[1] ------------------ IM(tmp) = IM(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]); ------------------ | | 392| 4.83M|#define IM(A) (A)[1] ------------------ 1235| 4.83M| RE(R0) = RE(tmp); ------------------ | | 391| 4.83M|#define RE(A) (A)[0] ------------------ RE(R0) = RE(tmp); ------------------ | | 391| 4.83M|#define RE(A) (A)[0] ------------------ 1236| 4.83M| IM(R0) = IM(tmp); ------------------ | | 392| 4.83M|#define IM(A) (A)[1] ------------------ IM(R0) = IM(tmp); ------------------ | | 392| 4.83M|#define IM(A) (A)[1] ------------------ 1237| 4.83M| RE(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]) = RE(inputLeft); ------------------ | | 391| 4.83M|#define RE(A) (A)[0] ------------------ RE(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]) = RE(inputLeft); ------------------ | | 391| 4.83M|#define RE(A) (A)[0] ------------------ 1238| 4.83M| IM(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]) = IM(inputLeft); ------------------ | | 392| 4.83M|#define IM(A) (A)[1] ------------------ IM(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]) = IM(inputLeft); ------------------ | | 392| 4.83M|#define IM(A) (A)[1] ------------------ 1239| 4.83M| } else { 1240| | /* allpass filter */ 1241| 4.41M| complex_t Phi_Fract; 1242| | 1243| | /* fetch parameters */ 1244| 4.41M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1244:25): [True: 2.13M, False: 2.27M] ------------------ 1245| 2.13M| { 1246| | /* select data from the hybrid subbands */ 1247| 2.13M| RE(tmp0) = RE(ps->delay_SubQmf[temp_delay][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(tmp0) = RE(ps->delay_SubQmf[temp_delay][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1248| 2.13M| IM(tmp0) = IM(ps->delay_SubQmf[temp_delay][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(tmp0) = IM(ps->delay_SubQmf[temp_delay][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1249| | 1250| 2.13M| RE(ps->delay_SubQmf[temp_delay][sb]) = RE(inputLeft); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(ps->delay_SubQmf[temp_delay][sb]) = RE(inputLeft); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1251| 2.13M| IM(ps->delay_SubQmf[temp_delay][sb]) = IM(inputLeft); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(ps->delay_SubQmf[temp_delay][sb]) = IM(inputLeft); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1252| | 1253| 2.13M| RE(Phi_Fract) = RE(Phi_Fract_SubQmf[sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(Phi_Fract) = RE(Phi_Fract_SubQmf[sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1254| 2.13M| IM(Phi_Fract) = IM(Phi_Fract_SubQmf[sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(Phi_Fract) = IM(Phi_Fract_SubQmf[sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1255| 2.27M| } else { 1256| | /* select data from the QMF subbands */ 1257| 2.27M| RE(tmp0) = RE(ps->delay_Qmf[temp_delay][sb]); ------------------ | | 391| 2.27M|#define RE(A) (A)[0] ------------------ RE(tmp0) = RE(ps->delay_Qmf[temp_delay][sb]); ------------------ | | 391| 2.27M|#define RE(A) (A)[0] ------------------ 1258| 2.27M| IM(tmp0) = IM(ps->delay_Qmf[temp_delay][sb]); ------------------ | | 392| 2.27M|#define IM(A) (A)[1] ------------------ IM(tmp0) = IM(ps->delay_Qmf[temp_delay][sb]); ------------------ | | 392| 2.27M|#define IM(A) (A)[1] ------------------ 1259| | 1260| 2.27M| RE(ps->delay_Qmf[temp_delay][sb]) = RE(inputLeft); ------------------ | | 391| 2.27M|#define RE(A) (A)[0] ------------------ RE(ps->delay_Qmf[temp_delay][sb]) = RE(inputLeft); ------------------ | | 391| 2.27M|#define RE(A) (A)[0] ------------------ 1261| 2.27M| IM(ps->delay_Qmf[temp_delay][sb]) = IM(inputLeft); ------------------ | | 392| 2.27M|#define IM(A) (A)[1] ------------------ IM(ps->delay_Qmf[temp_delay][sb]) = IM(inputLeft); ------------------ | | 392| 2.27M|#define IM(A) (A)[1] ------------------ 1262| | 1263| 2.27M| RE(Phi_Fract) = RE(Phi_Fract_Qmf[sb]); ------------------ | | 391| 2.27M|#define RE(A) (A)[0] ------------------ RE(Phi_Fract) = RE(Phi_Fract_Qmf[sb]); ------------------ | | 391| 2.27M|#define RE(A) (A)[0] ------------------ 1264| 2.27M| IM(Phi_Fract) = IM(Phi_Fract_Qmf[sb]); ------------------ | | 392| 2.27M|#define IM(A) (A)[1] ------------------ IM(Phi_Fract) = IM(Phi_Fract_Qmf[sb]); ------------------ | | 392| 2.27M|#define IM(A) (A)[1] ------------------ 1265| 2.27M| } 1266| | 1267| | /* z^(-2) * Phi_Fract[k] */ 1268| 4.41M| ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 391| 4.41M|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 392| 4.41M|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 391| 4.41M|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 392| 4.41M|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 391| 4.41M|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract)); ------------------ | | 392| 4.41M|#define IM(A) (A)[1] ------------------ 1269| | 1270| 4.41M| RE(R0) = RE(tmp); ------------------ | | 391| 4.41M|#define RE(A) (A)[0] ------------------ RE(R0) = RE(tmp); ------------------ | | 391| 4.41M|#define RE(A) (A)[0] ------------------ 1271| 4.41M| IM(R0) = IM(tmp); ------------------ | | 392| 4.41M|#define IM(A) (A)[1] ------------------ IM(R0) = IM(tmp); ------------------ | | 392| 4.41M|#define IM(A) (A)[1] ------------------ 1272| 17.6M| for (m = 0; m < NO_ALLPASS_LINKS; m++) ------------------ | | 43| 17.6M|#define NO_ALLPASS_LINKS 3 ------------------ | Branch (1272:33): [True: 13.2M, False: 4.41M] ------------------ 1273| 13.2M| { 1274| 13.2M| complex_t Q_Fract_allpass, tmp2; 1275| | 1276| | /* fetch parameters */ 1277| 13.2M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1277:29): [True: 6.41M, False: 6.81M] ------------------ 1278| 6.41M| { 1279| | /* select data from the hybrid subbands */ 1280| 6.41M| RE(tmp0) = RE(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 391| 6.41M|#define RE(A) (A)[0] ------------------ RE(tmp0) = RE(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 391| 6.41M|#define RE(A) (A)[0] ------------------ 1281| 6.41M| IM(tmp0) = IM(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 392| 6.41M|#define IM(A) (A)[1] ------------------ IM(tmp0) = IM(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 392| 6.41M|#define IM(A) (A)[1] ------------------ 1282| | 1283| 6.41M| if (ps->use34hybrid_bands) ------------------ | Branch (1283:33): [True: 4.18M, False: 2.23M] ------------------ 1284| 4.18M| { 1285| 4.18M| RE(Q_Fract_allpass) = RE(Q_Fract_allpass_SubQmf34[sb][m]); ------------------ | | 391| 4.18M|#define RE(A) (A)[0] ------------------ RE(Q_Fract_allpass) = RE(Q_Fract_allpass_SubQmf34[sb][m]); ------------------ | | 391| 4.18M|#define RE(A) (A)[0] ------------------ 1286| 4.18M| IM(Q_Fract_allpass) = IM(Q_Fract_allpass_SubQmf34[sb][m]); ------------------ | | 392| 4.18M|#define IM(A) (A)[1] ------------------ IM(Q_Fract_allpass) = IM(Q_Fract_allpass_SubQmf34[sb][m]); ------------------ | | 392| 4.18M|#define IM(A) (A)[1] ------------------ 1287| 4.18M| } else { 1288| 2.23M| RE(Q_Fract_allpass) = RE(Q_Fract_allpass_SubQmf20[sb][m]); ------------------ | | 391| 2.23M|#define RE(A) (A)[0] ------------------ RE(Q_Fract_allpass) = RE(Q_Fract_allpass_SubQmf20[sb][m]); ------------------ | | 391| 2.23M|#define RE(A) (A)[0] ------------------ 1289| 2.23M| IM(Q_Fract_allpass) = IM(Q_Fract_allpass_SubQmf20[sb][m]); ------------------ | | 392| 2.23M|#define IM(A) (A)[1] ------------------ IM(Q_Fract_allpass) = IM(Q_Fract_allpass_SubQmf20[sb][m]); ------------------ | | 392| 2.23M|#define IM(A) (A)[1] ------------------ 1290| 2.23M| } 1291| 6.81M| } else { 1292| | /* select data from the QMF subbands */ 1293| 6.81M| RE(tmp0) = RE(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 391| 6.81M|#define RE(A) (A)[0] ------------------ RE(tmp0) = RE(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 391| 6.81M|#define RE(A) (A)[0] ------------------ 1294| 6.81M| IM(tmp0) = IM(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 392| 6.81M|#define IM(A) (A)[1] ------------------ IM(tmp0) = IM(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]); ------------------ | | 392| 6.81M|#define IM(A) (A)[1] ------------------ 1295| | 1296| 6.81M| RE(Q_Fract_allpass) = RE(Q_Fract_allpass_Qmf[sb][m]); ------------------ | | 391| 6.81M|#define RE(A) (A)[0] ------------------ RE(Q_Fract_allpass) = RE(Q_Fract_allpass_Qmf[sb][m]); ------------------ | | 391| 6.81M|#define RE(A) (A)[0] ------------------ 1297| 6.81M| IM(Q_Fract_allpass) = IM(Q_Fract_allpass_Qmf[sb][m]); ------------------ | | 392| 6.81M|#define IM(A) (A)[1] ------------------ IM(Q_Fract_allpass) = IM(Q_Fract_allpass_Qmf[sb][m]); ------------------ | | 392| 6.81M|#define IM(A) (A)[1] ------------------ 1298| 6.81M| } 1299| | 1300| | /* delay by a fraction */ 1301| | /* z^(-d(m)) * Q_Fract_allpass[k,m] */ 1302| 13.2M| ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Q_Fract_allpass), IM(Q_Fract_allpass)); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Q_Fract_allpass), IM(Q_Fract_allpass)); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Q_Fract_allpass), IM(Q_Fract_allpass)); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Q_Fract_allpass), IM(Q_Fract_allpass)); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Q_Fract_allpass), IM(Q_Fract_allpass)); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Q_Fract_allpass), IM(Q_Fract_allpass)); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ 1303| | 1304| | /* -a(m) * g_DecaySlope[k] */ 1305| 13.2M| RE(tmp) += -MUL_F(g_DecaySlope_filt[m], RE(R0)); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ RE(tmp) += -MUL_F(g_DecaySlope_filt[m], RE(R0)); ------------------ | | 268| 13.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 1306| 13.2M| IM(tmp) += -MUL_F(g_DecaySlope_filt[m], IM(R0)); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ IM(tmp) += -MUL_F(g_DecaySlope_filt[m], IM(R0)); ------------------ | | 268| 13.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 1307| | 1308| | /* -a(m) * g_DecaySlope[k] * Q_Fract_allpass[k,m] * z^(-d(m)) */ 1309| 13.2M| RE(tmp2) = RE(R0) + MUL_F(g_DecaySlope_filt[m], RE(tmp)); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ RE(tmp2) = RE(R0) + MUL_F(g_DecaySlope_filt[m], RE(tmp)); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ RE(tmp2) = RE(R0) + MUL_F(g_DecaySlope_filt[m], RE(tmp)); ------------------ | | 268| 13.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 1310| 13.2M| IM(tmp2) = IM(R0) + MUL_F(g_DecaySlope_filt[m], IM(tmp)); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ IM(tmp2) = IM(R0) + MUL_F(g_DecaySlope_filt[m], IM(tmp)); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ IM(tmp2) = IM(R0) + MUL_F(g_DecaySlope_filt[m], IM(tmp)); ------------------ | | 268| 13.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 13.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 1311| | 1312| | /* store sample */ 1313| 13.2M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1313:29): [True: 6.41M, False: 6.81M] ------------------ 1314| 6.41M| { 1315| 6.41M| RE(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]) = RE(tmp2); ------------------ | | 391| 6.41M|#define RE(A) (A)[0] ------------------ RE(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]) = RE(tmp2); ------------------ | | 391| 6.41M|#define RE(A) (A)[0] ------------------ 1316| 6.41M| IM(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]) = IM(tmp2); ------------------ | | 392| 6.41M|#define IM(A) (A)[1] ------------------ IM(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]) = IM(tmp2); ------------------ | | 392| 6.41M|#define IM(A) (A)[1] ------------------ 1317| 6.81M| } else { 1318| 6.81M| RE(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]) = RE(tmp2); ------------------ | | 391| 6.81M|#define RE(A) (A)[0] ------------------ RE(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]) = RE(tmp2); ------------------ | | 391| 6.81M|#define RE(A) (A)[0] ------------------ 1319| 6.81M| IM(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]) = IM(tmp2); ------------------ | | 392| 6.81M|#define IM(A) (A)[1] ------------------ IM(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]) = IM(tmp2); ------------------ | | 392| 6.81M|#define IM(A) (A)[1] ------------------ 1320| 6.81M| } 1321| | 1322| | /* store for next iteration (or as output value if last iteration) */ 1323| 13.2M| RE(R0) = RE(tmp); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ RE(R0) = RE(tmp); ------------------ | | 391| 13.2M|#define RE(A) (A)[0] ------------------ 1324| 13.2M| IM(R0) = IM(tmp); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ IM(R0) = IM(tmp); ------------------ | | 392| 13.2M|#define IM(A) (A)[1] ------------------ 1325| 13.2M| } 1326| 4.41M| } 1327| | 1328| | /* select b(k) for reading the transient ratio */ 1329| 9.24M| bk = (~NEGATE_IPD_MASK) & ps->map_group2bk[gr]; ------------------ | | 41| 9.24M|#define NEGATE_IPD_MASK (0x1000) ------------------ 1330| | 1331| | /* duck if a past transient is found */ 1332| 9.24M| RE(R0) = MUL_R(G_TransientRatio[n][bk], RE(R0)); ------------------ | | 391| 9.24M|#define RE(A) (A)[0] ------------------ RE(R0) = MUL_R(G_TransientRatio[n][bk], RE(R0)); ------------------ | | 239| 9.24M| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 1333| 9.24M| IM(R0) = MUL_R(G_TransientRatio[n][bk], IM(R0)); ------------------ | | 392| 9.24M|#define IM(A) (A)[1] ------------------ IM(R0) = MUL_R(G_TransientRatio[n][bk], IM(R0)); ------------------ | | 239| 9.24M| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 9.24M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 1334| | 1335| 9.24M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1335:21): [True: 2.13M, False: 7.10M] ------------------ 1336| 2.13M| { 1337| | /* hybrid */ 1338| 2.13M| QMF_RE(X_hybrid_right[n][sb]) = RE(R0); ------------------ | | 168| 2.13M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 2.13M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_hybrid_right[n][sb]) = RE(R0); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1339| 2.13M| QMF_IM(X_hybrid_right[n][sb]) = IM(R0); ------------------ | | 169| 2.13M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 2.13M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_hybrid_right[n][sb]) = IM(R0); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1340| 7.10M| } else { 1341| | /* QMF */ 1342| 7.10M| QMF_RE(X_right[n][sb]) = RE(R0); ------------------ | | 168| 7.10M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 7.10M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_right[n][sb]) = RE(R0); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ 1343| 7.10M| QMF_IM(X_right[n][sb]) = IM(R0); ------------------ | | 169| 7.10M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 7.10M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_right[n][sb]) = IM(R0); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ 1344| 7.10M| } 1345| | 1346| | /* Update delay buffer index */ 1347| 9.24M| if (++temp_delay >= 2) ------------------ | Branch (1347:21): [True: 4.62M, False: 4.62M] ------------------ 1348| 4.62M| { 1349| 4.62M| temp_delay = 0; 1350| 4.62M| } 1351| | 1352| | /* update delay indices */ 1353| 9.24M| if (sb > ps->nr_allpass_bands && gr >= ps->num_hybrid_groups) ------------------ | Branch (1353:21): [True: 5.22M, False: 4.01M] | Branch (1353:50): [True: 4.83M, False: 392k] ------------------ 1354| 4.83M| { 1355| | /* delay_D depends on the samplerate, it can hold the values 14 and 1 */ 1356| 4.83M| if (++ps->delay_buf_index_delay[sb] >= ps->delay_D[sb]) ------------------ | Branch (1356:25): [True: 3.51M, False: 1.32M] ------------------ 1357| 3.51M| { 1358| 3.51M| ps->delay_buf_index_delay[sb] = 0; 1359| 3.51M| } 1360| 4.83M| } 1361| | 1362| 36.9M| for (m = 0; m < NO_ALLPASS_LINKS; m++) ------------------ | | 43| 36.9M|#define NO_ALLPASS_LINKS 3 ------------------ | Branch (1362:29): [True: 27.7M, False: 9.24M] ------------------ 1363| 27.7M| { 1364| 27.7M| if (++temp_delay_ser[m] >= ps->num_sample_delay_ser[m]) ------------------ | Branch (1364:25): [True: 7.07M, False: 20.6M] ------------------ 1365| 7.07M| { 1366| 7.07M| temp_delay_ser[m] = 0; 1367| 7.07M| } 1368| 27.7M| } 1369| 9.24M| } 1370| 295k| } 1371| 121k| } 1372| | 1373| | /* update delay indices */ 1374| 3.76k| ps->saved_delay = temp_delay; 1375| 15.0k| for (n = 0; n < NO_ALLPASS_LINKS; n++) ------------------ | | 43| 15.0k|#define NO_ALLPASS_LINKS 3 ------------------ | Branch (1375:17): [True: 11.2k, False: 3.76k] ------------------ 1376| 11.2k| ps->delay_buf_index_ser[n] = temp_delay_ser[n]; 1377| 3.76k|} ps_dec.c:ps_mix_phase: 1458| 3.76k|{ 1459| 3.76k| uint8_t n; 1460| 3.76k| uint8_t gr; 1461| 3.76k| uint8_t bk = 0; 1462| 3.76k| uint8_t sb, maxsb; 1463| 3.76k| uint8_t env; 1464| 3.76k| uint8_t nr_ipdopd_par; 1465| 3.76k| complex_t h11, h12, h21, h22; // COEF 1466| 3.76k| complex_t H11, H12, H21, H22; // COEF 1467| 3.76k| complex_t deltaH11, deltaH12, deltaH21, deltaH22; // COEF 1468| 3.76k| complex_t tempLeft, tempRight; // FRAC 1469| 3.76k| complex_t phaseLeft, phaseRight; // FRAC 1470| 3.76k| real_t L; 1471| 3.76k| const real_t *sf_iid; 1472| 3.76k| uint8_t no_iid_steps; 1473| | 1474| 3.76k| if (ps->iid_mode >= 3) ------------------ | Branch (1474:9): [True: 1.51k, False: 2.24k] ------------------ 1475| 1.51k| { 1476| 1.51k| no_iid_steps = 15; 1477| 1.51k| sf_iid = sf_iid_fine; 1478| 2.24k| } else { 1479| 2.24k| no_iid_steps = 7; 1480| 2.24k| sf_iid = sf_iid_normal; 1481| 2.24k| } 1482| | 1483| 3.76k| if (ps->ipd_mode == 0 || ps->ipd_mode == 3) ------------------ | Branch (1483:9): [True: 1.36k, False: 2.40k] | Branch (1483:30): [True: 560, False: 1.84k] ------------------ 1484| 1.92k| { 1485| 1.92k| nr_ipdopd_par = 11; /* resolution */ 1486| 1.92k| } else { 1487| 1.84k| nr_ipdopd_par = ps->nr_ipdopd_par; 1488| 1.84k| } 1489| | 1490| 125k| for (gr = 0; gr < ps->num_groups; gr++) ------------------ | Branch (1490:18): [True: 121k, False: 3.76k] ------------------ 1491| 121k| { 1492| 121k| bk = (~NEGATE_IPD_MASK) & ps->map_group2bk[gr]; ------------------ | | 41| 121k|#define NEGATE_IPD_MASK (0x1000) ------------------ 1493| | 1494| | /* use one channel per group in the subqmf domain */ 1495| 121k| maxsb = (gr < ps->num_hybrid_groups) ? ps->group_border[gr] + 1 : ps->group_border[gr + 1]; ------------------ | Branch (1495:17): [True: 68.4k, False: 53.5k] ------------------ 1496| | 1497| 389k| for (env = 0; env < ps->num_env; env++) ------------------ | Branch (1497:23): [True: 267k, False: 121k] ------------------ 1498| 267k| { 1499| 267k| uint8_t abs_iid = (uint8_t)abs(ps->iid_index[env][bk]); 1500| | /* index range is supposed to be -7...7 or -15...15 depending on iid_mode 1501| | (Table 8.24, ISO/IEC 14496-3:2005). 1502| | if it is outside these boundaries, this is most likely an error. sanitize 1503| | it and try to process further. */ 1504| 267k| if (ps->iid_index[env][bk] < -no_iid_steps) { ------------------ | Branch (1504:17): [True: 4, False: 267k] ------------------ 1505| 4| fprintf(stderr, "Warning: invalid iid_index: %d < %d\n", ps->iid_index[env][bk], 1506| 4| -no_iid_steps); 1507| 4| ps->iid_index[env][bk] = -no_iid_steps; 1508| 4| abs_iid = no_iid_steps; 1509| 267k| } else if (ps->iid_index[env][bk] > no_iid_steps) { ------------------ | Branch (1509:24): [True: 0, False: 267k] ------------------ 1510| 0| fprintf(stderr, "Warning: invalid iid_index: %d > %d\n", ps->iid_index[env][bk], 1511| 0| no_iid_steps); 1512| 0| ps->iid_index[env][bk] = no_iid_steps; 1513| 0| abs_iid = no_iid_steps; 1514| 0| } 1515| 267k| if (ps->icc_index[env][bk] < 0) { ------------------ | Branch (1515:17): [True: 0, False: 267k] ------------------ 1516| 0| fprintf(stderr, "Warning: invalid icc_index: %d < 0\n", ps->icc_index[env][bk]); 1517| 0| ps->icc_index[env][bk] = 0; 1518| 267k| } else if (ps->icc_index[env][bk] > 7) { ------------------ | Branch (1518:24): [True: 0, False: 267k] ------------------ 1519| 0| fprintf(stderr, "Warning: invalid icc_index: %d > 7\n", ps->icc_index[env][bk]); 1520| 0| ps->icc_index[env][bk] = 7; 1521| 0| } 1522| | 1523| 267k| if (ps->icc_mode < 3) ------------------ | Branch (1523:17): [True: 173k, False: 94.2k] ------------------ 1524| 173k| { 1525| | /* type 'A' mixing as described in 8.6.4.6.2.1 */ 1526| 173k| real_t c_1, c_2; // COEF 1527| 173k| real_t cosa, sina; // COEF 1528| 173k| real_t cosb, sinb; // COEF 1529| 173k| real_t ab1, ab2; // COEF 1530| 173k| real_t ab3, ab4; // COEF 1531| | 1532| | /* 1533| | c_1 = sqrt(2.0 / (1.0 + pow(10.0, quant_iid[no_iid_steps + iid_index] / 10.0))); 1534| | c_2 = sqrt(2.0 / (1.0 + pow(10.0, quant_iid[no_iid_steps - iid_index] / 10.0))); 1535| | alpha = 0.5 * acos(quant_rho[icc_index]); 1536| | beta = alpha * ( c_1 - c_2 ) / sqrt(2.0); 1537| | */ 1538| | 1539| | //printf("%d\n", ps->iid_index[env][bk]); 1540| | 1541| | /* calculate the scalefactors c_1 and c_2 from the intensity differences */ 1542| 173k| c_1 = sf_iid[no_iid_steps + ps->iid_index[env][bk]]; 1543| 173k| c_2 = sf_iid[no_iid_steps - ps->iid_index[env][bk]]; 1544| | 1545| | /* calculate alpha and beta using the ICC parameters */ 1546| 173k| cosa = cos_alphas[ps->icc_index[env][bk]]; 1547| 173k| sina = sin_alphas[ps->icc_index[env][bk]]; 1548| | 1549| 173k| if (ps->iid_mode >= 3) ------------------ | Branch (1549:21): [True: 36.1k, False: 137k] ------------------ 1550| 36.1k| { 1551| 36.1k| cosb = cos_betas_fine[abs_iid][ps->icc_index[env][bk]]; 1552| 36.1k| sinb = sin_betas_fine[abs_iid][ps->icc_index[env][bk]]; 1553| 137k| } else { 1554| 137k| cosb = cos_betas_normal[abs_iid][ps->icc_index[env][bk]]; 1555| 137k| sinb = sin_betas_normal[abs_iid][ps->icc_index[env][bk]]; 1556| 137k| } 1557| | 1558| 173k| ab1 = MUL_C(cosb, cosa); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1559| 173k| ab2 = MUL_C(sinb, sina); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1560| 173k| ab3 = MUL_C(sinb, cosa); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1561| 173k| ab4 = MUL_C(cosb, sina); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1562| | 1563| | /* h_xy: COEF */ 1564| 173k| RE(h11) = MUL_C(c_2, (ab1 - ab2)); ------------------ | | 391| 173k|#define RE(A) (A)[0] ------------------ RE(h11) = MUL_C(c_2, (ab1 - ab2)); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1565| 173k| RE(h12) = MUL_C(c_1, (ab1 + ab2)); ------------------ | | 391| 173k|#define RE(A) (A)[0] ------------------ RE(h12) = MUL_C(c_1, (ab1 + ab2)); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1566| 173k| RE(h21) = MUL_C(c_2, (ab3 + ab4)); ------------------ | | 391| 173k|#define RE(A) (A)[0] ------------------ RE(h21) = MUL_C(c_2, (ab3 + ab4)); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1567| 173k| RE(h22) = MUL_C(c_1, (ab3 - ab4)); ------------------ | | 391| 173k|#define RE(A) (A)[0] ------------------ RE(h22) = MUL_C(c_1, (ab3 - ab4)); ------------------ | | 241| 173k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 173k|#define COEF_BITS 28 | | ------------------ ------------------ 1568| 173k| } else { 1569| | /* type 'B' mixing as described in 8.6.4.6.2.2 */ 1570| 94.2k| real_t sina, cosa; // COEF 1571| 94.2k| real_t cosg, sing; // COEF 1572| | 1573| | /* 1574| | real_t c, rho, mu, alpha, gamma; 1575| | uint8_t i; 1576| | 1577| | i = ps->iid_index[env][bk]; 1578| | c = (real_t)pow(10.0, ((i)?(((i>0)?1:-1)*quant_iid[((i>0)?i:-i)-1]):0.)/20.0); 1579| | rho = quant_rho[ps->icc_index[env][bk]]; 1580| | 1581| | if (rho == 0.0f && c == 1.) 1582| | { 1583| | alpha = (real_t)M_PI/4.0f; 1584| | rho = 0.05f; 1585| | } else { 1586| | if (rho <= 0.05f) 1587| | { 1588| | rho = 0.05f; 1589| | } 1590| | alpha = 0.5f*(real_t)atan( (2.0f*c*rho) / (c*c-1.0f) ); 1591| | 1592| | if (alpha < 0.) 1593| | { 1594| | alpha += (real_t)M_PI/2.0f; 1595| | } 1596| | if (rho < 0.) 1597| | { 1598| | alpha += (real_t)M_PI; 1599| | } 1600| | } 1601| | mu = c+1.0f/c; 1602| | mu = 1+(4.0f*rho*rho-4.0f)/(mu*mu); 1603| | gamma = (real_t)atan(sqrt((1.0f-sqrt(mu))/(1.0f+sqrt(mu)))); 1604| | */ 1605| | 1606| 94.2k| if (ps->iid_mode >= 3) ------------------ | Branch (1606:21): [True: 64.4k, False: 29.7k] ------------------ 1607| 64.4k| { 1608| 64.4k| cosa = sincos_alphas_B_fine[no_iid_steps + ps->iid_index[env][bk]][ps->icc_index[env][bk]]; 1609| 64.4k| sina = sincos_alphas_B_fine[30 - (no_iid_steps + ps->iid_index[env][bk])][ps->icc_index[env][bk]]; 1610| 64.4k| cosg = cos_gammas_fine[abs_iid][ps->icc_index[env][bk]]; 1611| 64.4k| sing = sin_gammas_fine[abs_iid][ps->icc_index[env][bk]]; 1612| 64.4k| } else { 1613| 29.7k| cosa = sincos_alphas_B_normal[no_iid_steps + ps->iid_index[env][bk]][ps->icc_index[env][bk]]; 1614| 29.7k| sina = sincos_alphas_B_normal[14 - (no_iid_steps + ps->iid_index[env][bk])][ps->icc_index[env][bk]]; 1615| 29.7k| cosg = cos_gammas_normal[abs_iid][ps->icc_index[env][bk]]; 1616| 29.7k| sing = sin_gammas_normal[abs_iid][ps->icc_index[env][bk]]; 1617| 29.7k| } 1618| | 1619| 94.2k| RE(h11) = MUL_C(COEF_SQRT2, MUL_C(cosa, cosg)); ------------------ | | 391| 94.2k|#define RE(A) (A)[0] ------------------ RE(h11) = MUL_C(COEF_SQRT2, MUL_C(cosa, cosg)); ------------------ | | 241| 188k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 94.2k, Folded] | | ------------------ ------------------ 1620| 94.2k| RE(h12) = MUL_C(COEF_SQRT2, MUL_C(sina, cosg)); ------------------ | | 391| 94.2k|#define RE(A) (A)[0] ------------------ RE(h12) = MUL_C(COEF_SQRT2, MUL_C(sina, cosg)); ------------------ | | 241| 188k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 94.2k, Folded] | | ------------------ ------------------ 1621| 94.2k| RE(h21) = MUL_C(COEF_SQRT2, MUL_C(-cosa, sing)); ------------------ | | 391| 94.2k|#define RE(A) (A)[0] ------------------ RE(h21) = MUL_C(COEF_SQRT2, MUL_C(-cosa, sing)); ------------------ | | 241| 188k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 94.2k, Folded] | | ------------------ ------------------ 1622| 94.2k| RE(h22) = MUL_C(COEF_SQRT2, MUL_C(sina, sing)); ------------------ | | 391| 94.2k|#define RE(A) (A)[0] ------------------ RE(h22) = MUL_C(COEF_SQRT2, MUL_C(sina, sing)); ------------------ | | 241| 188k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 94.2k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 94.2k, Folded] | | ------------------ ------------------ 1623| 94.2k| } 1624| 267k| IM(h11) = IM(h12) = IM(h21) = IM(h22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ IM(h11) = IM(h12) = IM(h21) = IM(h22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ IM(h11) = IM(h12) = IM(h21) = IM(h22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ IM(h11) = IM(h12) = IM(h21) = IM(h22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ 1625| | 1626| | /* calculate phase rotation parameters H_xy */ 1627| | /* note that the imaginary part of these parameters are only calculated when 1628| | IPD and OPD are enabled 1629| | */ 1630| 267k| if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par)) ------------------ | Branch (1630:17): [True: 80.3k, False: 187k] | Branch (1630:40): [True: 46.4k, False: 33.8k] ------------------ 1631| 46.4k| { 1632| 46.4k| int8_t i; 1633| 46.4k| real_t xy, pq, xypq; // FRAC 1634| | 1635| | /* ringbuffer index */ 1636| 46.4k| i = ps->phase_hist; 1637| | 1638| | /* previous value */ 1639| 46.4k|#ifdef FIXED_POINT 1640| | /* divide by 4*2, shift right 3 bits; 1641| | extra halving to avoid overflows; it is ok, because result is normalized */ 1642| 46.4k| RE(tempLeft) = RE(ps->ipd_prev[bk][i]) >> 3; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(tempLeft) = RE(ps->ipd_prev[bk][i]) >> 3; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1643| 46.4k| IM(tempLeft) = IM(ps->ipd_prev[bk][i]) >> 3; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(tempLeft) = IM(ps->ipd_prev[bk][i]) >> 3; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1644| 46.4k| RE(tempRight) = RE(ps->opd_prev[bk][i]) >> 3; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(tempRight) = RE(ps->opd_prev[bk][i]) >> 3; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1645| 46.4k| IM(tempRight) = IM(ps->opd_prev[bk][i]) >> 3; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(tempRight) = IM(ps->opd_prev[bk][i]) >> 3; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1646| |#else 1647| | RE(tempLeft) = MUL_F(RE(ps->ipd_prev[bk][i]), FRAC_CONST(0.25)); 1648| | IM(tempLeft) = MUL_F(IM(ps->ipd_prev[bk][i]), FRAC_CONST(0.25)); 1649| | RE(tempRight) = MUL_F(RE(ps->opd_prev[bk][i]), FRAC_CONST(0.25)); 1650| | IM(tempRight) = MUL_F(IM(ps->opd_prev[bk][i]), FRAC_CONST(0.25)); 1651| |#endif 1652| | 1653| | /* save current value */ 1654| 46.4k| RE(ps->ipd_prev[bk][i]) = ipdopd_cos_tab[abs(ps->ipd_index[env][bk])]; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1655| 46.4k| IM(ps->ipd_prev[bk][i]) = ipdopd_sin_tab[abs(ps->ipd_index[env][bk])]; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1656| 46.4k| RE(ps->opd_prev[bk][i]) = ipdopd_cos_tab[abs(ps->opd_index[env][bk])]; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1657| 46.4k| IM(ps->opd_prev[bk][i]) = ipdopd_sin_tab[abs(ps->opd_index[env][bk])]; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1658| | 1659| | /* add current value */ 1660| 46.4k|#ifdef FIXED_POINT 1661| | /* extra halving to avoid overflows */ 1662| 46.4k| RE(tempLeft) += RE(ps->ipd_prev[bk][i]) >> 1; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(tempLeft) += RE(ps->ipd_prev[bk][i]) >> 1; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1663| 46.4k| IM(tempLeft) += IM(ps->ipd_prev[bk][i]) >> 1; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(tempLeft) += IM(ps->ipd_prev[bk][i]) >> 1; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1664| 46.4k| RE(tempRight) += RE(ps->opd_prev[bk][i]) >> 1; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(tempRight) += RE(ps->opd_prev[bk][i]) >> 1; ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1665| 46.4k| IM(tempRight) += IM(ps->opd_prev[bk][i]) >> 1; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(tempRight) += IM(ps->opd_prev[bk][i]) >> 1; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1666| |#else 1667| | RE(tempLeft) += RE(ps->ipd_prev[bk][i]); 1668| | IM(tempLeft) += IM(ps->ipd_prev[bk][i]); 1669| | RE(tempRight) += RE(ps->opd_prev[bk][i]); 1670| | IM(tempRight) += IM(ps->opd_prev[bk][i]); 1671| |#endif 1672| | 1673| | /* ringbuffer index */ 1674| 46.4k| if (i == 0) ------------------ | Branch (1674:21): [True: 23.5k, False: 22.9k] ------------------ 1675| 23.5k| { 1676| 23.5k| i = 2; 1677| 23.5k| } 1678| 46.4k| i--; 1679| | 1680| | /* get value before previous */ 1681| 46.4k|#ifdef FIXED_POINT 1682| | /* dividing by 2*2, shift right 2 bits; extra halving to avoid overflows */ 1683| 46.4k| RE(tempLeft) += (RE(ps->ipd_prev[bk][i]) >> 2); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(tempLeft) += (RE(ps->ipd_prev[bk][i]) >> 2); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1684| 46.4k| IM(tempLeft) += (IM(ps->ipd_prev[bk][i]) >> 2); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(tempLeft) += (IM(ps->ipd_prev[bk][i]) >> 2); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1685| 46.4k| RE(tempRight) += (RE(ps->opd_prev[bk][i]) >> 2); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(tempRight) += (RE(ps->opd_prev[bk][i]) >> 2); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ 1686| 46.4k| IM(tempRight) += (IM(ps->opd_prev[bk][i]) >> 2); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(tempRight) += (IM(ps->opd_prev[bk][i]) >> 2); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1687| |#else 1688| | RE(tempLeft) += MUL_F(RE(ps->ipd_prev[bk][i]), FRAC_CONST(0.5)); 1689| | IM(tempLeft) += MUL_F(IM(ps->ipd_prev[bk][i]), FRAC_CONST(0.5)); 1690| | RE(tempRight) += MUL_F(RE(ps->opd_prev[bk][i]), FRAC_CONST(0.5)); 1691| | IM(tempRight) += MUL_F(IM(ps->opd_prev[bk][i]), FRAC_CONST(0.5)); 1692| |#endif 1693| | 1694| |#if 0 /* original code */ 1695| | ipd = (float)atan2(IM(tempLeft), RE(tempLeft)); 1696| | opd = (float)atan2(IM(tempRight), RE(tempRight)); 1697| | 1698| | /* phase rotation */ 1699| | RE(phaseLeft) = (float)cos(opd); 1700| | IM(phaseLeft) = (float)sin(opd); 1701| | opd -= ipd; 1702| | RE(phaseRight) = (float)cos(opd); 1703| | IM(phaseRight) = (float)sin(opd); 1704| |#else 1705| | 1706| | // x = IM(tempLeft) 1707| | // y = RE(tempLeft) 1708| | // p = IM(tempRight) 1709| | // q = RE(tempRight) 1710| | // cos(atan2(x,y)) = y/sqrt((x*x) + (y*y)) 1711| | // sin(atan2(x,y)) = x/sqrt((x*x) + (y*y)) 1712| | // cos(atan2(x,y)-atan2(p,q)) = (y*q + x*p) / ( sqrt((x*x) + (y*y)) * sqrt((p*p) + (q*q)) ); 1713| | // sin(atan2(x,y)-atan2(p,q)) = (x*q - y*p) / ( sqrt((x*x) + (y*y)) * sqrt((p*p) + (q*q)) ); 1714| | 1715| 46.4k| xy = magnitude_c(tempRight); 1716| 46.4k| pq = magnitude_c(tempLeft); 1717| | 1718| 46.4k| if (xy != 0) ------------------ | Branch (1718:21): [True: 46.4k, False: 0] ------------------ 1719| 46.4k| { 1720| 46.4k| RE(phaseLeft) = DIV_F(RE(tempRight), xy); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(phaseLeft) = DIV_F(RE(tempRight), xy); ------------------ | | 159| 46.4k|#define DIV_F(A, B) (((int64_t)A * FRAC_PRECISION)/B) | | ------------------ | | | | 53| 46.4k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 46.4k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ ------------------ 1721| 46.4k| IM(phaseLeft) = DIV_F(IM(tempRight), xy); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(phaseLeft) = DIV_F(IM(tempRight), xy); ------------------ | | 159| 46.4k|#define DIV_F(A, B) (((int64_t)A * FRAC_PRECISION)/B) | | ------------------ | | | | 53| 46.4k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 46.4k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ ------------------ 1722| 46.4k| } else { 1723| 0| RE(phaseLeft) = 0; ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 1724| 0| IM(phaseLeft) = 0; ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 1725| 0| } 1726| | 1727| 46.4k| xypq = MUL_F(xy, pq); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1728| | 1729| 46.4k| if (xypq != 0) ------------------ | Branch (1729:21): [True: 46.4k, False: 0] ------------------ 1730| 46.4k| { 1731| 46.4k| real_t tmp1 = MUL_F(RE(tempRight), RE(tempLeft)) + MUL_F(IM(tempRight), IM(tempLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ real_t tmp1 = MUL_F(RE(tempRight), RE(tempLeft)) + MUL_F(IM(tempRight), IM(tempLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1732| 46.4k| real_t tmp2 = MUL_F(IM(tempRight), RE(tempLeft)) - MUL_F(RE(tempRight), IM(tempLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ real_t tmp2 = MUL_F(IM(tempRight), RE(tempLeft)) - MUL_F(RE(tempRight), IM(tempLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1733| | 1734| 46.4k| RE(phaseRight) = DIV_F(tmp1, xypq); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(phaseRight) = DIV_F(tmp1, xypq); ------------------ | | 159| 46.4k|#define DIV_F(A, B) (((int64_t)A * FRAC_PRECISION)/B) | | ------------------ | | | | 53| 46.4k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 46.4k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ ------------------ 1735| 46.4k| IM(phaseRight) = DIV_F(tmp2, xypq); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(phaseRight) = DIV_F(tmp2, xypq); ------------------ | | 159| 46.4k|#define DIV_F(A, B) (((int64_t)A * FRAC_PRECISION)/B) | | ------------------ | | | | 53| 46.4k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 46.4k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ ------------------ 1736| 46.4k| } else { 1737| 0| RE(phaseRight) = 0; ------------------ | | 391| 0|#define RE(A) (A)[0] ------------------ 1738| 0| IM(phaseRight) = 0; ------------------ | | 392| 0|#define IM(A) (A)[1] ------------------ 1739| 0| } 1740| | 1741| 46.4k|#endif 1742| | 1743| | /* MUL_F(COEF, REAL) = COEF */ 1744| 46.4k| IM(h11) = MUL_F(RE(h11), IM(phaseLeft)); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(h11) = MUL_F(RE(h11), IM(phaseLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1745| 46.4k| IM(h12) = MUL_F(RE(h12), IM(phaseRight)); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(h12) = MUL_F(RE(h12), IM(phaseRight)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1746| 46.4k| IM(h21) = MUL_F(RE(h21), IM(phaseLeft)); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(h21) = MUL_F(RE(h21), IM(phaseLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1747| 46.4k| IM(h22) = MUL_F(RE(h22), IM(phaseRight)); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(h22) = MUL_F(RE(h22), IM(phaseRight)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1748| | 1749| 46.4k| RE(h11) = MUL_F(RE(h11), RE(phaseLeft)); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(h11) = MUL_F(RE(h11), RE(phaseLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1750| 46.4k| RE(h12) = MUL_F(RE(h12), RE(phaseRight)); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(h12) = MUL_F(RE(h12), RE(phaseRight)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1751| 46.4k| RE(h21) = MUL_F(RE(h21), RE(phaseLeft)); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(h21) = MUL_F(RE(h21), RE(phaseLeft)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1752| 46.4k| RE(h22) = MUL_F(RE(h22), RE(phaseRight)); ------------------ | | 391| 46.4k|#define RE(A) (A)[0] ------------------ RE(h22) = MUL_F(RE(h22), RE(phaseRight)); ------------------ | | 268| 46.4k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 46.4k|#define FRAC_BITS 31 | | ------------------ ------------------ 1753| 46.4k| } 1754| | 1755| | /* length of the envelope n_e+1 - n_e (in time samples) */ 1756| | /* 0 < L <= 32: integer */ 1757| 267k| L = (real_t)(ps->border_position[env + 1] - ps->border_position[env]); 1758| | 1759| | /* obtain final H_xy by means of linear interpolation */ 1760| 267k| RE(deltaH11) = (RE(h11) - RE(ps->h11_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH11) = (RE(h11) - RE(ps->h11_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH11) = (RE(h11) - RE(ps->h11_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1761| 267k| RE(deltaH12) = (RE(h12) - RE(ps->h12_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH12) = (RE(h12) - RE(ps->h12_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH12) = (RE(h12) - RE(ps->h12_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1762| 267k| RE(deltaH21) = (RE(h21) - RE(ps->h21_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH21) = (RE(h21) - RE(ps->h21_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH21) = (RE(h21) - RE(ps->h21_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1763| 267k| RE(deltaH22) = (RE(h22) - RE(ps->h22_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH22) = (RE(h22) - RE(ps->h22_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(deltaH22) = (RE(h22) - RE(ps->h22_prev[gr])) / L; ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1764| | 1765| 267k| RE(H11) = RE(ps->h11_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(H11) = RE(ps->h11_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1766| 267k| RE(H12) = RE(ps->h12_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(H12) = RE(ps->h12_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1767| 267k| RE(H21) = RE(ps->h21_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(H21) = RE(ps->h21_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1768| 267k| RE(H22) = RE(ps->h22_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(H22) = RE(ps->h22_prev[gr]); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1769| 267k| IM(H11) = IM(H12) = IM(H21) = IM(H22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ IM(H11) = IM(H12) = IM(H21) = IM(H22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ IM(H11) = IM(H12) = IM(H21) = IM(H22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ IM(H11) = IM(H12) = IM(H21) = IM(H22) = 0; ------------------ | | 392| 267k|#define IM(A) (A)[1] ------------------ 1770| | 1771| 267k| RE(ps->h11_prev[gr]) = RE(h11); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(ps->h11_prev[gr]) = RE(h11); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1772| 267k| RE(ps->h12_prev[gr]) = RE(h12); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(ps->h12_prev[gr]) = RE(h12); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1773| 267k| RE(ps->h21_prev[gr]) = RE(h21); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(ps->h21_prev[gr]) = RE(h21); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1774| 267k| RE(ps->h22_prev[gr]) = RE(h22); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ RE(ps->h22_prev[gr]) = RE(h22); ------------------ | | 391| 267k|#define RE(A) (A)[0] ------------------ 1775| | 1776| | /* only calculate imaginary part when needed */ 1777| 267k| if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par)) ------------------ | Branch (1777:17): [True: 80.3k, False: 187k] | Branch (1777:40): [True: 46.4k, False: 33.8k] ------------------ 1778| 46.4k| { 1779| | /* obtain final H_xy by means of linear interpolation */ 1780| 46.4k| IM(deltaH11) = (IM(h11) - IM(ps->h11_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH11) = (IM(h11) - IM(ps->h11_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH11) = (IM(h11) - IM(ps->h11_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1781| 46.4k| IM(deltaH12) = (IM(h12) - IM(ps->h12_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH12) = (IM(h12) - IM(ps->h12_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH12) = (IM(h12) - IM(ps->h12_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1782| 46.4k| IM(deltaH21) = (IM(h21) - IM(ps->h21_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH21) = (IM(h21) - IM(ps->h21_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH21) = (IM(h21) - IM(ps->h21_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1783| 46.4k| IM(deltaH22) = (IM(h22) - IM(ps->h22_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH22) = (IM(h22) - IM(ps->h22_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(deltaH22) = (IM(h22) - IM(ps->h22_prev[gr])) / L; ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1784| | 1785| 46.4k| IM(H11) = IM(ps->h11_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(H11) = IM(ps->h11_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1786| 46.4k| IM(H12) = IM(ps->h12_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(H12) = IM(ps->h12_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1787| 46.4k| IM(H21) = IM(ps->h21_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(H21) = IM(ps->h21_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1788| 46.4k| IM(H22) = IM(ps->h22_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(H22) = IM(ps->h22_prev[gr]); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1789| | 1790| 46.4k| if ((NEGATE_IPD_MASK & ps->map_group2bk[gr]) != 0) ------------------ | | 41| 46.4k|#define NEGATE_IPD_MASK (0x1000) ------------------ | Branch (1790:21): [True: 6.66k, False: 39.8k] ------------------ 1791| 6.66k| { 1792| 6.66k| IM(deltaH11) = -IM(deltaH11); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(deltaH11) = -IM(deltaH11); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1793| 6.66k| IM(deltaH12) = -IM(deltaH12); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(deltaH12) = -IM(deltaH12); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1794| 6.66k| IM(deltaH21) = -IM(deltaH21); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(deltaH21) = -IM(deltaH21); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1795| 6.66k| IM(deltaH22) = -IM(deltaH22); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(deltaH22) = -IM(deltaH22); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1796| | 1797| 6.66k| IM(H11) = -IM(H11); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(H11) = -IM(H11); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1798| 6.66k| IM(H12) = -IM(H12); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(H12) = -IM(H12); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1799| 6.66k| IM(H21) = -IM(H21); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(H21) = -IM(H21); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1800| 6.66k| IM(H22) = -IM(H22); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ IM(H22) = -IM(H22); ------------------ | | 392| 6.66k|#define IM(A) (A)[1] ------------------ 1801| 6.66k| } 1802| | 1803| 46.4k| IM(ps->h11_prev[gr]) = IM(h11); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(ps->h11_prev[gr]) = IM(h11); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1804| 46.4k| IM(ps->h12_prev[gr]) = IM(h12); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(ps->h12_prev[gr]) = IM(h12); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1805| 46.4k| IM(ps->h21_prev[gr]) = IM(h21); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(ps->h21_prev[gr]) = IM(h21); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1806| 46.4k| IM(ps->h22_prev[gr]) = IM(h22); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ IM(ps->h22_prev[gr]) = IM(h22); ------------------ | | 392| 46.4k|#define IM(A) (A)[1] ------------------ 1807| 46.4k| } 1808| | 1809| | /* apply H_xy to the current envelope band of the decorrelated subband */ 1810| 4.08M| for (n = ps->border_position[env]; n < ps->border_position[env + 1]; n++) ------------------ | Branch (1810:48): [True: 3.81M, False: 267k] ------------------ 1811| 3.81M| { 1812| | /* addition finalises the interpolation over every n */ 1813| 3.81M| RE(H11) += RE(deltaH11); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ RE(H11) += RE(deltaH11); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ 1814| 3.81M| RE(H12) += RE(deltaH12); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ RE(H12) += RE(deltaH12); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ 1815| 3.81M| RE(H21) += RE(deltaH21); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ RE(H21) += RE(deltaH21); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ 1816| 3.81M| RE(H22) += RE(deltaH22); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ RE(H22) += RE(deltaH22); ------------------ | | 391| 3.81M|#define RE(A) (A)[0] ------------------ 1817| 3.81M| if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par)) ------------------ | Branch (1817:21): [True: 841k, False: 2.97M] | Branch (1817:44): [True: 503k, False: 337k] ------------------ 1818| 503k| { 1819| 503k| IM(H11) += IM(deltaH11); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ IM(H11) += IM(deltaH11); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ 1820| 503k| IM(H12) += IM(deltaH12); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ IM(H12) += IM(deltaH12); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ 1821| 503k| IM(H21) += IM(deltaH21); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ IM(H21) += IM(deltaH21); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ 1822| 503k| IM(H22) += IM(deltaH22); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ IM(H22) += IM(deltaH22); ------------------ | | 392| 503k|#define IM(A) (A)[1] ------------------ 1823| 503k| } 1824| | 1825| | /* channel is an alias to the subband */ 1826| 13.0M| for (sb = ps->group_border[gr]; sb < maxsb; sb++) ------------------ | Branch (1826:49): [True: 9.24M, False: 3.81M] ------------------ 1827| 9.24M| { 1828| 9.24M| complex_t inLeft, inRight; // precision_of in(Left|Right) == precision_of X_(left|right) 1829| | 1830| | /* load decorrelated samples */ 1831| 9.24M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1831:25): [True: 2.13M, False: 7.10M] ------------------ 1832| 2.13M| { 1833| 2.13M| RE(inLeft) = RE(X_hybrid_left[n][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(inLeft) = RE(X_hybrid_left[n][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1834| 2.13M| IM(inLeft) = IM(X_hybrid_left[n][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(inLeft) = IM(X_hybrid_left[n][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1835| 2.13M| RE(inRight) = RE(X_hybrid_right[n][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(inRight) = RE(X_hybrid_right[n][sb]); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1836| 2.13M| IM(inRight) = IM(X_hybrid_right[n][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(inRight) = IM(X_hybrid_right[n][sb]); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1837| 7.10M| } else { 1838| 7.10M| RE(inLeft) = RE(X_left[n][sb]); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ RE(inLeft) = RE(X_left[n][sb]); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ 1839| 7.10M| IM(inLeft) = IM(X_left[n][sb]); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ IM(inLeft) = IM(X_left[n][sb]); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ 1840| 7.10M| RE(inRight) = RE(X_right[n][sb]); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ RE(inRight) = RE(X_right[n][sb]); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ 1841| 7.10M| IM(inRight) = IM(X_right[n][sb]); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ IM(inRight) = IM(X_right[n][sb]); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ 1842| 7.10M| } 1843| | 1844| | /* precision_of temp(Left|Right) == precision_of X_(left|right) */ 1845| | 1846| | /* apply mixing */ 1847| 9.24M| RE(tempLeft) = MUL_C(RE(H11), RE(inLeft)) + MUL_C(RE(H21), RE(inRight)); ------------------ | | 391| 9.24M|#define RE(A) (A)[0] ------------------ RE(tempLeft) = MUL_C(RE(H11), RE(inLeft)) + MUL_C(RE(H21), RE(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ RE(tempLeft) = MUL_C(RE(H11), RE(inLeft)) + MUL_C(RE(H21), RE(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ 1848| 9.24M| IM(tempLeft) = MUL_C(RE(H11), IM(inLeft)) + MUL_C(RE(H21), IM(inRight)); ------------------ | | 392| 9.24M|#define IM(A) (A)[1] ------------------ IM(tempLeft) = MUL_C(RE(H11), IM(inLeft)) + MUL_C(RE(H21), IM(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ IM(tempLeft) = MUL_C(RE(H11), IM(inLeft)) + MUL_C(RE(H21), IM(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ 1849| 9.24M| RE(tempRight) = MUL_C(RE(H12), RE(inLeft)) + MUL_C(RE(H22), RE(inRight)); ------------------ | | 391| 9.24M|#define RE(A) (A)[0] ------------------ RE(tempRight) = MUL_C(RE(H12), RE(inLeft)) + MUL_C(RE(H22), RE(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ RE(tempRight) = MUL_C(RE(H12), RE(inLeft)) + MUL_C(RE(H22), RE(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ 1850| 9.24M| IM(tempRight) = MUL_C(RE(H12), IM(inLeft)) + MUL_C(RE(H22), IM(inRight)); ------------------ | | 392| 9.24M|#define IM(A) (A)[1] ------------------ IM(tempRight) = MUL_C(RE(H12), IM(inLeft)) + MUL_C(RE(H22), IM(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ IM(tempRight) = MUL_C(RE(H12), IM(inLeft)) + MUL_C(RE(H22), IM(inRight)); ------------------ | | 241| 9.24M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 9.24M|#define COEF_BITS 28 | | ------------------ ------------------ 1851| | 1852| | /* only perform imaginary operations when needed */ 1853| 9.24M| if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par)) ------------------ | Branch (1853:25): [True: 2.23M, False: 7.01M] | Branch (1853:48): [True: 506k, False: 1.72M] ------------------ 1854| 506k| { 1855| | /* apply rotation */ 1856| 506k| RE(tempLeft) -= MUL_C(IM(H11), IM(inLeft)) + MUL_C(IM(H21), IM(inRight)); ------------------ | | 391| 506k|#define RE(A) (A)[0] ------------------ RE(tempLeft) -= MUL_C(IM(H11), IM(inLeft)) + MUL_C(IM(H21), IM(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ RE(tempLeft) -= MUL_C(IM(H11), IM(inLeft)) + MUL_C(IM(H21), IM(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ 1857| 506k| IM(tempLeft) += MUL_C(IM(H11), RE(inLeft)) + MUL_C(IM(H21), RE(inRight)); ------------------ | | 392| 506k|#define IM(A) (A)[1] ------------------ IM(tempLeft) += MUL_C(IM(H11), RE(inLeft)) + MUL_C(IM(H21), RE(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ IM(tempLeft) += MUL_C(IM(H11), RE(inLeft)) + MUL_C(IM(H21), RE(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ 1858| 506k| RE(tempRight) -= MUL_C(IM(H12), IM(inLeft)) + MUL_C(IM(H22), IM(inRight)); ------------------ | | 391| 506k|#define RE(A) (A)[0] ------------------ RE(tempRight) -= MUL_C(IM(H12), IM(inLeft)) + MUL_C(IM(H22), IM(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ RE(tempRight) -= MUL_C(IM(H12), IM(inLeft)) + MUL_C(IM(H22), IM(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ 1859| 506k| IM(tempRight) += MUL_C(IM(H12), RE(inLeft)) + MUL_C(IM(H22), RE(inRight)); ------------------ | | 392| 506k|#define IM(A) (A)[1] ------------------ IM(tempRight) += MUL_C(IM(H12), RE(inLeft)) + MUL_C(IM(H22), RE(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ IM(tempRight) += MUL_C(IM(H12), RE(inLeft)) + MUL_C(IM(H22), RE(inRight)); ------------------ | | 241| 506k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 506k|#define COEF_BITS 28 | | ------------------ ------------------ 1860| 506k| } 1861| | 1862| | /* store final samples */ 1863| 9.24M| if (gr < ps->num_hybrid_groups) ------------------ | Branch (1863:25): [True: 2.13M, False: 7.10M] ------------------ 1864| 2.13M| { 1865| 2.13M| RE(X_hybrid_left[n][sb]) = RE(tempLeft); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(X_hybrid_left[n][sb]) = RE(tempLeft); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1866| 2.13M| IM(X_hybrid_left[n][sb]) = IM(tempLeft); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(X_hybrid_left[n][sb]) = IM(tempLeft); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1867| 2.13M| RE(X_hybrid_right[n][sb]) = RE(tempRight); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ RE(X_hybrid_right[n][sb]) = RE(tempRight); ------------------ | | 391| 2.13M|#define RE(A) (A)[0] ------------------ 1868| 2.13M| IM(X_hybrid_right[n][sb]) = IM(tempRight); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ IM(X_hybrid_right[n][sb]) = IM(tempRight); ------------------ | | 392| 2.13M|#define IM(A) (A)[1] ------------------ 1869| 7.10M| } else { 1870| 7.10M| RE(X_left[n][sb]) = RE(tempLeft); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ RE(X_left[n][sb]) = RE(tempLeft); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ 1871| 7.10M| IM(X_left[n][sb]) = IM(tempLeft); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ IM(X_left[n][sb]) = IM(tempLeft); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ 1872| 7.10M| RE(X_right[n][sb]) = RE(tempRight); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ RE(X_right[n][sb]) = RE(tempRight); ------------------ | | 391| 7.10M|#define RE(A) (A)[0] ------------------ 1873| 7.10M| IM(X_right[n][sb]) = IM(tempRight); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ IM(X_right[n][sb]) = IM(tempRight); ------------------ | | 392| 7.10M|#define IM(A) (A)[1] ------------------ 1874| 7.10M| } 1875| 9.24M| } 1876| 3.81M| } 1877| | 1878| | /* shift phase smoother's circular buffer index */ 1879| 267k| ps->phase_hist++; 1880| 267k| if (ps->phase_hist == 2) ------------------ | Branch (1880:17): [True: 133k, False: 133k] ------------------ 1881| 133k| { 1882| 133k| ps->phase_hist = 0; 1883| 133k| } 1884| 267k| } 1885| 121k| } 1886| 3.76k|} ps_dec.c:magnitude_c: 1437| 92.9k|{ 1438| 92.9k|#ifdef FIXED_POINT 1439| 92.9k|#define ps_abs(A) (((A) > 0) ? (A) : (-(A))) 1440| 92.9k|#define ALPHA FRAC_CONST(0.948059448969) 1441| 92.9k|#define BETA FRAC_CONST(0.392699081699) 1442| | 1443| 92.9k| real_t abs_inphase = ps_abs(RE(c)); ------------------ | | 1439| 92.9k|#define ps_abs(A) (((A) > 0) ? (A) : (-(A))) | | ------------------ | | | Branch (1439:20): [True: 76.0k, False: 16.8k] | | ------------------ ------------------ 1444| 92.9k| real_t abs_quadrature = ps_abs(IM(c)); ------------------ | | 1439| 92.9k|#define ps_abs(A) (((A) > 0) ? (A) : (-(A))) | | ------------------ | | | Branch (1439:20): [True: 18.7k, False: 74.2k] | | ------------------ ------------------ 1445| | 1446| 92.9k| if (abs_inphase > abs_quadrature) { ------------------ | Branch (1446:9): [True: 76.7k, False: 16.2k] ------------------ 1447| 76.7k| return MUL_F(abs_inphase, ALPHA) + MUL_F(abs_quadrature, BETA); ------------------ | | 268| 306k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 76.7k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 76.7k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 76.7k, Folded] | | | Branch (268:55): [Folded, False: 76.7k] | | ------------------ ------------------ return MUL_F(abs_inphase, ALPHA) + MUL_F(abs_quadrature, BETA); ------------------ | | 268| 306k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 76.7k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 76.7k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 76.7k, Folded] | | | Branch (268:55): [Folded, False: 76.7k] | | ------------------ ------------------ 1448| 76.7k| } else { 1449| 16.2k| return MUL_F(abs_quadrature, ALPHA) + MUL_F(abs_inphase, BETA); ------------------ | | 268| 65.0k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16.2k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16.2k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 16.2k, Folded] | | | Branch (268:55): [Folded, False: 16.2k] | | ------------------ ------------------ return MUL_F(abs_quadrature, ALPHA) + MUL_F(abs_inphase, BETA); ------------------ | | 268| 65.0k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16.2k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16.2k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 16.2k, Folded] | | | Branch (268:55): [Folded, False: 16.2k] | | ------------------ ------------------ 1450| 16.2k| } 1451| |#else 1452| | return sqrt(RE(c)*RE(c) + IM(c)*IM(c)); 1453| |#endif 1454| 92.9k|} ps_dec.c:hybrid_synthesis: 588| 7.52k|{ 589| 7.52k| uint8_t k, n, band; 590| 7.52k| uint8_t offset = 0; 591| 7.52k| uint8_t qmf_bands = (use34) ? 5 : 3; ------------------ | Branch (591:25): [True: 2.80k, False: 4.72k] ------------------ 592| 7.52k| uint8_t *resolution = (use34) ? hyb->resolution34 : hyb->resolution20; ------------------ | Branch (592:27): [True: 2.80k, False: 4.72k] ------------------ 593| 7.52k| (void)numTimeSlotsRate; /* TODO: remove parameter? */ 594| | 595| 35.6k| for(band = 0; band < qmf_bands; band++) ------------------ | Branch (595:19): [True: 28.1k, False: 7.52k] ------------------ 596| 28.1k| { 597| 908k| for (n = 0; n < hyb->frame_len; n++) ------------------ | Branch (597:21): [True: 879k, False: 28.1k] ------------------ 598| 879k| { 599| 879k| QMF_RE(X[n][band]) = 0; ------------------ | | 168| 879k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 879k|#define RE(A) (A)[0] | | ------------------ ------------------ 600| 879k| QMF_IM(X[n][band]) = 0; ------------------ | | 169| 879k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 879k|#define IM(A) (A)[1] | | ------------------ ------------------ 601| | 602| 5.44M| for (k = 0; k < resolution[band]; k++) ------------------ | Branch (602:25): [True: 4.56M, False: 879k] ------------------ 603| 4.56M| { 604| 4.56M| QMF_RE(X[n][band]) += QMF_RE(X_hybrid[n][offset + k]); ------------------ | | 168| 4.56M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 4.56M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X[n][band]) += QMF_RE(X_hybrid[n][offset + k]); ------------------ | | 168| 4.56M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 4.56M|#define RE(A) (A)[0] | | ------------------ ------------------ 605| 4.56M| QMF_IM(X[n][band]) += QMF_IM(X_hybrid[n][offset + k]); ------------------ | | 169| 4.56M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 4.56M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X[n][band]) += QMF_IM(X_hybrid[n][offset + k]); ------------------ | | 169| 4.56M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 4.56M|#define IM(A) (A)[1] | | ------------------ ------------------ 606| 4.56M| } 607| 879k| } 608| 28.1k| offset += resolution[band]; 609| 28.1k| } 610| 7.52k|} ps_data: 329| 27.2k|{ 330| 27.2k| uint8_t tmp, n; 331| 27.2k| uint16_t bits = (uint16_t)faad_get_processed_bits(ld); 332| | 333| 27.2k| *header = 0; 334| | 335| | /* check for new PS header */ 336| 27.2k| if (faad_get1bit(ld ------------------ | Branch (336:9): [True: 14.0k, False: 13.2k] ------------------ 337| 27.2k| DEBUGVAR(1,1000,"ps_data(): enable_ps_header"))) 338| 14.0k| { 339| 14.0k| *header = 1; 340| | 341| 14.0k| ps->header_read = 1; 342| | 343| 14.0k| ps->use34hybrid_bands = 0; 344| | 345| | /* Inter-channel Intensity Difference (IID) parameters enabled */ 346| 14.0k| ps->enable_iid = (uint8_t)faad_get1bit(ld 347| 14.0k| DEBUGVAR(1,1001,"ps_data(): enable_iid")); 348| | 349| 14.0k| if (ps->enable_iid) ------------------ | Branch (349:13): [True: 5.62k, False: 8.44k] ------------------ 350| 5.62k| { 351| 5.62k| ps->iid_mode = (uint8_t)faad_getbits(ld, 3 352| 5.62k| DEBUGVAR(1,1002,"ps_data(): iid_mode")); 353| | 354| 5.62k| ps->nr_iid_par = nr_iid_par_tab[ps->iid_mode]; 355| 5.62k| ps->nr_ipdopd_par = nr_ipdopd_par_tab[ps->iid_mode]; 356| | 357| 5.62k| if (ps->iid_mode == 2 || ps->iid_mode == 5) ------------------ | Branch (357:17): [True: 1.04k, False: 4.57k] | Branch (357:38): [True: 370, False: 4.20k] ------------------ 358| 1.41k| ps->use34hybrid_bands = 1; 359| | 360| | /* IPD freq res equal to IID freq res */ 361| 5.62k| ps->ipd_mode = ps->iid_mode; 362| 5.62k| } 363| | 364| | /* Inter-channel Coherence (ICC) parameters enabled */ 365| 14.0k| ps->enable_icc = (uint8_t)faad_get1bit(ld 366| 14.0k| DEBUGVAR(1,1003,"ps_data(): enable_icc")); 367| | 368| 14.0k| if (ps->enable_icc) ------------------ | Branch (368:13): [True: 4.31k, False: 9.75k] ------------------ 369| 4.31k| { 370| 4.31k| ps->icc_mode = (uint8_t)faad_getbits(ld, 3 371| 4.31k| DEBUGVAR(1,1004,"ps_data(): icc_mode")); 372| | 373| 4.31k| ps->nr_icc_par = nr_icc_par_tab[ps->icc_mode]; 374| | 375| 4.31k| if (ps->icc_mode == 2 || ps->icc_mode == 5) ------------------ | Branch (375:17): [True: 1.19k, False: 3.11k] | Branch (375:38): [True: 370, False: 2.74k] ------------------ 376| 1.56k| ps->use34hybrid_bands = 1; 377| 4.31k| } 378| | 379| | /* PS extension layer enabled */ 380| 14.0k| ps->enable_ext = (uint8_t)faad_get1bit(ld 381| 14.0k| DEBUGVAR(1,1005,"ps_data(): enable_ext")); 382| 14.0k| } 383| | 384| | /* we are here, but no header has been read yet */ 385| 27.2k| if (ps->header_read == 0) ------------------ | Branch (385:9): [True: 5.44k, False: 21.8k] ------------------ 386| 5.44k| { 387| 5.44k| ps->ps_data_available = 0; 388| 5.44k| return 1; 389| 5.44k| } 390| | 391| 21.8k| ps->frame_class = (uint8_t)faad_get1bit(ld 392| 21.8k| DEBUGVAR(1,1006,"ps_data(): frame_class")); 393| 21.8k| tmp = (uint8_t)faad_getbits(ld, 2 394| 21.8k| DEBUGVAR(1,1007,"ps_data(): num_env_idx")); 395| | 396| 21.8k| ps->num_env = num_env_tab[ps->frame_class][tmp]; 397| | 398| 21.8k| if (ps->frame_class) ------------------ | Branch (398:9): [True: 9.40k, False: 12.4k] ------------------ 399| 9.40k| { 400| 37.2k| for (n = 1; n < ps->num_env+1; n++) ------------------ | Branch (400:21): [True: 27.8k, False: 9.40k] ------------------ 401| 27.8k| { 402| 27.8k| ps->border_position[n] = (uint8_t)faad_getbits(ld, 5 403| 27.8k| DEBUGVAR(1,1008,"ps_data(): border_position")) + 1; 404| 27.8k| } 405| 9.40k| } 406| | 407| 21.8k| if (ps->enable_iid) ------------------ | Branch (407:9): [True: 7.82k, False: 14.0k] ------------------ 408| 7.82k| { 409| 23.9k| for (n = 0; n < ps->num_env; n++) ------------------ | Branch (409:21): [True: 16.1k, False: 7.82k] ------------------ 410| 16.1k| { 411| 16.1k| ps->iid_dt[n] = (uint8_t)faad_get1bit(ld 412| 16.1k| DEBUGVAR(1,1009,"ps_data(): iid_dt")); 413| | 414| | /* iid_data */ 415| 16.1k| if (ps->iid_mode < 3) ------------------ | Branch (415:17): [True: 3.66k, False: 12.4k] ------------------ 416| 3.66k| { 417| 3.66k| huff_data(ld, ps->iid_dt[n], ps->nr_iid_par, t_huff_iid_def, 418| 3.66k| f_huff_iid_def, ps->iid_index[n]); 419| 12.4k| } else { 420| 12.4k| huff_data(ld, ps->iid_dt[n], ps->nr_iid_par, t_huff_iid_fine, 421| 12.4k| f_huff_iid_fine, ps->iid_index[n]); 422| 12.4k| } 423| 16.1k| } 424| 7.82k| } 425| | 426| 21.8k| if (ps->enable_icc) ------------------ | Branch (426:9): [True: 5.59k, False: 16.2k] ------------------ 427| 5.59k| { 428| 17.4k| for (n = 0; n < ps->num_env; n++) ------------------ | Branch (428:21): [True: 11.8k, False: 5.59k] ------------------ 429| 11.8k| { 430| 11.8k| ps->icc_dt[n] = (uint8_t)faad_get1bit(ld 431| 11.8k| DEBUGVAR(1,1010,"ps_data(): icc_dt")); 432| | 433| | /* icc_data */ 434| 11.8k| huff_data(ld, ps->icc_dt[n], ps->nr_icc_par, t_huff_icc, 435| 11.8k| f_huff_icc, ps->icc_index[n]); 436| 11.8k| } 437| 5.59k| } 438| | 439| 21.8k| if (ps->enable_ext) ------------------ | Branch (439:9): [True: 5.72k, False: 16.1k] ------------------ 440| 5.72k| { 441| 5.72k| uint16_t num_bits_left; 442| 5.72k| uint16_t cnt = (uint16_t)faad_getbits(ld, 4 443| 5.72k| DEBUGVAR(1,1011,"ps_data(): ps_extension_size")); 444| 5.72k| if (cnt == 15) ------------------ | Branch (444:13): [True: 443, False: 5.28k] ------------------ 445| 443| { 446| 443| cnt += (uint16_t)faad_getbits(ld, 8 447| 443| DEBUGVAR(1,1012,"ps_data(): esc_count")); 448| 443| } 449| | 450| 5.72k| num_bits_left = 8 * cnt; 451| 5.28M| while (num_bits_left > 7) ------------------ | Branch (451:16): [True: 5.27M, False: 5.72k] ------------------ 452| 5.27M| { 453| 5.27M| uint8_t ps_extension_id = (uint8_t)faad_getbits(ld, 2 454| 5.27M| DEBUGVAR(1,1013,"ps_data(): ps_extension_size")); 455| | 456| 5.27M| num_bits_left -= 2; 457| 5.27M| num_bits_left -= ps_extension(ps, ld, ps_extension_id, num_bits_left); 458| 5.27M| } 459| | 460| 5.72k| faad_getbits(ld, num_bits_left 461| 5.72k| DEBUGVAR(1,1014,"ps_data(): fill_bits")); 462| 5.72k| } 463| | 464| 21.8k| bits = (uint16_t)faad_get_processed_bits(ld) - bits; 465| | 466| 21.8k| ps->ps_data_available = 1; 467| | 468| 21.8k| return bits; 469| 27.2k|} ps_syntax.c:ps_extension: 474| 5.27M|{ 475| 5.27M| uint8_t n; 476| 5.27M| uint16_t bits = (uint16_t)faad_get_processed_bits(ld); 477| 5.27M| (void)num_bits_left; /* TODO: remove parameter, or actually use it. */ 478| | 479| 5.27M| if (ps_extension_id == 0) ------------------ | Branch (479:9): [True: 5.20M, False: 68.6k] ------------------ 480| 5.20M| { 481| 5.20M| ps->enable_ipdopd = (uint8_t)faad_get1bit(ld 482| 5.20M| DEBUGVAR(1,1015,"ps_extension(): enable_ipdopd")); 483| | 484| 5.20M| if (ps->enable_ipdopd) ------------------ | Branch (484:13): [True: 10.4k, False: 5.19M] ------------------ 485| 10.4k| { 486| 38.5k| for (n = 0; n < ps->num_env; n++) ------------------ | Branch (486:25): [True: 28.0k, False: 10.4k] ------------------ 487| 28.0k| { 488| 28.0k| ps->ipd_dt[n] = (uint8_t)faad_get1bit(ld 489| 28.0k| DEBUGVAR(1,1016,"ps_extension(): ipd_dt")); 490| | 491| | /* ipd_data */ 492| 28.0k| huff_data(ld, ps->ipd_dt[n], ps->nr_ipdopd_par, t_huff_ipd, 493| 28.0k| f_huff_ipd, ps->ipd_index[n]); 494| | 495| 28.0k| ps->opd_dt[n] = (uint8_t)faad_get1bit(ld 496| 28.0k| DEBUGVAR(1,1017,"ps_extension(): opd_dt")); 497| | 498| | /* opd_data */ 499| 28.0k| huff_data(ld, ps->opd_dt[n], ps->nr_ipdopd_par, t_huff_opd, 500| 28.0k| f_huff_opd, ps->opd_index[n]); 501| 28.0k| } 502| 10.4k| } 503| 5.20M| faad_get1bit(ld 504| 5.20M| DEBUGVAR(1,1018,"ps_extension(): reserved_ps")); 505| 5.20M| } 506| | 507| | /* return number of bits read */ 508| 5.27M| bits = (uint16_t)faad_get_processed_bits(ld) - bits; 509| | 510| 5.27M| return bits; 511| 5.27M|} ps_syntax.c:huff_data: 516| 84.1k|{ 517| 84.1k| uint8_t n; 518| | 519| 84.1k| if (dt) ------------------ | Branch (519:9): [True: 34.7k, False: 49.3k] ------------------ 520| 34.7k| { 521| | /* coded in time direction */ 522| 168k| for (n = 0; n < nr_par; n++) ------------------ | Branch (522:21): [True: 133k, False: 34.7k] ------------------ 523| 133k| { 524| 133k| par[n] = ps_huff_dec(ld, t_huff); 525| 133k| } 526| 49.3k| } else { 527| | /* coded in frequency direction */ 528| 49.3k| par[0] = ps_huff_dec(ld, f_huff); 529| | 530| 299k| for (n = 1; n < nr_par; n++) ------------------ | Branch (530:21): [True: 249k, False: 49.3k] ------------------ 531| 249k| { 532| 249k| par[n] = ps_huff_dec(ld, f_huff); 533| 249k| } 534| 49.3k| } 535| 84.1k|} ps_syntax.c:ps_huff_dec: 539| 432k|{ 540| 432k| uint8_t bit; 541| 432k| int8_t index = 0; 542| | 543| 1.35M| while (index >= 0) ------------------ | Branch (543:12): [True: 922k, False: 432k] ------------------ 544| 922k| { 545| 922k| bit = (uint8_t)faad_get1bit(ld); 546| 922k| index = t_huff[index][bit]; 547| 922k| } 548| | 549| 432k| return index + 31; 550| 432k|} pulse_decode: 37| 1.04k|{ 38| 1.04k| uint8_t i; 39| 1.04k| uint16_t k; 40| 1.04k| pulse_info *pul = &(ics->pul); 41| | 42| 1.04k| k = min(ics->swb_offset[pul->pulse_start_sfb], ics->swb_offset_max); ------------------ | | 60| 1.04k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 1.04k, False: 0] | | ------------------ ------------------ 43| | 44| 3.81k| for (i = 0; i <= pul->number_pulse; i++) ------------------ | Branch (44:17): [True: 2.76k, False: 1.04k] ------------------ 45| 2.76k| { 46| 2.76k| k += pul->pulse_offset[i]; 47| | 48| 2.76k| if (k >= framelen) ------------------ | Branch (48:13): [True: 0, False: 2.76k] ------------------ 49| 0| return 15; /* should not be possible */ 50| | 51| 2.76k| if (spec_data[k] > 0) ------------------ | Branch (51:13): [True: 192, False: 2.57k] ------------------ 52| 192| spec_data[k] += pul->pulse_amp[i]; 53| 2.57k| else 54| 2.57k| spec_data[k] -= pul->pulse_amp[i]; 55| 2.76k| } 56| | 57| 1.04k| return 0; 58| 1.04k|} rvlc_scale_factor_data: 75| 1.94k|{ 76| 1.94k| uint8_t bits = 9; 77| | 78| 1.94k| ics->sf_concealment = faad_get1bit(ld 79| 1.94k| DEBUGVAR(1,149,"rvlc_scale_factor_data(): sf_concealment")); 80| 1.94k| ics->rev_global_gain = (uint8_t)faad_getbits(ld, 8 81| 1.94k| DEBUGVAR(1,150,"rvlc_scale_factor_data(): rev_global_gain")); 82| | 83| 1.94k| if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 1.94k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (83:9): [True: 245, False: 1.69k] ------------------ 84| 245| bits = 11; 85| | 86| | /* the number of bits used for the huffman codewords */ 87| 1.94k| ics->length_of_rvlc_sf = (uint16_t)faad_getbits(ld, bits 88| 1.94k| DEBUGVAR(1,151,"rvlc_scale_factor_data(): length_of_rvlc_sf")); 89| | 90| 1.94k| if (ics->noise_used) ------------------ | Branch (90:9): [True: 0, False: 1.94k] ------------------ 91| 0| { 92| 0| ics->dpcm_noise_nrg = (uint16_t)faad_getbits(ld, 9 93| 0| DEBUGVAR(1,152,"rvlc_scale_factor_data(): dpcm_noise_nrg")); 94| | 95| | /* the 9 bits of dpcm_noise_nrg are counted in length_of_rvlc_sf, so a 96| | conformant value is at least 9; reject a smaller one before the 97| | unsigned subtraction wraps length_of_rvlc_sf to a huge value */ 98| 0| if (ics->length_of_rvlc_sf < 9) ------------------ | Branch (98:13): [True: 0, False: 0] ------------------ 99| 0| return 8; 100| | 101| 0| ics->length_of_rvlc_sf -= 9; 102| 0| } 103| | 104| 1.94k| ics->sf_escapes_present = faad_get1bit(ld 105| 1.94k| DEBUGVAR(1,153,"rvlc_scale_factor_data(): sf_escapes_present")); 106| | 107| 1.94k| if (ics->sf_escapes_present) ------------------ | Branch (107:9): [True: 366, False: 1.57k] ------------------ 108| 366| { 109| 366| ics->length_of_rvlc_escapes = (uint8_t)faad_getbits(ld, 8 110| 366| DEBUGVAR(1,154,"rvlc_scale_factor_data(): length_of_rvlc_escapes")); 111| 366| } 112| | 113| 1.94k| if (ics->noise_used) ------------------ | Branch (113:9): [True: 0, False: 1.94k] ------------------ 114| 0| { 115| 0| ics->dpcm_noise_last_position = (uint16_t)faad_getbits(ld, 9 116| 0| DEBUGVAR(1,155,"rvlc_scale_factor_data(): dpcm_noise_last_position")); 117| 0| } 118| | 119| 1.94k| return 0; 120| 1.94k|} rvlc_decode_scale_factors: 123| 1.93k|{ 124| 1.93k| uint8_t result; 125| 1.93k| uint8_t intensity_used = 0; 126| 1.93k| uint8_t *rvlc_sf_buffer = NULL; 127| 1.93k| uint8_t *rvlc_esc_buffer = NULL; 128| 1.93k| bitfile ld_rvlc_sf = {0}, ld_rvlc_esc = {0}; 129| |// bitfile ld_rvlc_sf_rev, ld_rvlc_esc_rev; 130| | 131| 1.93k| if (ics->length_of_rvlc_sf > 0) ------------------ | Branch (131:9): [True: 687, False: 1.25k] ------------------ 132| 687| { 133| | /* We read length_of_rvlc_sf bits here to put it in a 134| | seperate bitfile. 135| | */ 136| 687| rvlc_sf_buffer = faad_getbitbuffer(ld, ics->length_of_rvlc_sf 137| 687| DEBUGVAR(1,156,"rvlc_decode_scale_factors(): bitbuffer: length_of_rvlc_sf")); 138| | 139| 687| faad_initbits(&ld_rvlc_sf, (void*)rvlc_sf_buffer, bit2byte(ics->length_of_rvlc_sf)); ------------------ | | 46| 687|#define bit2byte(a) ((a+7)>>BYTE_NUMBIT_LD) | | ------------------ | | | | 44| 687|#define BYTE_NUMBIT_LD 3 | | ------------------ ------------------ 140| |// faad_initbits_rev(&ld_rvlc_sf_rev, (void*)rvlc_sf_buffer, 141| |// ics->length_of_rvlc_sf); 142| 687| } 143| 1.93k| if ((ics->length_of_rvlc_sf == 0) || (ld_rvlc_sf.error != 0)) { ------------------ | Branch (143:9): [True: 1.25k, False: 687] | Branch (143:42): [True: 0, False: 687] ------------------ 144| 1.25k| memset(&ld_rvlc_sf, 0, sizeof(ld_rvlc_sf)); 145| 1.25k| ld_rvlc_sf.error = 1; 146| 1.25k| } 147| | 148| 1.93k| if (ics->sf_escapes_present) ------------------ | Branch (148:9): [True: 365, False: 1.57k] ------------------ 149| 365| { 150| | /* We read length_of_rvlc_escapes bits here to put it in a 151| | seperate bitfile. 152| | */ 153| 365| rvlc_esc_buffer = faad_getbitbuffer(ld, ics->length_of_rvlc_escapes 154| 365| DEBUGVAR(1,157,"rvlc_decode_scale_factors(): bitbuffer: length_of_rvlc_escapes")); 155| | 156| 365| faad_initbits(&ld_rvlc_esc, (void*)rvlc_esc_buffer, bit2byte(ics->length_of_rvlc_escapes)); ------------------ | | 46| 365|#define bit2byte(a) ((a+7)>>BYTE_NUMBIT_LD) | | ------------------ | | | | 44| 365|#define BYTE_NUMBIT_LD 3 | | ------------------ ------------------ 157| |// faad_initbits_rev(&ld_rvlc_esc_rev, (void*)rvlc_esc_buffer, 158| |// ics->length_of_rvlc_escapes); 159| 365| } 160| 1.93k| if (!ics->sf_escapes_present || (ld_rvlc_esc.error != 0)) { ------------------ | Branch (160:9): [True: 1.57k, False: 365] | Branch (160:37): [True: 229, False: 136] ------------------ 161| 1.80k| memset(&ld_rvlc_esc, 0, sizeof(ld_rvlc_esc)); 162| 1.80k| ld_rvlc_esc.error = 1; 163| 1.80k| } 164| | 165| | /* decode the rvlc scale factors and escapes */ 166| 1.93k| result = rvlc_decode_sf_forward(ics, &ld_rvlc_sf, 167| 1.93k| &ld_rvlc_esc, &intensity_used); 168| |// result = rvlc_decode_sf_reverse(ics, &ld_rvlc_sf_rev, 169| |// &ld_rvlc_esc_rev, intensity_used); 170| | 171| | 172| 1.93k| if (rvlc_esc_buffer) faad_free(rvlc_esc_buffer); ------------------ | Branch (172:9): [True: 365, False: 1.57k] ------------------ 173| 1.93k| if (rvlc_sf_buffer) faad_free(rvlc_sf_buffer); ------------------ | Branch (173:9): [True: 687, False: 1.25k] ------------------ 174| | 175| 1.93k| if (ics->length_of_rvlc_sf > 0) ------------------ | Branch (175:9): [True: 687, False: 1.25k] ------------------ 176| 687| faad_endbits(&ld_rvlc_sf); 177| 1.93k| if (ics->sf_escapes_present) ------------------ | Branch (177:9): [True: 365, False: 1.57k] ------------------ 178| 365| faad_endbits(&ld_rvlc_esc); 179| | 180| 1.93k| return result; 181| 1.93k|} rvlc.c:rvlc_decode_sf_forward: 185| 1.93k|{ 186| 1.93k| int8_t g, sfb; 187| 1.93k| int8_t t = 0; 188| 1.93k| int8_t error = ld_sf->error | ld_esc->error; 189| 1.93k| int8_t noise_pcm_flag = 1; 190| | 191| 1.93k| int16_t scale_factor = ics->global_gain; 192| 1.93k| int16_t is_position = 0; 193| 1.93k| int16_t noise_energy = ics->global_gain - 90 - 256; 194| 1.93k| int16_t scale_factor_max = 255; 195| 1.93k|#ifdef FIXED_POINT 196| | /* TODO: consider rolling out to regular build. */ 197| 1.93k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 198| | /* The value is inexact, adjusted to current fuzzer findings. */ 199| 1.93k| scale_factor_max = 165; 200| 1.93k|#endif // FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 201| 1.93k|#endif // FIXED_POINT 202| | 203| |#ifdef PRINT_RVLC 204| | printf("\nglobal_gain: %d\n", ics->global_gain); 205| |#endif 206| | 207| 5.35k| for (g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (207:17): [True: 3.41k, False: 1.93k] ------------------ 208| 3.41k| { 209| 10.7k| for (sfb = 0; sfb < ics->max_sfb; sfb++) ------------------ | Branch (209:23): [True: 7.37k, False: 3.41k] ------------------ 210| 7.37k| { 211| 7.37k| if (error) ------------------ | Branch (211:17): [True: 4.72k, False: 2.64k] ------------------ 212| 4.72k| { 213| 4.72k| ics->scale_factors[g][sfb] = 0; 214| 4.72k| } else { 215| 2.64k| switch (ics->sfb_cb[g][sfb]) 216| 2.64k| { 217| 57| case ZERO_HCB: /* zero book */ ------------------ | | 101| 57|#define ZERO_HCB 0 ------------------ | Branch (217:17): [True: 57, False: 2.59k] ------------------ 218| 57| ics->scale_factors[g][sfb] = 0; 219| 57| break; 220| 1.08k| case INTENSITY_HCB: /* intensity books */ ------------------ | | 108| 1.08k|#define INTENSITY_HCB 15 ------------------ | Branch (220:17): [True: 1.08k, False: 1.56k] ------------------ 221| 1.15k| case INTENSITY_HCB2: ------------------ | | 107| 1.15k|#define INTENSITY_HCB2 14 ------------------ | Branch (221:17): [True: 71, False: 2.57k] ------------------ 222| | 223| 1.15k| *intensity_used = 1; 224| | 225| | /* decode intensity position */ 226| 1.15k| t = rvlc_huffman_sf(ld_sf, ld_esc /*, +1*/); 227| | 228| 1.15k| is_position += t; 229| 1.15k| ics->scale_factors[g][sfb] = is_position; 230| | 231| 1.15k| break; 232| 0| case NOISE_HCB: /* noise books */ ------------------ | | 106| 0|#define NOISE_HCB 13 ------------------ | Branch (232:17): [True: 0, False: 2.64k] ------------------ 233| | 234| | /* decode noise energy */ 235| 0| if (noise_pcm_flag) ------------------ | Branch (235:25): [True: 0, False: 0] ------------------ 236| 0| { 237| 0| int16_t n = ics->dpcm_noise_nrg; 238| 0| noise_pcm_flag = 0; 239| 0| noise_energy += n; 240| 0| } else { 241| 0| t = rvlc_huffman_sf(ld_sf, ld_esc /*, +1*/); 242| 0| noise_energy += t; 243| 0| } 244| | 245| 0| ics->scale_factors[g][sfb] = noise_energy; 246| | 247| 0| break; 248| 1.43k| default: /* spectral books */ ------------------ | Branch (248:17): [True: 1.43k, False: 1.20k] ------------------ 249| | 250| | /* decode scale factor */ 251| 1.43k| t = rvlc_huffman_sf(ld_sf, ld_esc /*, +1*/); 252| | 253| 1.43k| scale_factor += t; 254| 1.43k| if (scale_factor < 0 || scale_factor > 255) ------------------ | Branch (254:25): [True: 2, False: 1.43k] | Branch (254:45): [True: 2, False: 1.43k] ------------------ 255| 4| return 4; 256| | 257| 1.43k| ics->scale_factors[g][sfb] = min(scale_factor, scale_factor_max); ------------------ | | 60| 1.43k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 886, False: 549] | | ------------------ ------------------ 258| | 259| 1.43k| break; 260| 2.64k| } 261| |#ifdef PRINT_RVLC 262| | printf("%3d:%4d%4d\n", sfb, ics->sfb_cb[g][sfb], 263| | ics->scale_factors[g][sfb]); 264| |#endif 265| 2.64k| if (t == 99) ------------------ | Branch (265:21): [True: 8, False: 2.63k] ------------------ 266| 8| { 267| 8| error = 1; 268| 8| } 269| 2.64k| } 270| 7.37k| } 271| 3.41k| } 272| |#ifdef PRINT_RVLC 273| | printf("\n\n"); 274| |#endif 275| | 276| 1.93k| return 0; 277| 1.93k|} rvlc.c:rvlc_huffman_sf: 474| 2.59k|{ 475| 2.59k| uint16_t i, j; 476| 2.59k| int16_t index; 477| 2.59k| uint32_t cw; 478| 2.59k| rvlc_huff_table *h = book_rvlc; 479| 2.59k| int8_t direction = +1; 480| | 481| 2.59k| i = h->len; 482| 2.59k| if (direction > 0) ------------------ | Branch (482:9): [True: 2.59k, False: 0] ------------------ 483| 2.59k| cw = faad_getbits(ld_sf, i DEBUGVAR(1,0,"")); 484| 0| else 485| 0| cw = 0 /* faad_getbits_rev(ld_sf, i DEBUGVAR(1,0,"")) */; 486| | 487| 8.82k| while ((cw != h->cw) ------------------ | Branch (487:12): [True: 6.23k, False: 2.59k] ------------------ 488| 6.23k| && (i < 10)) ------------------ | Branch (488:12): [True: 6.23k, False: 0] ------------------ 489| 6.23k| { 490| 6.23k| h++; 491| 6.23k| j = h->len-i; 492| 6.23k| i += j; 493| 6.23k| cw <<= j; 494| 6.23k| if (direction > 0) ------------------ | Branch (494:13): [True: 6.23k, False: 0] ------------------ 495| 6.23k| cw |= faad_getbits(ld_sf, j DEBUGVAR(1,0,"")); 496| 0| else 497| 0| cw |= 0 /* faad_getbits_rev(ld_sf, j DEBUGVAR(1,0,"")) */; 498| 6.23k| } 499| | 500| 2.59k| index = h->index; 501| | 502| 2.59k| if (index == +ESC_VAL) ------------------ | | 46| 2.59k|#define ESC_VAL 7 ------------------ | Branch (502:9): [True: 44, False: 2.54k] ------------------ 503| 44| { 504| 44| int8_t esc = rvlc_huffman_esc(ld_esc /*, direction*/); 505| 44| if (esc == 99) ------------------ | Branch (505:13): [True: 0, False: 44] ------------------ 506| 0| return 99; 507| 44| index += esc; 508| |#ifdef PRINT_RVLC 509| | printf("esc: %d - ", esc); 510| |#endif 511| 44| } 512| 2.59k| if (index == -ESC_VAL) ------------------ | | 46| 2.59k|#define ESC_VAL 7 ------------------ | Branch (512:9): [True: 245, False: 2.34k] ------------------ 513| 245| { 514| 245| int8_t esc = rvlc_huffman_esc(ld_esc /*, direction*/); 515| 245| if (esc == 99) ------------------ | Branch (515:13): [True: 0, False: 245] ------------------ 516| 0| return 99; 517| 245| index -= esc; 518| |#ifdef PRINT_RVLC 519| | printf("esc: %d - ", esc); 520| |#endif 521| 245| } 522| | 523| 2.59k| return (int8_t)index; 524| 2.59k|} rvlc.c:rvlc_huffman_esc: 528| 289|{ 529| 289| uint16_t i, j; 530| 289| uint32_t cw; 531| 289| rvlc_huff_table *h = book_escape; 532| 289| int8_t direction = +1; 533| | 534| 289| i = h->len; 535| 289| if (direction > 0) ------------------ | Branch (535:9): [True: 289, False: 0] ------------------ 536| 289| cw = faad_getbits(ld, i DEBUGVAR(1,0,"")); 537| 0| else 538| 0| cw = 0 /* faad_getbits_rev(ld, i DEBUGVAR(1,0,"")) */; 539| | 540| 2.52k| while ((cw != h->cw) ------------------ | Branch (540:12): [True: 2.23k, False: 289] ------------------ 541| 2.23k| && (i < 21)) ------------------ | Branch (541:12): [True: 2.23k, False: 0] ------------------ 542| 2.23k| { 543| 2.23k| h++; 544| 2.23k| j = h->len-i; 545| 2.23k| i += j; 546| 2.23k| cw <<= j; 547| 2.23k| if (direction > 0) ------------------ | Branch (547:13): [True: 2.23k, False: 0] ------------------ 548| 2.23k| cw |= faad_getbits(ld, j DEBUGVAR(1,0,"")); 549| 0| else 550| 0| cw |= 0 /* faad_getbits_rev(ld, j DEBUGVAR(1,0,"")) */; 551| 2.23k| } 552| | 553| 289| return (int8_t)h->index; 554| 289|} DCT4_32: 49| 569k|{ 50| 569k| real_t f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10; 51| 569k| real_t f11, f12, f13, f14, f15, f16, f17, f18, f19, f20; 52| 569k| real_t f21, f22, f23, f24, f25, f26, f27, f28, f29, f30; 53| 569k| real_t f31, f32, f33, f34, f35, f36, f37, f38, f39, f40; 54| 569k| real_t f41, f42, f43, f44, f45, f46, f47, f48, f49, f50; 55| 569k| real_t f51, f52, f53, f54, f55, f56, f57, f58, f59, f60; 56| 569k| real_t f61, f62, f63, f64, f65, f66, f67, f68, f69, f70; 57| 569k| real_t f71, f72, f73, f74, f75, f76, f77, f78, f79, f80; 58| 569k| real_t f81, f82, f83, f84, f85, f86, f87, f88, f89, f90; 59| 569k| real_t f91, f92, f93, f94, f95, f96, f97, f98, f99, f100; 60| 569k| real_t f101, f102, f103, f104, f105, f106, f107, f108, f109, f110; 61| 569k| real_t f111, f112, f113, f114, f115, f116, f117, f118, f119, f120; 62| 569k| real_t f121, f122, f123, f124, f125, f126, f127, f128, f129, f130; 63| 569k| real_t f131, f132, f133, f134, f135, f136, f137, f138, f139, f140; 64| 569k| real_t f141, f142, f143, f144, f145, f146, f147, f148, f149, f150; 65| 569k| real_t f151, f152, f153, f154, f155, f156, f157, f158, f159, f160; 66| 569k| real_t f161, f162, f163, f164, f165, f166, f167, f168, f169, f170; 67| 569k| real_t f171, f172, f173, f174, f175, f176, f177, f178, f179, f180; 68| 569k| real_t f181, f182, f183, f184, f185, f186, f187, f188, f189, f190; 69| 569k| real_t f191, f192, f193, f194, f195, f196, f197, f198, f199, f200; 70| 569k| real_t f201, f202, f203, f204, f205, f206, f207, f208, f209, f210; 71| 569k| real_t f211, f212, f213, f214, f215, f216, f217, f218, f219, f220; 72| 569k| real_t f221, f222, f223, f224, f225, f226, f227, f228, f229, f230; 73| 569k| real_t f231, f232, f233, f234, f235, f236, f237, f238, f239, f240; 74| 569k| real_t f241, f242, f243, f244, f245, f246, f247, f248, f249, f250; 75| 569k| real_t f251, f252, f253, f254, f255, f256, f257, f258, f259, f260; 76| 569k| real_t f261, f262, f263, f264, f265, f266, f267, f268, f269, f270; 77| 569k| real_t f271, f272, f273, f274, f275, f276, f277, f278, f279, f280; 78| 569k| real_t f281, f282, f283, f284, f285, f286, f287, f288, f289, f290; 79| 569k| real_t f291, f292, f293, f294, f295, f296, f297, f298, f299, f300; 80| 569k| real_t f301, f302, f303, f304, f305, f306, f307, f310, f311, f312; 81| 569k| real_t f313, f316, f317, f318, f319, f322, f323, f324, f325, f328; 82| 569k| real_t f329, f330, f331, f334, f335, f336, f337, f340, f341, f342; 83| 569k| real_t f343, f346, f347, f348, f349, f352, f353, f354, f355, f358; 84| 569k| real_t f359, f360, f361, f364, f365, f366, f367, f370, f371, f372; 85| 569k| real_t f373, f376, f377, f378, f379, f382, f383, f384, f385, f388; 86| 569k| real_t f389, f390, f391, f394, f395, f396, f397; 87| | 88| 569k| f0 = x[15] - x[16]; 89| 569k| f1 = x[15] + x[16]; 90| 569k| f2 = MUL_F(FRAC_CONST(0.7071067811865476), f1); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 91| 569k| f3 = MUL_F(FRAC_CONST(0.7071067811865476), f0); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 92| 569k| f4 = x[8] - x[23]; 93| 569k| f5 = x[8] + x[23]; 94| 569k| f6 = MUL_F(FRAC_CONST(0.7071067811865476), f5); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 95| 569k| f7 = MUL_F(FRAC_CONST(0.7071067811865476), f4); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 96| 569k| f8 = x[12] - x[19]; 97| 569k| f9 = x[12] + x[19]; 98| 569k| f10 = MUL_F(FRAC_CONST(0.7071067811865476), f9); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 99| 569k| f11 = MUL_F(FRAC_CONST(0.7071067811865476), f8); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 100| 569k| f12 = x[11] - x[20]; 101| 569k| f13 = x[11] + x[20]; 102| 569k| f14 = MUL_F(FRAC_CONST(0.7071067811865476), f13); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 103| 569k| f15 = MUL_F(FRAC_CONST(0.7071067811865476), f12); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 104| 569k| f16 = x[14] - x[17]; 105| 569k| f17 = x[14] + x[17]; 106| 569k| f18 = MUL_F(FRAC_CONST(0.7071067811865476), f17); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 107| 569k| f19 = MUL_F(FRAC_CONST(0.7071067811865476), f16); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 108| 569k| f20 = x[9] - x[22]; 109| 569k| f21 = x[9] + x[22]; 110| 569k| f22 = MUL_F(FRAC_CONST(0.7071067811865476), f21); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 111| 569k| f23 = MUL_F(FRAC_CONST(0.7071067811865476), f20); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 112| 569k| f24 = x[13] - x[18]; 113| 569k| f25 = x[13] + x[18]; 114| 569k| f26 = MUL_F(FRAC_CONST(0.7071067811865476), f25); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 115| 569k| f27 = MUL_F(FRAC_CONST(0.7071067811865476), f24); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 116| 569k| f28 = x[10] - x[21]; 117| 569k| f29 = x[10] + x[21]; 118| 569k| f30 = MUL_F(FRAC_CONST(0.7071067811865476), f29); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 119| 569k| f31 = MUL_F(FRAC_CONST(0.7071067811865476), f28); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 120| 569k| f32 = x[0] - f2; 121| 569k| f33 = x[0] + f2; 122| 569k| f34 = x[31] - f3; 123| 569k| f35 = x[31] + f3; 124| 569k| f36 = x[7] - f6; 125| 569k| f37 = x[7] + f6; 126| 569k| f38 = x[24] - f7; 127| 569k| f39 = x[24] + f7; 128| 569k| f40 = x[3] - f10; 129| 569k| f41 = x[3] + f10; 130| 569k| f42 = x[28] - f11; 131| 569k| f43 = x[28] + f11; 132| 569k| f44 = x[4] - f14; 133| 569k| f45 = x[4] + f14; 134| 569k| f46 = x[27] - f15; 135| 569k| f47 = x[27] + f15; 136| 569k| f48 = x[1] - f18; 137| 569k| f49 = x[1] + f18; 138| 569k| f50 = x[30] - f19; 139| 569k| f51 = x[30] + f19; 140| 569k| f52 = x[6] - f22; 141| 569k| f53 = x[6] + f22; 142| 569k| f54 = x[25] - f23; 143| 569k| f55 = x[25] + f23; 144| 569k| f56 = x[2] - f26; 145| 569k| f57 = x[2] + f26; 146| 569k| f58 = x[29] - f27; 147| 569k| f59 = x[29] + f27; 148| 569k| f60 = x[5] - f30; 149| 569k| f61 = x[5] + f30; 150| 569k| f62 = x[26] - f31; 151| 569k| f63 = x[26] + f31; 152| 569k| f64 = f39 + f37; 153| 569k| f65 = MUL_F(FRAC_CONST(-0.5411961001461969), f39); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 154| 569k| f66 = MUL_F(FRAC_CONST(0.9238795325112867), f64); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 155| 569k| f67 = MUL_C(COEF_CONST(1.3065629648763766), f37); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 156| 569k| f68 = f65 + f66; 157| 569k| f69 = f67 - f66; 158| 569k| f70 = f38 + f36; 159| 569k| f71 = MUL_C(COEF_CONST(1.3065629648763770), f38); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 160| 569k| f72 = MUL_F(FRAC_CONST(-0.3826834323650904), f70); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 161| 569k| f73 = MUL_F(FRAC_CONST(0.5411961001461961), f36); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 162| 569k| f74 = f71 + f72; 163| 569k| f75 = f73 - f72; 164| 569k| f76 = f47 + f45; 165| 569k| f77 = MUL_F(FRAC_CONST(-0.5411961001461969), f47); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 166| 569k| f78 = MUL_F(FRAC_CONST(0.9238795325112867), f76); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 167| 569k| f79 = MUL_C(COEF_CONST(1.3065629648763766), f45); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 168| 569k| f80 = f77 + f78; 169| 569k| f81 = f79 - f78; 170| 569k| f82 = f46 + f44; 171| 569k| f83 = MUL_C(COEF_CONST(1.3065629648763770), f46); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 172| 569k| f84 = MUL_F(FRAC_CONST(-0.3826834323650904), f82); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 173| 569k| f85 = MUL_F(FRAC_CONST(0.5411961001461961), f44); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 174| 569k| f86 = f83 + f84; 175| 569k| f87 = f85 - f84; 176| 569k| f88 = f55 + f53; 177| 569k| f89 = MUL_F(FRAC_CONST(-0.5411961001461969), f55); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 178| 569k| f90 = MUL_F(FRAC_CONST(0.9238795325112867), f88); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 179| 569k| f91 = MUL_C(COEF_CONST(1.3065629648763766), f53); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 180| 569k| f92 = f89 + f90; 181| 569k| f93 = f91 - f90; 182| 569k| f94 = f54 + f52; 183| 569k| f95 = MUL_C(COEF_CONST(1.3065629648763770), f54); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 184| 569k| f96 = MUL_F(FRAC_CONST(-0.3826834323650904), f94); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 185| 569k| f97 = MUL_F(FRAC_CONST(0.5411961001461961), f52); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 186| 569k| f98 = f95 + f96; 187| 569k| f99 = f97 - f96; 188| 569k| f100 = f63 + f61; 189| 569k| f101 = MUL_F(FRAC_CONST(-0.5411961001461969), f63); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 190| 569k| f102 = MUL_F(FRAC_CONST(0.9238795325112867), f100); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 191| 569k| f103 = MUL_C(COEF_CONST(1.3065629648763766), f61); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 192| 569k| f104 = f101 + f102; 193| 569k| f105 = f103 - f102; 194| 569k| f106 = f62 + f60; 195| 569k| f107 = MUL_C(COEF_CONST(1.3065629648763770), f62); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 196| 569k| f108 = MUL_F(FRAC_CONST(-0.3826834323650904), f106); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 197| 569k| f109 = MUL_F(FRAC_CONST(0.5411961001461961), f60); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 198| 569k| f110 = f107 + f108; 199| 569k| f111 = f109 - f108; 200| 569k| f112 = f33 - f68; 201| 569k| f113 = f33 + f68; 202| 569k| f114 = f35 - f69; 203| 569k| f115 = f35 + f69; 204| 569k| f116 = f32 - f74; 205| 569k| f117 = f32 + f74; 206| 569k| f118 = f34 - f75; 207| 569k| f119 = f34 + f75; 208| 569k| f120 = f41 - f80; 209| 569k| f121 = f41 + f80; 210| 569k| f122 = f43 - f81; 211| 569k| f123 = f43 + f81; 212| 569k| f124 = f40 - f86; 213| 569k| f125 = f40 + f86; 214| 569k| f126 = f42 - f87; 215| 569k| f127 = f42 + f87; 216| 569k| f128 = f49 - f92; 217| 569k| f129 = f49 + f92; 218| 569k| f130 = f51 - f93; 219| 569k| f131 = f51 + f93; 220| 569k| f132 = f48 - f98; 221| 569k| f133 = f48 + f98; 222| 569k| f134 = f50 - f99; 223| 569k| f135 = f50 + f99; 224| 569k| f136 = f57 - f104; 225| 569k| f137 = f57 + f104; 226| 569k| f138 = f59 - f105; 227| 569k| f139 = f59 + f105; 228| 569k| f140 = f56 - f110; 229| 569k| f141 = f56 + f110; 230| 569k| f142 = f58 - f111; 231| 569k| f143 = f58 + f111; 232| 569k| f144 = f123 + f121; 233| 569k| f145 = MUL_F(FRAC_CONST(-0.7856949583871021), f123); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 234| 569k| f146 = MUL_F(FRAC_CONST(0.9807852804032304), f144); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 235| 569k| f147 = MUL_C(COEF_CONST(1.1758756024193588), f121); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 236| 569k| f148 = f145 + f146; 237| 569k| f149 = f147 - f146; 238| 569k| f150 = f127 + f125; 239| 569k| f151 = MUL_F(FRAC_CONST(0.2758993792829431), f127); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 240| 569k| f152 = MUL_F(FRAC_CONST(0.5555702330196022), f150); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 241| 569k| f153 = MUL_C(COEF_CONST(1.3870398453221475), f125); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 242| 569k| f154 = f151 + f152; 243| 569k| f155 = f153 - f152; 244| 569k| f156 = f122 + f120; 245| 569k| f157 = MUL_C(COEF_CONST(1.1758756024193591), f122); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 246| 569k| f158 = MUL_F(FRAC_CONST(-0.1950903220161287), f156); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 247| 569k| f159 = MUL_F(FRAC_CONST(0.7856949583871016), f120); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 248| 569k| f160 = f157 + f158; 249| 569k| f161 = f159 - f158; 250| 569k| f162 = f126 + f124; 251| 569k| f163 = MUL_C(COEF_CONST(1.3870398453221473), f126); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 252| 569k| f164 = MUL_F(FRAC_CONST(-0.8314696123025455), f162); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 253| 569k| f165 = MUL_F(FRAC_CONST(-0.2758993792829436), f124); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 254| 569k| f166 = f163 + f164; 255| 569k| f167 = f165 - f164; 256| 569k| f168 = f139 + f137; 257| 569k| f169 = MUL_F(FRAC_CONST(-0.7856949583871021), f139); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 258| 569k| f170 = MUL_F(FRAC_CONST(0.9807852804032304), f168); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 259| 569k| f171 = MUL_C(COEF_CONST(1.1758756024193588), f137); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 260| 569k| f172 = f169 + f170; 261| 569k| f173 = f171 - f170; 262| 569k| f174 = f143 + f141; 263| 569k| f175 = MUL_F(FRAC_CONST(0.2758993792829431), f143); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 264| 569k| f176 = MUL_F(FRAC_CONST(0.5555702330196022), f174); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 265| 569k| f177 = MUL_C(COEF_CONST(1.3870398453221475), f141); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 266| 569k| f178 = f175 + f176; 267| 569k| f179 = f177 - f176; 268| 569k| f180 = f138 + f136; 269| 569k| f181 = MUL_C(COEF_CONST(1.1758756024193591), f138); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 270| 569k| f182 = MUL_F(FRAC_CONST(-0.1950903220161287), f180); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 271| 569k| f183 = MUL_F(FRAC_CONST(0.7856949583871016), f136); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 272| 569k| f184 = f181 + f182; 273| 569k| f185 = f183 - f182; 274| 569k| f186 = f142 + f140; 275| 569k| f187 = MUL_C(COEF_CONST(1.3870398453221473), f142); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 276| 569k| f188 = MUL_F(FRAC_CONST(-0.8314696123025455), f186); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 277| 569k| f189 = MUL_F(FRAC_CONST(-0.2758993792829436), f140); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 278| 569k| f190 = f187 + f188; 279| 569k| f191 = f189 - f188; 280| 569k| f192 = f113 - f148; 281| 569k| f193 = f113 + f148; 282| 569k| f194 = f115 - f149; 283| 569k| f195 = f115 + f149; 284| 569k| f196 = f117 - f154; 285| 569k| f197 = f117 + f154; 286| 569k| f198 = f119 - f155; 287| 569k| f199 = f119 + f155; 288| 569k| f200 = f112 - f160; 289| 569k| f201 = f112 + f160; 290| 569k| f202 = f114 - f161; 291| 569k| f203 = f114 + f161; 292| 569k| f204 = f116 - f166; 293| 569k| f205 = f116 + f166; 294| 569k| f206 = f118 - f167; 295| 569k| f207 = f118 + f167; 296| 569k| f208 = f129 - f172; 297| 569k| f209 = f129 + f172; 298| 569k| f210 = f131 - f173; 299| 569k| f211 = f131 + f173; 300| 569k| f212 = f133 - f178; 301| 569k| f213 = f133 + f178; 302| 569k| f214 = f135 - f179; 303| 569k| f215 = f135 + f179; 304| 569k| f216 = f128 - f184; 305| 569k| f217 = f128 + f184; 306| 569k| f218 = f130 - f185; 307| 569k| f219 = f130 + f185; 308| 569k| f220 = f132 - f190; 309| 569k| f221 = f132 + f190; 310| 569k| f222 = f134 - f191; 311| 569k| f223 = f134 + f191; 312| 569k| f224 = f211 + f209; 313| 569k| f225 = MUL_F(FRAC_CONST(-0.8971675863426361), f211); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 314| 569k| f226 = MUL_F(FRAC_CONST(0.9951847266721968), f224); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 315| 569k| f227 = MUL_C(COEF_CONST(1.0932018670017576), f209); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 316| 569k| f228 = f225 + f226; 317| 569k| f229 = f227 - f226; 318| 569k| f230 = f215 + f213; 319| 569k| f231 = MUL_F(FRAC_CONST(-0.4105245275223571), f215); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 320| 569k| f232 = MUL_F(FRAC_CONST(0.8819212643483549), f230); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 321| 569k| f233 = MUL_C(COEF_CONST(1.3533180011743529), f213); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 322| 569k| f234 = f231 + f232; 323| 569k| f235 = f233 - f232; 324| 569k| f236 = f219 + f217; 325| 569k| f237 = MUL_F(FRAC_CONST(0.1386171691990915), f219); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 326| 569k| f238 = MUL_F(FRAC_CONST(0.6343932841636455), f236); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 327| 569k| f239 = MUL_C(COEF_CONST(1.4074037375263826), f217); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 328| 569k| f240 = f237 + f238; 329| 569k| f241 = f239 - f238; 330| 569k| f242 = f223 + f221; 331| 569k| f243 = MUL_F(FRAC_CONST(0.6666556584777466), f223); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 332| 569k| f244 = MUL_F(FRAC_CONST(0.2902846772544623), f242); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 333| 569k| f245 = MUL_C(COEF_CONST(1.2472250129866711), f221); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 334| 569k| f246 = f243 + f244; 335| 569k| f247 = f245 - f244; 336| 569k| f248 = f210 + f208; 337| 569k| f249 = MUL_C(COEF_CONST(1.0932018670017574), f210); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 338| 569k| f250 = MUL_F(FRAC_CONST(-0.0980171403295605), f248); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 339| 569k| f251 = MUL_F(FRAC_CONST(0.8971675863426364), f208); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 340| 569k| f252 = f249 + f250; 341| 569k| f253 = f251 - f250; 342| 569k| f254 = f214 + f212; 343| 569k| f255 = MUL_C(COEF_CONST(1.3533180011743529), f214); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 344| 569k| f256 = MUL_F(FRAC_CONST(-0.4713967368259979), f254); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 345| 569k| f257 = MUL_F(FRAC_CONST(0.4105245275223569), f212); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 346| 569k| f258 = f255 + f256; 347| 569k| f259 = f257 - f256; 348| 569k| f260 = f218 + f216; 349| 569k| f261 = MUL_C(COEF_CONST(1.4074037375263826), f218); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 350| 569k| f262 = MUL_F(FRAC_CONST(-0.7730104533627369), f260); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 351| 569k| f263 = MUL_F(FRAC_CONST(-0.1386171691990913), f216); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 352| 569k| f264 = f261 + f262; 353| 569k| f265 = f263 - f262; 354| 569k| f266 = f222 + f220; 355| 569k| f267 = MUL_C(COEF_CONST(1.2472250129866711), f222); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 356| 569k| f268 = MUL_F(FRAC_CONST(-0.9569403357322089), f266); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 357| 569k| f269 = MUL_F(FRAC_CONST(-0.6666556584777469), f220); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 358| 569k| f270 = f267 + f268; 359| 569k| f271 = f269 - f268; 360| 569k| f272 = f193 - f228; 361| 569k| f273 = f193 + f228; 362| 569k| f274 = f195 - f229; 363| 569k| f275 = f195 + f229; 364| 569k| f276 = f197 - f234; 365| 569k| f277 = f197 + f234; 366| 569k| f278 = f199 - f235; 367| 569k| f279 = f199 + f235; 368| 569k| f280 = f201 - f240; 369| 569k| f281 = f201 + f240; 370| 569k| f282 = f203 - f241; 371| 569k| f283 = f203 + f241; 372| 569k| f284 = f205 - f246; 373| 569k| f285 = f205 + f246; 374| 569k| f286 = f207 - f247; 375| 569k| f287 = f207 + f247; 376| 569k| f288 = f192 - f252; 377| 569k| f289 = f192 + f252; 378| 569k| f290 = f194 - f253; 379| 569k| f291 = f194 + f253; 380| 569k| f292 = f196 - f258; 381| 569k| f293 = f196 + f258; 382| 569k| f294 = f198 - f259; 383| 569k| f295 = f198 + f259; 384| 569k| f296 = f200 - f264; 385| 569k| f297 = f200 + f264; 386| 569k| f298 = f202 - f265; 387| 569k| f299 = f202 + f265; 388| 569k| f300 = f204 - f270; 389| 569k| f301 = f204 + f270; 390| 569k| f302 = f206 - f271; 391| 569k| f303 = f206 + f271; 392| 569k| f304 = f275 + f273; 393| 569k| f305 = MUL_F(FRAC_CONST(-0.9751575901732920), f275); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 394| 569k| f306 = MUL_F(FRAC_CONST(0.9996988186962043), f304); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 395| 569k| f307 = MUL_C(COEF_CONST(1.0242400472191164), f273); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 396| 569k| y[0] = f305 + f306; 397| 569k| y[31] = f307 - f306; 398| 569k| f310 = f279 + f277; 399| 569k| f311 = MUL_F(FRAC_CONST(-0.8700688593994936), f279); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 400| 569k| f312 = MUL_F(FRAC_CONST(0.9924795345987100), f310); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 401| 569k| f313 = MUL_C(COEF_CONST(1.1148902097979263), f277); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 402| 569k| y[2] = f311 + f312; 403| 569k| y[29] = f313 - f312; 404| 569k| f316 = f283 + f281; 405| 569k| f317 = MUL_F(FRAC_CONST(-0.7566008898816587), f283); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 406| 569k| f318 = MUL_F(FRAC_CONST(0.9757021300385286), f316); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 407| 569k| f319 = MUL_C(COEF_CONST(1.1948033701953984), f281); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 408| 569k| y[4] = f317 + f318; 409| 569k| y[27] = f319 - f318; 410| 569k| f322 = f287 + f285; 411| 569k| f323 = MUL_F(FRAC_CONST(-0.6358464401941451), f287); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 412| 569k| f324 = MUL_F(FRAC_CONST(0.9495281805930367), f322); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 413| 569k| f325 = MUL_C(COEF_CONST(1.2632099209919283), f285); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 414| 569k| y[6] = f323 + f324; 415| 569k| y[25] = f325 - f324; 416| 569k| f328 = f291 + f289; 417| 569k| f329 = MUL_F(FRAC_CONST(-0.5089684416985408), f291); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 418| 569k| f330 = MUL_F(FRAC_CONST(0.9142097557035307), f328); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 419| 569k| f331 = MUL_C(COEF_CONST(1.3194510697085207), f289); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 420| 569k| y[8] = f329 + f330; 421| 569k| y[23] = f331 - f330; 422| 569k| f334 = f295 + f293; 423| 569k| f335 = MUL_F(FRAC_CONST(-0.3771887988789273), f295); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 424| 569k| f336 = MUL_F(FRAC_CONST(0.8700869911087114), f334); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 425| 569k| f337 = MUL_C(COEF_CONST(1.3629851833384954), f293); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 426| 569k| y[10] = f335 + f336; 427| 569k| y[21] = f337 - f336; 428| 569k| f340 = f299 + f297; 429| 569k| f341 = MUL_F(FRAC_CONST(-0.2417766217337384), f299); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 430| 569k| f342 = MUL_F(FRAC_CONST(0.8175848131515837), f340); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 431| 569k| f343 = MUL_C(COEF_CONST(1.3933930045694289), f297); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 432| 569k| y[12] = f341 + f342; 433| 569k| y[19] = f343 - f342; 434| 569k| f346 = f303 + f301; 435| 569k| f347 = MUL_F(FRAC_CONST(-0.1040360035527077), f303); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 436| 569k| f348 = MUL_F(FRAC_CONST(0.7572088465064845), f346); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 437| 569k| f349 = MUL_C(COEF_CONST(1.4103816894602612), f301); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 438| 569k| y[14] = f347 + f348; 439| 569k| y[17] = f349 - f348; 440| 569k| f352 = f274 + f272; 441| 569k| f353 = MUL_F(FRAC_CONST(0.0347065382144002), f274); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 442| 569k| f354 = MUL_F(FRAC_CONST(0.6895405447370668), f352); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 443| 569k| f355 = MUL_C(COEF_CONST(1.4137876276885337), f272); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 444| 569k| y[16] = f353 + f354; 445| 569k| y[15] = f355 - f354; 446| 569k| f358 = f278 + f276; 447| 569k| f359 = MUL_F(FRAC_CONST(0.1731148370459795), f278); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 448| 569k| f360 = MUL_F(FRAC_CONST(0.6152315905806268), f358); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 449| 569k| f361 = MUL_C(COEF_CONST(1.4035780182072330), f276); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 450| 569k| y[18] = f359 + f360; 451| 569k| y[13] = f361 - f360; 452| 569k| f364 = f282 + f280; 453| 569k| f365 = MUL_F(FRAC_CONST(0.3098559453626100), f282); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 454| 569k| f366 = MUL_F(FRAC_CONST(0.5349976198870972), f364); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 455| 569k| f367 = MUL_C(COEF_CONST(1.3798511851368043), f280); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 456| 569k| y[20] = f365 + f366; 457| 569k| y[11] = f367 - f366; 458| 569k| f370 = f286 + f284; 459| 569k| f371 = MUL_F(FRAC_CONST(0.4436129715409088), f286); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 460| 569k| f372 = MUL_F(FRAC_CONST(0.4496113296546065), f370); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 461| 569k| f373 = MUL_C(COEF_CONST(1.3428356308501219), f284); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 462| 569k| y[22] = f371 + f372; 463| 569k| y[9] = f373 - f372; 464| 569k| f376 = f290 + f288; 465| 569k| f377 = MUL_F(FRAC_CONST(0.5730977622997509), f290); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 466| 569k| f378 = MUL_F(FRAC_CONST(0.3598950365349881), f376); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 467| 569k| f379 = MUL_C(COEF_CONST(1.2928878353697271), f288); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 468| 569k| y[24] = f377 + f378; 469| 569k| y[7] = f379 - f378; 470| 569k| f382 = f294 + f292; 471| 569k| f383 = MUL_F(FRAC_CONST(0.6970633083205415), f294); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 472| 569k| f384 = MUL_F(FRAC_CONST(0.2667127574748984), f382); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 473| 569k| f385 = MUL_C(COEF_CONST(1.2304888232703382), f292); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 474| 569k| y[26] = f383 + f384; 475| 569k| y[5] = f385 - f384; 476| 569k| f388 = f298 + f296; 477| 569k| f389 = MUL_F(FRAC_CONST(0.8143157536286401), f298); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 478| 569k| f390 = MUL_F(FRAC_CONST(0.1709618887603012), f388); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 479| 569k| f391 = MUL_C(COEF_CONST(1.1562395311492424), f296); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 480| 569k| y[28] = f389 + f390; 481| 569k| y[3] = f391 - f390; 482| 569k| f394 = f302 + f300; 483| 569k| f395 = MUL_F(FRAC_CONST(0.9237258930790228), f302); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 484| 569k| f396 = MUL_F(FRAC_CONST(0.0735645635996674), f394); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 485| 569k| f397 = MUL_C(COEF_CONST(1.0708550202783576), f300); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 486| 569k| y[30] = f395 + f396; 487| 569k| y[1] = f397 - f396; 488| 569k|} DST4_32: 491| 569k|{ 492| 569k| real_t f0, f1, f2, f3, f4, f5, f6, f7, f8, f9; 493| 569k| real_t f10, f11, f12, f13, f14, f15, f16, f17, f18, f19; 494| 569k| real_t f20, f21, f22, f23, f24, f25, f26, f27, f28, f29; 495| 569k| real_t f30, f31, f32, f33, f34, f35, f36, f37, f38, f39; 496| 569k| real_t f40, f41, f42, f43, f44, f45, f46, f47, f48, f49; 497| 569k| real_t f50, f51, f52, f53, f54, f55, f56, f57, f58, f59; 498| 569k| real_t f60, f61, f62, f63, f64, f65, f66, f67, f68, f69; 499| 569k| real_t f70, f71, f72, f73, f74, f75, f76, f77, f78, f79; 500| 569k| real_t f80, f81, f82, f83, f84, f85, f86, f87, f88, f89; 501| 569k| real_t f90, f91, f92, f93, f94, f95, f96, f97, f98, f99; 502| 569k| real_t f100, f101, f102, f103, f104, f105, f106, f107, f108, f109; 503| 569k| real_t f110, f111, f112, f113, f114, f115, f116, f117, f118, f119; 504| 569k| real_t f120, f121, f122, f123, f124, f125, f126, f127, f128, f129; 505| 569k| real_t f130, f131, f132, f133, f134, f135, f136, f137, f138, f139; 506| 569k| real_t f140, f141, f142, f143, f144, f145, f146, f147, f148, f149; 507| 569k| real_t f150, f151, f152, f153, f154, f155, f156, f157, f158, f159; 508| 569k| real_t f160, f161, f162, f163, f164, f165, f166, f167, f168, f169; 509| 569k| real_t f170, f171, f172, f173, f174, f175, f176, f177, f178, f179; 510| 569k| real_t f180, f181, f182, f183, f184, f185, f186, f187, f188, f189; 511| 569k| real_t f190, f191, f192, f193, f194, f195, f196, f197, f198, f199; 512| 569k| real_t f200, f201, f202, f203, f204, f205, f206, f207, f208, f209; 513| 569k| real_t f210, f211, f212, f213, f214, f215, f216, f217, f218, f219; 514| 569k| real_t f220, f221, f222, f223, f224, f225, f226, f227, f228, f229; 515| 569k| real_t f230, f231, f232, f233, f234, f235, f236, f237, f238, f239; 516| 569k| real_t f240, f241, f242, f243, f244, f245, f246, f247, f248, f249; 517| 569k| real_t f250, f251, f252, f253, f254, f255, f256, f257, f258, f259; 518| 569k| real_t f260, f261, f262, f263, f264, f265, f266, f267, f268, f269; 519| 569k| real_t f270, f271, f272, f273, f274, f275, f276, f277, f278, f279; 520| 569k| real_t f280, f281, f282, f283, f284, f285, f286, f287, f288, f289; 521| 569k| real_t f290, f291, f292, f293, f294, f295, f296, f297, f298, f299; 522| 569k| real_t f300, f301, f302, f303, f304, f305, f306, f307, f308, f309; 523| 569k| real_t f310, f311, f312, f313, f314, f315, f316, f317, f318, f319; 524| 569k| real_t f320, f321, f322, f323, f324, f325, f326, f327, f328, f329; 525| 569k| real_t f330, f331, f332, f333, f334, f335; 526| | 527| 569k| f0 = x[0] - x[1]; 528| 569k| f1 = x[2] - x[1]; 529| 569k| f2 = x[2] - x[3]; 530| 569k| f3 = x[4] - x[3]; 531| 569k| f4 = x[4] - x[5]; 532| 569k| f5 = x[6] - x[5]; 533| 569k| f6 = x[6] - x[7]; 534| 569k| f7 = x[8] - x[7]; 535| 569k| f8 = x[8] - x[9]; 536| 569k| f9 = x[10] - x[9]; 537| 569k| f10 = x[10] - x[11]; 538| 569k| f11 = x[12] - x[11]; 539| 569k| f12 = x[12] - x[13]; 540| 569k| f13 = x[14] - x[13]; 541| 569k| f14 = x[14] - x[15]; 542| 569k| f15 = x[16] - x[15]; 543| 569k| f16 = x[16] - x[17]; 544| 569k| f17 = x[18] - x[17]; 545| 569k| f18 = x[18] - x[19]; 546| 569k| f19 = x[20] - x[19]; 547| 569k| f20 = x[20] - x[21]; 548| 569k| f21 = x[22] - x[21]; 549| 569k| f22 = x[22] - x[23]; 550| 569k| f23 = x[24] - x[23]; 551| 569k| f24 = x[24] - x[25]; 552| 569k| f25 = x[26] - x[25]; 553| 569k| f26 = x[26] - x[27]; 554| 569k| f27 = x[28] - x[27]; 555| 569k| f28 = x[28] - x[29]; 556| 569k| f29 = x[30] - x[29]; 557| 569k| f30 = x[30] - x[31]; 558| 569k| f31 = MUL_F(FRAC_CONST(0.7071067811865476), f15); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 559| 569k| f32 = x[0] - f31; 560| 569k| f33 = x[0] + f31; 561| 569k| f34 = f7 + f23; 562| 569k| f35 = MUL_C(COEF_CONST(1.3065629648763766), f7); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 563| 569k| f36 = MUL_F(FRAC_CONST(-0.9238795325112866), f34); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 564| 569k| f37 = MUL_F(FRAC_CONST(-0.5411961001461967), f23); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 565| 569k| f38 = f35 + f36; 566| 569k| f39 = f37 - f36; 567| 569k| f40 = f33 - f39; 568| 569k| f41 = f33 + f39; 569| 569k| f42 = f32 - f38; 570| 569k| f43 = f32 + f38; 571| 569k| f44 = f11 - f19; 572| 569k| f45 = f11 + f19; 573| 569k| f46 = MUL_F(FRAC_CONST(0.7071067811865476), f45); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 574| 569k| f47 = f3 - f46; 575| 569k| f48 = f3 + f46; 576| 569k| f49 = MUL_F(FRAC_CONST(0.7071067811865476), f44); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 577| 569k| f50 = f49 - f27; 578| 569k| f51 = f49 + f27; 579| 569k| f52 = f51 + f48; 580| 569k| f53 = MUL_F(FRAC_CONST(-0.7856949583871021), f51); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 581| 569k| f54 = MUL_F(FRAC_CONST(0.9807852804032304), f52); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 582| 569k| f55 = MUL_C(COEF_CONST(1.1758756024193588), f48); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 583| 569k| f56 = f53 + f54; 584| 569k| f57 = f55 - f54; 585| 569k| f58 = f50 + f47; 586| 569k| f59 = MUL_F(FRAC_CONST(-0.2758993792829430), f50); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 587| 569k| f60 = MUL_F(FRAC_CONST(0.8314696123025452), f58); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 588| 569k| f61 = MUL_C(COEF_CONST(1.3870398453221475), f47); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 589| 569k| f62 = f59 + f60; 590| 569k| f63 = f61 - f60; 591| 569k| f64 = f41 - f56; 592| 569k| f65 = f41 + f56; 593| 569k| f66 = f43 - f62; 594| 569k| f67 = f43 + f62; 595| 569k| f68 = f42 - f63; 596| 569k| f69 = f42 + f63; 597| 569k| f70 = f40 - f57; 598| 569k| f71 = f40 + f57; 599| 569k| f72 = f5 - f9; 600| 569k| f73 = f5 + f9; 601| 569k| f74 = f13 - f17; 602| 569k| f75 = f13 + f17; 603| 569k| f76 = f21 - f25; 604| 569k| f77 = f21 + f25; 605| 569k| f78 = MUL_F(FRAC_CONST(0.7071067811865476), f75); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 606| 569k| f79 = f1 - f78; 607| 569k| f80 = f1 + f78; 608| 569k| f81 = f73 + f77; 609| 569k| f82 = MUL_C(COEF_CONST(1.3065629648763766), f73); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 610| 569k| f83 = MUL_F(FRAC_CONST(-0.9238795325112866), f81); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 611| 569k| f84 = MUL_F(FRAC_CONST(-0.5411961001461967), f77); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 612| 569k| f85 = f82 + f83; 613| 569k| f86 = f84 - f83; 614| 569k| f87 = f80 - f86; 615| 569k| f88 = f80 + f86; 616| 569k| f89 = f79 - f85; 617| 569k| f90 = f79 + f85; 618| 569k| f91 = MUL_F(FRAC_CONST(0.7071067811865476), f74); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 619| 569k| f92 = f29 - f91; 620| 569k| f93 = f29 + f91; 621| 569k| f94 = f76 + f72; 622| 569k| f95 = MUL_C(COEF_CONST(1.3065629648763766), f76); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 623| 569k| f96 = MUL_F(FRAC_CONST(-0.9238795325112866), f94); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 624| 569k| f97 = MUL_F(FRAC_CONST(-0.5411961001461967), f72); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 625| 569k| f98 = f95 + f96; 626| 569k| f99 = f97 - f96; 627| 569k| f100 = f93 - f99; 628| 569k| f101 = f93 + f99; 629| 569k| f102 = f92 - f98; 630| 569k| f103 = f92 + f98; 631| 569k| f104 = f101 + f88; 632| 569k| f105 = MUL_F(FRAC_CONST(-0.8971675863426361), f101); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 633| 569k| f106 = MUL_F(FRAC_CONST(0.9951847266721968), f104); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 634| 569k| f107 = MUL_C(COEF_CONST(1.0932018670017576), f88); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 635| 569k| f108 = f105 + f106; 636| 569k| f109 = f107 - f106; 637| 569k| f110 = f90 - f103; 638| 569k| f111 = MUL_F(FRAC_CONST(-0.6666556584777466), f103); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 639| 569k| f112 = MUL_F(FRAC_CONST(0.9569403357322089), f110); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 640| 569k| f113 = MUL_C(COEF_CONST(1.2472250129866713), f90); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 641| 569k| f114 = f112 - f111; 642| 569k| f115 = f113 - f112; 643| 569k| f116 = f102 + f89; 644| 569k| f117 = MUL_F(FRAC_CONST(-0.4105245275223571), f102); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 645| 569k| f118 = MUL_F(FRAC_CONST(0.8819212643483549), f116); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 646| 569k| f119 = MUL_C(COEF_CONST(1.3533180011743529), f89); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 647| 569k| f120 = f117 + f118; 648| 569k| f121 = f119 - f118; 649| 569k| f122 = f87 - f100; 650| 569k| f123 = MUL_F(FRAC_CONST(-0.1386171691990915), f100); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 651| 569k| f124 = MUL_F(FRAC_CONST(0.7730104533627370), f122); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 652| 569k| f125 = MUL_C(COEF_CONST(1.4074037375263826), f87); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 653| 569k| f126 = f124 - f123; 654| 569k| f127 = f125 - f124; 655| 569k| f128 = f65 - f108; 656| 569k| f129 = f65 + f108; 657| 569k| f130 = f67 - f114; 658| 569k| f131 = f67 + f114; 659| 569k| f132 = f69 - f120; 660| 569k| f133 = f69 + f120; 661| 569k| f134 = f71 - f126; 662| 569k| f135 = f71 + f126; 663| 569k| f136 = f70 - f127; 664| 569k| f137 = f70 + f127; 665| 569k| f138 = f68 - f121; 666| 569k| f139 = f68 + f121; 667| 569k| f140 = f66 - f115; 668| 569k| f141 = f66 + f115; 669| 569k| f142 = f64 - f109; 670| 569k| f143 = f64 + f109; 671| 569k| f144 = f0 + f30; 672| 569k| f145 = MUL_C(COEF_CONST(1.0478631305325901), f0); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 673| 569k| f146 = MUL_F(FRAC_CONST(-0.9987954562051724), f144); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 674| 569k| f147 = MUL_F(FRAC_CONST(-0.9497277818777548), f30); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 675| 569k| f148 = f145 + f146; 676| 569k| f149 = f147 - f146; 677| 569k| f150 = f4 + f26; 678| 569k| f151 = MUL_C(COEF_CONST(1.2130114330978077), f4); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 679| 569k| f152 = MUL_F(FRAC_CONST(-0.9700312531945440), f150); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 680| 569k| f153 = MUL_F(FRAC_CONST(-0.7270510732912803), f26); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 681| 569k| f154 = f151 + f152; 682| 569k| f155 = f153 - f152; 683| 569k| f156 = f8 + f22; 684| 569k| f157 = MUL_C(COEF_CONST(1.3315443865537255), f8); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 685| 569k| f158 = MUL_F(FRAC_CONST(-0.9039892931234433), f156); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 686| 569k| f159 = MUL_F(FRAC_CONST(-0.4764341996931612), f22); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 687| 569k| f160 = f157 + f158; 688| 569k| f161 = f159 - f158; 689| 569k| f162 = f12 + f18; 690| 569k| f163 = MUL_C(COEF_CONST(1.3989068359730781), f12); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 691| 569k| f164 = MUL_F(FRAC_CONST(-0.8032075314806453), f162); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 692| 569k| f165 = MUL_F(FRAC_CONST(-0.2075082269882124), f18); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 693| 569k| f166 = f163 + f164; 694| 569k| f167 = f165 - f164; 695| 569k| f168 = f16 + f14; 696| 569k| f169 = MUL_C(COEF_CONST(1.4125100802019777), f16); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 697| 569k| f170 = MUL_F(FRAC_CONST(-0.6715589548470187), f168); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 698| 569k| f171 = MUL_F(FRAC_CONST(0.0693921705079402), f14); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 699| 569k| f172 = f169 + f170; 700| 569k| f173 = f171 - f170; 701| 569k| f174 = f20 + f10; 702| 569k| f175 = MUL_C(COEF_CONST(1.3718313541934939), f20); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 703| 569k| f176 = MUL_F(FRAC_CONST(-0.5141027441932219), f174); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 704| 569k| f177 = MUL_F(FRAC_CONST(0.3436258658070501), f10); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 705| 569k| f178 = f175 + f176; 706| 569k| f179 = f177 - f176; 707| 569k| f180 = f24 + f6; 708| 569k| f181 = MUL_C(COEF_CONST(1.2784339185752409), f24); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 709| 569k| f182 = MUL_F(FRAC_CONST(-0.3368898533922200), f180); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 710| 569k| f183 = MUL_F(FRAC_CONST(0.6046542117908008), f6); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 711| 569k| f184 = f181 + f182; 712| 569k| f185 = f183 - f182; 713| 569k| f186 = f28 + f2; 714| 569k| f187 = MUL_C(COEF_CONST(1.1359069844201433), f28); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 715| 569k| f188 = MUL_F(FRAC_CONST(-0.1467304744553624), f186); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 716| 569k| f189 = MUL_F(FRAC_CONST(0.8424460355094185), f2); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 717| 569k| f190 = f187 + f188; 718| 569k| f191 = f189 - f188; 719| 569k| f192 = f149 - f173; 720| 569k| f193 = f149 + f173; 721| 569k| f194 = f148 - f172; 722| 569k| f195 = f148 + f172; 723| 569k| f196 = f155 - f179; 724| 569k| f197 = f155 + f179; 725| 569k| f198 = f154 - f178; 726| 569k| f199 = f154 + f178; 727| 569k| f200 = f161 - f185; 728| 569k| f201 = f161 + f185; 729| 569k| f202 = f160 - f184; 730| 569k| f203 = f160 + f184; 731| 569k| f204 = f167 - f191; 732| 569k| f205 = f167 + f191; 733| 569k| f206 = f166 - f190; 734| 569k| f207 = f166 + f190; 735| 569k| f208 = f192 + f194; 736| 569k| f209 = MUL_C(COEF_CONST(1.1758756024193588), f192); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 737| 569k| f210 = MUL_F(FRAC_CONST(-0.9807852804032304), f208); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 738| 569k| f211 = MUL_F(FRAC_CONST(-0.7856949583871021), f194); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 739| 569k| f212 = f209 + f210; 740| 569k| f213 = f211 - f210; 741| 569k| f214 = f196 + f198; 742| 569k| f215 = MUL_C(COEF_CONST(1.3870398453221475), f196); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 743| 569k| f216 = MUL_F(FRAC_CONST(-0.5555702330196022), f214); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 744| 569k| f217 = MUL_F(FRAC_CONST(0.2758993792829431), f198); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 745| 569k| f218 = f215 + f216; 746| 569k| f219 = f217 - f216; 747| 569k| f220 = f200 + f202; 748| 569k| f221 = MUL_F(FRAC_CONST(0.7856949583871022), f200); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 749| 569k| f222 = MUL_F(FRAC_CONST(0.1950903220161283), f220); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 750| 569k| f223 = MUL_C(COEF_CONST(1.1758756024193586), f202); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 751| 569k| f224 = f221 + f222; 752| 569k| f225 = f223 - f222; 753| 569k| f226 = f204 + f206; 754| 569k| f227 = MUL_F(FRAC_CONST(-0.2758993792829430), f204); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 755| 569k| f228 = MUL_F(FRAC_CONST(0.8314696123025452), f226); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 756| 569k| f229 = MUL_C(COEF_CONST(1.3870398453221475), f206); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 757| 569k| f230 = f227 + f228; 758| 569k| f231 = f229 - f228; 759| 569k| f232 = f193 - f201; 760| 569k| f233 = f193 + f201; 761| 569k| f234 = f195 - f203; 762| 569k| f235 = f195 + f203; 763| 569k| f236 = f197 - f205; 764| 569k| f237 = f197 + f205; 765| 569k| f238 = f199 - f207; 766| 569k| f239 = f199 + f207; 767| 569k| f240 = f213 - f225; 768| 569k| f241 = f213 + f225; 769| 569k| f242 = f212 - f224; 770| 569k| f243 = f212 + f224; 771| 569k| f244 = f219 - f231; 772| 569k| f245 = f219 + f231; 773| 569k| f246 = f218 - f230; 774| 569k| f247 = f218 + f230; 775| 569k| f248 = f232 + f234; 776| 569k| f249 = MUL_C(COEF_CONST(1.3065629648763766), f232); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 777| 569k| f250 = MUL_F(FRAC_CONST(-0.9238795325112866), f248); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 778| 569k| f251 = MUL_F(FRAC_CONST(-0.5411961001461967), f234); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 779| 569k| f252 = f249 + f250; 780| 569k| f253 = f251 - f250; 781| 569k| f254 = f236 + f238; 782| 569k| f255 = MUL_F(FRAC_CONST(0.5411961001461969), f236); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 783| 569k| f256 = MUL_F(FRAC_CONST(0.3826834323650898), f254); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 784| 569k| f257 = MUL_C(COEF_CONST(1.3065629648763766), f238); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 785| 569k| f258 = f255 + f256; 786| 569k| f259 = f257 - f256; 787| 569k| f260 = f240 + f242; 788| 569k| f261 = MUL_C(COEF_CONST(1.3065629648763766), f240); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 789| 569k| f262 = MUL_F(FRAC_CONST(-0.9238795325112866), f260); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 790| 569k| f263 = MUL_F(FRAC_CONST(-0.5411961001461967), f242); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [Folded, False: 569k] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 791| 569k| f264 = f261 + f262; 792| 569k| f265 = f263 - f262; 793| 569k| f266 = f244 + f246; 794| 569k| f267 = MUL_F(FRAC_CONST(0.5411961001461969), f244); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 795| 569k| f268 = MUL_F(FRAC_CONST(0.3826834323650898), f266); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 796| 569k| f269 = MUL_C(COEF_CONST(1.3065629648763766), f246); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 797| 569k| f270 = f267 + f268; 798| 569k| f271 = f269 - f268; 799| 569k| f272 = f233 - f237; 800| 569k| f273 = f233 + f237; 801| 569k| f274 = f235 - f239; 802| 569k| f275 = f235 + f239; 803| 569k| f276 = f253 - f259; 804| 569k| f277 = f253 + f259; 805| 569k| f278 = f252 - f258; 806| 569k| f279 = f252 + f258; 807| 569k| f280 = f241 - f245; 808| 569k| f281 = f241 + f245; 809| 569k| f282 = f243 - f247; 810| 569k| f283 = f243 + f247; 811| 569k| f284 = f265 - f271; 812| 569k| f285 = f265 + f271; 813| 569k| f286 = f264 - f270; 814| 569k| f287 = f264 + f270; 815| 569k| f288 = f272 - f274; 816| 569k| f289 = f272 + f274; 817| 569k| f290 = MUL_F(FRAC_CONST(0.7071067811865474), f288); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 818| 569k| f291 = MUL_F(FRAC_CONST(0.7071067811865474), f289); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 819| 569k| f292 = f276 - f278; 820| 569k| f293 = f276 + f278; 821| 569k| f294 = MUL_F(FRAC_CONST(0.7071067811865474), f292); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 822| 569k| f295 = MUL_F(FRAC_CONST(0.7071067811865474), f293); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 823| 569k| f296 = f280 - f282; 824| 569k| f297 = f280 + f282; 825| 569k| f298 = MUL_F(FRAC_CONST(0.7071067811865474), f296); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 826| 569k| f299 = MUL_F(FRAC_CONST(0.7071067811865474), f297); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 827| 569k| f300 = f284 - f286; 828| 569k| f301 = f284 + f286; 829| 569k| f302 = MUL_F(FRAC_CONST(0.7071067811865474), f300); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 830| 569k| f303 = MUL_F(FRAC_CONST(0.7071067811865474), f301); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 831| 569k| f304 = f129 - f273; 832| 569k| f305 = f129 + f273; 833| 569k| f306 = f131 - f281; 834| 569k| f307 = f131 + f281; 835| 569k| f308 = f133 - f285; 836| 569k| f309 = f133 + f285; 837| 569k| f310 = f135 - f277; 838| 569k| f311 = f135 + f277; 839| 569k| f312 = f137 - f295; 840| 569k| f313 = f137 + f295; 841| 569k| f314 = f139 - f303; 842| 569k| f315 = f139 + f303; 843| 569k| f316 = f141 - f299; 844| 569k| f317 = f141 + f299; 845| 569k| f318 = f143 - f291; 846| 569k| f319 = f143 + f291; 847| 569k| f320 = f142 - f290; 848| 569k| f321 = f142 + f290; 849| 569k| f322 = f140 - f298; 850| 569k| f323 = f140 + f298; 851| 569k| f324 = f138 - f302; 852| 569k| f325 = f138 + f302; 853| 569k| f326 = f136 - f294; 854| 569k| f327 = f136 + f294; 855| 569k| f328 = f134 - f279; 856| 569k| f329 = f134 + f279; 857| 569k| f330 = f132 - f287; 858| 569k| f331 = f132 + f287; 859| 569k| f332 = f130 - f283; 860| 569k| f333 = f130 + f283; 861| 569k| f334 = f128 - f275; 862| 569k| f335 = f128 + f275; 863| 569k| y[31] = MUL_F(FRAC_CONST(0.5001506360206510), f305); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 864| 569k| y[30] = MUL_F(FRAC_CONST(0.5013584524464084), f307); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 865| 569k| y[29] = MUL_F(FRAC_CONST(0.5037887256810443), f309); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 866| 569k| y[28] = MUL_F(FRAC_CONST(0.5074711720725553), f311); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 867| 569k| y[27] = MUL_F(FRAC_CONST(0.5124514794082247), f313); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 868| 569k| y[26] = MUL_F(FRAC_CONST(0.5187927131053328), f315); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 869| 569k| y[25] = MUL_F(FRAC_CONST(0.5265773151542700), f317); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 870| 569k| y[24] = MUL_F(FRAC_CONST(0.5359098169079920), f319); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 871| 569k| y[23] = MUL_F(FRAC_CONST(0.5469204379855088), f321); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 872| 569k| y[22] = MUL_F(FRAC_CONST(0.5597698129470802), f323); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 873| 569k| y[21] = MUL_F(FRAC_CONST(0.5746551840326600), f325); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 874| 569k| y[20] = MUL_F(FRAC_CONST(0.5918185358574165), f327); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 875| 569k| y[19] = MUL_F(FRAC_CONST(0.6115573478825099), f329); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 876| 569k| y[18] = MUL_F(FRAC_CONST(0.6342389366884031), f331); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 877| 569k| y[17] = MUL_F(FRAC_CONST(0.6603198078137061), f333); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 878| 569k| y[16] = MUL_F(FRAC_CONST(0.6903721282002123), f335); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 879| 569k| y[15] = MUL_F(FRAC_CONST(0.7251205223771985), f334); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 880| 569k| y[14] = MUL_F(FRAC_CONST(0.7654941649730891), f332); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 881| 569k| y[13] = MUL_F(FRAC_CONST(0.8127020908144905), f330); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 882| 569k| y[12] = MUL_F(FRAC_CONST(0.8683447152233481), f328); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 883| 569k| y[11] = MUL_F(FRAC_CONST(0.9345835970364075), f326); ------------------ | | 268| 2.27M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 569k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:42): [True: 569k, Folded] | | | Branch (268:42): [Folded, False: 569k] | | ------------------ ------------------ 884| 569k| y[10] = MUL_C(COEF_CONST(1.0144082649970547), f324); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 885| 569k| y[9] = MUL_C(COEF_CONST(1.1120716205797176), f322); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 886| 569k| y[8] = MUL_C(COEF_CONST(1.2338327379765710), f320); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 887| 569k| y[7] = MUL_C(COEF_CONST(1.3892939586328277), f318); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 888| 569k| y[6] = MUL_C(COEF_CONST(1.5939722833856311), f316); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 889| 569k| y[5] = MUL_C(COEF_CONST(1.8746759800084078), f314); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 890| 569k| y[4] = MUL_C(COEF_CONST(2.2820500680051619), f312); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 891| 569k| y[3] = MUL_C(COEF_CONST(2.9246284281582162), f310); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 892| 569k| y[2] = MUL_C(COEF_CONST(4.0846110781292477), f308); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 893| 569k| y[1] = MUL_C(COEF_CONST(6.7967507116736332), f306); ------------------ | | 241| 1.13M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 569k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:42): [True: 569k, Folded] | | ------------------ ------------------ 894| 569k| y[0] = MUL_R(REAL_CONST(20.3738781672314530), f304); ------------------ | | 239| 1.13M| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 569k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 569k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | | Branch (239:42): [True: 569k, Folded] | | ------------------ ------------------ 895| 569k|} dct4_kernel: 2226| 3.04M|{ 2227| | // Tables with bit reverse values for 5 bits, bit reverse of i at i-th position 2228| 3.04M| const uint8_t bit_rev_tab[32] = { 0,16,8,24,4,20,12,28,2,18,10,26,6,22,14,30,1,17,9,25,5,21,13,29,3,19,11,27,7,23,15,31 }; 2229| 3.04M| uint32_t i, i_rev; 2230| | 2231| | /* Step 2: modulate */ 2232| | // 3*32=96 multiplications 2233| | // 3*32=96 additions 2234| 100M| for (i = 0; i < 32; i++) ------------------ | Branch (2234:17): [True: 97.3M, False: 3.04M] ------------------ 2235| 97.3M| { 2236| 97.3M| real_t x_re, x_im, tmp; 2237| 97.3M| x_re = in_real[i]; 2238| 97.3M| x_im = in_imag[i]; 2239| 97.3M| tmp = MUL_C(x_re + x_im, dct4_64_tab[i]); ------------------ | | 241| 97.3M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 97.3M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 97.3M|#define COEF_BITS 28 | | ------------------ ------------------ 2240| 97.3M| in_real[i] = MUL_C(x_im, dct4_64_tab[i + 64]) + tmp; ------------------ | | 241| 97.3M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 97.3M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 97.3M|#define COEF_BITS 28 | | ------------------ ------------------ 2241| 97.3M| in_imag[i] = MUL_C(x_re, dct4_64_tab[i + 32]) + tmp; ------------------ | | 241| 97.3M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 97.3M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 97.3M|#define COEF_BITS 28 | | ------------------ ------------------ 2242| 97.3M| } 2243| | 2244| | /* Step 3: FFT, but with output in bit reverse order */ 2245| 3.04M| fft_dif(in_real, in_imag); 2246| | 2247| | /* Step 4: modulate + bitreverse reordering */ 2248| | // 3*31+2=95 multiplications 2249| | // 3*31+2=95 additions 2250| 51.7M| for (i = 0; i < 16; i++) ------------------ | Branch (2250:17): [True: 48.6M, False: 3.04M] ------------------ 2251| 48.6M| { 2252| 48.6M| real_t x_re, x_im, tmp; 2253| 48.6M| i_rev = bit_rev_tab[i]; 2254| 48.6M| x_re = in_real[i_rev]; 2255| 48.6M| x_im = in_imag[i_rev]; 2256| | 2257| 48.6M| tmp = MUL_C(x_re + x_im, dct4_64_tab[i + 3*32]); ------------------ | | 241| 48.6M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 48.6M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 48.6M|#define COEF_BITS 28 | | ------------------ ------------------ 2258| 48.6M| out_real[i] = MUL_C(x_im, dct4_64_tab[i + 5*32]) + tmp; ------------------ | | 241| 48.6M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 48.6M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 48.6M|#define COEF_BITS 28 | | ------------------ ------------------ 2259| 48.6M| out_imag[i] = MUL_C(x_re, dct4_64_tab[i + 4*32]) + tmp; ------------------ | | 241| 48.6M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 48.6M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 48.6M|#define COEF_BITS 28 | | ------------------ ------------------ 2260| 48.6M| } 2261| | // i = 16, i_rev = 1 = rev(16); 2262| 3.04M| out_imag[16] = MUL_C(in_imag[1] - in_real[1], dct4_64_tab[16 + 3*32]); ------------------ | | 241| 3.04M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 3.04M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 3.04M|#define COEF_BITS 28 | | ------------------ ------------------ 2263| 3.04M| out_real[16] = MUL_C(in_real[1] + in_imag[1], dct4_64_tab[16 + 3*32]); ------------------ | | 241| 3.04M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 3.04M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 3.04M|#define COEF_BITS 28 | | ------------------ ------------------ 2264| 48.6M| for (i = 17; i < 32; i++) ------------------ | Branch (2264:18): [True: 45.6M, False: 3.04M] ------------------ 2265| 45.6M| { 2266| 45.6M| real_t x_re, x_im, tmp; 2267| 45.6M| i_rev = bit_rev_tab[i]; 2268| 45.6M| x_re = in_real[i_rev]; 2269| 45.6M| x_im = in_imag[i_rev]; 2270| 45.6M| tmp = MUL_C(x_re + x_im, dct4_64_tab[i + 3*32]); ------------------ | | 241| 45.6M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 45.6M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 45.6M|#define COEF_BITS 28 | | ------------------ ------------------ 2271| 45.6M| out_real[i] = MUL_C(x_im, dct4_64_tab[i + 5*32]) + tmp; ------------------ | | 241| 45.6M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 45.6M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 45.6M|#define COEF_BITS 28 | | ------------------ ------------------ 2272| 45.6M| out_imag[i] = MUL_C(x_re, dct4_64_tab[i + 4*32]) + tmp; ------------------ | | 241| 45.6M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 45.6M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 45.6M|#define COEF_BITS 28 | | ------------------ ------------------ 2273| 45.6M| } 2274| | 2275| 3.04M|} sbr_dct.c:fft_dif: 1899| 3.04M|{ 1900| 3.04M| real_t w_real, w_imag; // For faster access 1901| 3.04M| real_t point1_real, point1_imag, point2_real, point2_imag; // For faster access 1902| 3.04M| uint32_t j, i, i2, w_index; // Counters 1903| | 1904| | // First 2 stages of 32 point FFT decimation in frequency 1905| | // 4*16*2=64*2=128 multiplications 1906| | // 6*16*2=96*2=192 additions 1907| | // Stage 1 of 32 point FFT decimation in frequency 1908| 51.7M| for (i = 0; i < 16; i++) ------------------ | Branch (1908:17): [True: 48.6M, False: 3.04M] ------------------ 1909| 48.6M| { 1910| 48.6M| point1_real = Real[i]; 1911| 48.6M| point1_imag = Imag[i]; 1912| 48.6M| i2 = i+16; 1913| 48.6M| point2_real = Real[i2]; 1914| 48.6M| point2_imag = Imag[i2]; 1915| | 1916| 48.6M| w_real = w_array_real[i]; 1917| 48.6M| w_imag = w_array_imag[i]; 1918| | 1919| | // temp1 = x[i] - x[i2] 1920| 48.6M| point1_real -= point2_real; 1921| 48.6M| point1_imag -= point2_imag; 1922| | 1923| | // x[i1] = x[i] + x[i2] 1924| 48.6M| Real[i] += point2_real; 1925| 48.6M| Imag[i] += point2_imag; 1926| | 1927| | // x[i2] = (x[i] - x[i2]) * w 1928| 48.6M| Real[i2] = (MUL_F(point1_real,w_real) - MUL_F(point1_imag,w_imag)); ------------------ | | 268| 48.6M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ ------------------ Real[i2] = (MUL_F(point1_real,w_real) - MUL_F(point1_imag,w_imag)); ------------------ | | 268| 48.6M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ ------------------ 1929| 48.6M| Imag[i2] = (MUL_F(point1_real,w_imag) + MUL_F(point1_imag,w_real)); ------------------ | | 268| 48.6M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ ------------------ Imag[i2] = (MUL_F(point1_real,w_imag) + MUL_F(point1_imag,w_real)); ------------------ | | 268| 48.6M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 48.6M|#define FRAC_BITS 31 | | ------------------ ------------------ 1930| 48.6M| } 1931| | // Stage 2 of 32 point FFT decimation in frequency 1932| 27.3M| for (j = 0, w_index = 0; j < 8; j++, w_index += 2) ------------------ | Branch (1932:30): [True: 24.3M, False: 3.04M] ------------------ 1933| 24.3M| { 1934| 24.3M| w_real = w_array_real[w_index]; 1935| 24.3M| w_imag = w_array_imag[w_index]; 1936| | 1937| 24.3M| i = j; 1938| 24.3M| point1_real = Real[i]; 1939| 24.3M| point1_imag = Imag[i]; 1940| 24.3M| i2 = i+8; 1941| 24.3M| point2_real = Real[i2]; 1942| 24.3M| point2_imag = Imag[i2]; 1943| | 1944| | // temp1 = x[i] - x[i2] 1945| 24.3M| point1_real -= point2_real; 1946| 24.3M| point1_imag -= point2_imag; 1947| | 1948| | // x[i1] = x[i] + x[i2] 1949| 24.3M| Real[i] += point2_real; 1950| 24.3M| Imag[i] += point2_imag; 1951| | 1952| | // x[i2] = (x[i] - x[i2]) * w 1953| 24.3M| Real[i2] = (MUL_F(point1_real,w_real) - MUL_F(point1_imag,w_imag)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ Real[i2] = (MUL_F(point1_real,w_real) - MUL_F(point1_imag,w_imag)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 1954| 24.3M| Imag[i2] = (MUL_F(point1_real,w_imag) + MUL_F(point1_imag,w_real)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ Imag[i2] = (MUL_F(point1_real,w_imag) + MUL_F(point1_imag,w_real)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 1955| | 1956| 24.3M| i = j+16; 1957| 24.3M| point1_real = Real[i]; 1958| 24.3M| point1_imag = Imag[i]; 1959| 24.3M| i2 = i+8; 1960| 24.3M| point2_real = Real[i2]; 1961| 24.3M| point2_imag = Imag[i2]; 1962| | 1963| | // temp1 = x[i] - x[i2] 1964| 24.3M| point1_real -= point2_real; 1965| 24.3M| point1_imag -= point2_imag; 1966| | 1967| | // x[i1] = x[i] + x[i2] 1968| 24.3M| Real[i] += point2_real; 1969| 24.3M| Imag[i] += point2_imag; 1970| | 1971| | // x[i2] = (x[i] - x[i2]) * w 1972| 24.3M| Real[i2] = (MUL_F(point1_real,w_real) - MUL_F(point1_imag,w_imag)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ Real[i2] = (MUL_F(point1_real,w_real) - MUL_F(point1_imag,w_imag)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 1973| 24.3M| Imag[i2] = (MUL_F(point1_real,w_imag) + MUL_F(point1_imag,w_real)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ Imag[i2] = (MUL_F(point1_real,w_imag) + MUL_F(point1_imag,w_real)); ------------------ | | 268| 24.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 24.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 1974| 24.3M| } 1975| | 1976| | // Stage 3 of 32 point FFT decimation in frequency 1977| | // 2*4*2=16 multiplications 1978| | // 4*4*2+6*4*2=10*8=80 additions 1979| 15.2M| for (i = 0; i < n; i += 8) ------------------ | | 1868| 15.2M|#define n 32 ------------------ | Branch (1979:17): [True: 12.1M, False: 3.04M] ------------------ 1980| 12.1M| { 1981| 12.1M| i2 = i+4; 1982| 12.1M| point1_real = Real[i]; 1983| 12.1M| point1_imag = Imag[i]; 1984| | 1985| 12.1M| point2_real = Real[i2]; 1986| 12.1M| point2_imag = Imag[i2]; 1987| | 1988| | // out[i1] = point1 + point2 1989| 12.1M| Real[i] += point2_real; 1990| 12.1M| Imag[i] += point2_imag; 1991| | 1992| | // out[i2] = point1 - point2 1993| 12.1M| Real[i2] = point1_real - point2_real; 1994| 12.1M| Imag[i2] = point1_imag - point2_imag; 1995| 12.1M| } 1996| 3.04M| w_real = w_array_real[4]; // = sqrt(2)/2 1997| | // w_imag = -w_real; // = w_array_imag[4]; // = -sqrt(2)/2 1998| 15.2M| for (i = 1; i < n; i += 8) ------------------ | | 1868| 15.2M|#define n 32 ------------------ | Branch (1998:17): [True: 12.1M, False: 3.04M] ------------------ 1999| 12.1M| { 2000| 12.1M| i2 = i+4; 2001| 12.1M| point1_real = Real[i]; 2002| 12.1M| point1_imag = Imag[i]; 2003| | 2004| 12.1M| point2_real = Real[i2]; 2005| 12.1M| point2_imag = Imag[i2]; 2006| | 2007| | // temp1 = x[i] - x[i2] 2008| 12.1M| point1_real -= point2_real; 2009| 12.1M| point1_imag -= point2_imag; 2010| | 2011| | // x[i1] = x[i] + x[i2] 2012| 12.1M| Real[i] += point2_real; 2013| 12.1M| Imag[i] += point2_imag; 2014| | 2015| | // x[i2] = (x[i] - x[i2]) * w 2016| 12.1M| Real[i2] = MUL_F(point1_real+point1_imag, w_real); ------------------ | | 268| 12.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 2017| 12.1M| Imag[i2] = MUL_F(point1_imag-point1_real, w_real); ------------------ | | 268| 12.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 2018| 12.1M| } 2019| 15.2M| for (i = 2; i < n; i += 8) ------------------ | | 1868| 15.2M|#define n 32 ------------------ | Branch (2019:17): [True: 12.1M, False: 3.04M] ------------------ 2020| 12.1M| { 2021| 12.1M| i2 = i+4; 2022| 12.1M| point1_real = Real[i]; 2023| 12.1M| point1_imag = Imag[i]; 2024| | 2025| 12.1M| point2_real = Real[i2]; 2026| 12.1M| point2_imag = Imag[i2]; 2027| | 2028| | // x[i] = x[i] + x[i2] 2029| 12.1M| Real[i] += point2_real; 2030| 12.1M| Imag[i] += point2_imag; 2031| | 2032| | // x[i2] = (x[i] - x[i2]) * (-i) 2033| 12.1M| Real[i2] = point1_imag - point2_imag; 2034| 12.1M| Imag[i2] = point2_real - point1_real; 2035| 12.1M| } 2036| 3.04M| w_real = w_array_real[12]; // = -sqrt(2)/2 2037| | // w_imag = w_real; // = w_array_imag[12]; // = -sqrt(2)/2 2038| 15.2M| for (i = 3; i < n; i += 8) ------------------ | | 1868| 15.2M|#define n 32 ------------------ | Branch (2038:17): [True: 12.1M, False: 3.04M] ------------------ 2039| 12.1M| { 2040| 12.1M| i2 = i+4; 2041| 12.1M| point1_real = Real[i]; 2042| 12.1M| point1_imag = Imag[i]; 2043| | 2044| 12.1M| point2_real = Real[i2]; 2045| 12.1M| point2_imag = Imag[i2]; 2046| | 2047| | // temp1 = x[i] - x[i2] 2048| 12.1M| point1_real -= point2_real; 2049| 12.1M| point1_imag -= point2_imag; 2050| | 2051| | // x[i1] = x[i] + x[i2] 2052| 12.1M| Real[i] += point2_real; 2053| 12.1M| Imag[i] += point2_imag; 2054| | 2055| | // x[i2] = (x[i] - x[i2]) * w 2056| 12.1M| Real[i2] = MUL_F(point1_real-point1_imag, w_real); ------------------ | | 268| 12.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 2057| 12.1M| Imag[i2] = MUL_F(point1_real+point1_imag, w_real); ------------------ | | 268| 12.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 12.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 2058| 12.1M| } 2059| | 2060| | 2061| | // Stage 4 of 32 point FFT decimation in frequency (no multiplications) 2062| | // 16*4=64 additions 2063| 27.3M| for (i = 0; i < n; i += 4) ------------------ | | 1868| 27.3M|#define n 32 ------------------ | Branch (2063:17): [True: 24.3M, False: 3.04M] ------------------ 2064| 24.3M| { 2065| 24.3M| i2 = i+2; 2066| 24.3M| point1_real = Real[i]; 2067| 24.3M| point1_imag = Imag[i]; 2068| | 2069| 24.3M| point2_real = Real[i2]; 2070| 24.3M| point2_imag = Imag[i2]; 2071| | 2072| | // x[i1] = x[i] + x[i2] 2073| 24.3M| Real[i] += point2_real; 2074| 24.3M| Imag[i] += point2_imag; 2075| | 2076| | // x[i2] = x[i] - x[i2] 2077| 24.3M| Real[i2] = point1_real - point2_real; 2078| 24.3M| Imag[i2] = point1_imag - point2_imag; 2079| 24.3M| } 2080| 27.3M| for (i = 1; i < n; i += 4) ------------------ | | 1868| 27.3M|#define n 32 ------------------ | Branch (2080:17): [True: 24.3M, False: 3.04M] ------------------ 2081| 24.3M| { 2082| 24.3M| i2 = i+2; 2083| 24.3M| point1_real = Real[i]; 2084| 24.3M| point1_imag = Imag[i]; 2085| | 2086| 24.3M| point2_real = Real[i2]; 2087| 24.3M| point2_imag = Imag[i2]; 2088| | 2089| | // x[i] = x[i] + x[i2] 2090| 24.3M| Real[i] += point2_real; 2091| 24.3M| Imag[i] += point2_imag; 2092| | 2093| | // x[i2] = (x[i] - x[i2]) * (-i) 2094| 24.3M| Real[i2] = point1_imag - point2_imag; 2095| 24.3M| Imag[i2] = point2_real - point1_real; 2096| 24.3M| } 2097| | 2098| | // Stage 5 of 32 point FFT decimation in frequency (no multiplications) 2099| | // 16*4=64 additions 2100| 51.7M| for (i = 0; i < n; i += 2) ------------------ | | 1868| 51.7M|#define n 32 ------------------ | Branch (2100:17): [True: 48.6M, False: 3.04M] ------------------ 2101| 48.6M| { 2102| 48.6M| i2 = i+1; 2103| 48.6M| point1_real = Real[i]; 2104| 48.6M| point1_imag = Imag[i]; 2105| | 2106| 48.6M| point2_real = Real[i2]; 2107| 48.6M| point2_imag = Imag[i2]; 2108| | 2109| | // out[i1] = point1 + point2 2110| 48.6M| Real[i] += point2_real; 2111| 48.6M| Imag[i] += point2_imag; 2112| | 2113| | // out[i2] = point1 - point2 2114| 48.6M| Real[i2] = point1_real - point2_real; 2115| 48.6M| Imag[i2] = point1_imag - point2_imag; 2116| 48.6M| } 2117| | 2118| |#ifdef REORDER_IN_FFT 2119| | FFTReorder(Real, Imag); 2120| |#endif // #ifdef REORDER_IN_FFT 2121| 3.04M|} sbrDecodeInit: 59| 27.6k|{ 60| 27.6k| sbr_info *sbr = faad_malloc(sizeof(sbr_info)); 61| 27.6k| memset(sbr, 0, sizeof(sbr_info)); 62| | 63| | /* save id of the parent element */ 64| 27.6k| sbr->id_aac = id_aac; 65| 27.6k| sbr->sample_rate = sample_rate; 66| | 67| 27.6k| sbr->bs_freq_scale = 2; 68| 27.6k| sbr->bs_alter_scale = 1; 69| 27.6k| sbr->bs_noise_bands = 2; 70| 27.6k| sbr->bs_limiter_bands = 2; 71| 27.6k| sbr->bs_limiter_gains = 2; 72| 27.6k| sbr->bs_interpol_freq = 1; 73| 27.6k| sbr->bs_smoothing_mode = 1; 74| 27.6k| sbr->bs_start_freq = 5; 75| 27.6k| sbr->bs_amp_res = 1; 76| 27.6k| sbr->bs_samplerate_mode = 1; 77| 27.6k| sbr->prevEnvIsShort[0] = -1; 78| 27.6k| sbr->prevEnvIsShort[1] = -1; 79| 27.6k| sbr->header_count = 0; 80| 27.6k| sbr->Reset = 1; 81| | 82| 27.6k|#ifdef DRM 83| 27.6k| sbr->Is_DRM_SBR = IsDRM; 84| 27.6k|#endif 85| 27.6k| sbr->tHFGen = T_HFGEN; ------------------ | | 40| 27.6k|#define T_HFGEN 8 ------------------ 86| 27.6k| sbr->tHFAdj = T_HFADJ; ------------------ | | 41| 27.6k|#define T_HFADJ 2 ------------------ 87| | 88| 27.6k| sbr->bsco = 0; 89| 27.6k| sbr->bsco_prev = 0; 90| 27.6k| sbr->M_prev = 0; 91| 27.6k| sbr->frame_len = framelength; 92| | 93| | /* force sbr reset */ 94| 27.6k| sbr->bs_start_freq_prev = INVALID; ------------------ | | 51| 27.6k|#define INVALID ((uint8_t)-1) ------------------ 95| | 96| 27.6k| if (framelength == 960) ------------------ | Branch (96:9): [True: 7.24k, False: 20.4k] ------------------ 97| 7.24k| { 98| 7.24k| sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960; ------------------ | | 56| 7.24k|#define RATE 2 ------------------ sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960; ------------------ | | 54| 7.24k|#define NO_TIME_SLOTS_960 15 ------------------ 99| 7.24k| sbr->numTimeSlots = NO_TIME_SLOTS_960; ------------------ | | 54| 7.24k|#define NO_TIME_SLOTS_960 15 ------------------ 100| 7.24k| } 101| 20.4k| else if (framelength == 1024) ------------------ | Branch (101:14): [True: 20.4k, False: 0] ------------------ 102| 20.4k| { 103| 20.4k| sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS; ------------------ | | 56| 20.4k|#define RATE 2 ------------------ sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS; ------------------ | | 55| 20.4k|#define NO_TIME_SLOTS 16 ------------------ 104| 20.4k| sbr->numTimeSlots = NO_TIME_SLOTS; ------------------ | | 55| 20.4k|#define NO_TIME_SLOTS 16 ------------------ 105| 20.4k| } 106| 0| else 107| 0| { 108| 0| faad_free(sbr); 109| 0| return NULL; 110| 0| } 111| | 112| 27.6k| sbr->GQ_ringbuf_index[0] = 0; 113| 27.6k| sbr->GQ_ringbuf_index[1] = 0; 114| | 115| 27.6k| if (id_aac == ID_CPE) ------------------ | | 87| 27.6k|#define ID_CPE 0x1 ------------------ | Branch (115:9): [True: 7.12k, False: 20.5k] ------------------ 116| 7.12k| { 117| | /* stereo */ 118| 7.12k| uint8_t j; 119| 7.12k| sbr->qmfa[0] = qmfa_init(32); 120| 7.12k| sbr->qmfa[1] = qmfa_init(32); 121| 7.12k| sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64); ------------------ | Branch (121:34): [True: 1.82k, False: 5.30k] ------------------ 122| 7.12k| sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64); ------------------ | Branch (122:34): [True: 1.82k, False: 5.30k] ------------------ 123| | 124| 42.7k| for (j = 0; j < 5; j++) ------------------ | Branch (124:21): [True: 35.6k, False: 7.12k] ------------------ 125| 35.6k| { 126| 35.6k| sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t)); 127| 35.6k| sbr->G_temp_prev[1][j] = faad_malloc(64*sizeof(real_t)); 128| 35.6k| sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t)); 129| 35.6k| sbr->Q_temp_prev[1][j] = faad_malloc(64*sizeof(real_t)); 130| 35.6k| } 131| | 132| 7.12k| memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t)); 133| 7.12k| memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t)); 134| 20.5k| } else { 135| | /* mono */ 136| 20.5k| uint8_t j; 137| 20.5k| sbr->qmfa[0] = qmfa_init(32); 138| 20.5k| sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64); ------------------ | Branch (138:34): [True: 8.62k, False: 11.9k] ------------------ 139| 20.5k| sbr->qmfs[1] = NULL; 140| | 141| 123k| for (j = 0; j < 5; j++) ------------------ | Branch (141:21): [True: 102k, False: 20.5k] ------------------ 142| 102k| { 143| 102k| sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t)); 144| 102k| sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t)); 145| 102k| } 146| | 147| 20.5k| memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t)); 148| 20.5k| } 149| | 150| 27.6k| return sbr; 151| 27.6k|} sbrDecodeEnd: 154| 27.6k|{ 155| 27.6k| uint8_t j; 156| | 157| 27.6k| if (sbr) ------------------ | Branch (157:9): [True: 27.6k, False: 0] ------------------ 158| 27.6k| { 159| 27.6k| qmfa_end(sbr->qmfa[0]); 160| 27.6k| qmfs_end(sbr->qmfs[0]); 161| 27.6k| if (sbr->qmfs[1] != NULL) ------------------ | Branch (161:13): [True: 9.74k, False: 17.9k] ------------------ 162| 9.74k| { 163| 9.74k| qmfa_end(sbr->qmfa[1]); 164| 9.74k| qmfs_end(sbr->qmfs[1]); 165| 9.74k| } 166| | 167| 166k| for (j = 0; j < 5; j++) ------------------ | Branch (167:21): [True: 138k, False: 27.6k] ------------------ 168| 138k| { 169| 138k| if (sbr->G_temp_prev[0][j]) faad_free(sbr->G_temp_prev[0][j]); ------------------ | Branch (169:17): [True: 138k, False: 0] ------------------ 170| 138k| if (sbr->Q_temp_prev[0][j]) faad_free(sbr->Q_temp_prev[0][j]); ------------------ | Branch (170:17): [True: 138k, False: 0] ------------------ 171| 138k| if (sbr->G_temp_prev[1][j]) faad_free(sbr->G_temp_prev[1][j]); ------------------ | Branch (171:17): [True: 35.6k, False: 102k] ------------------ 172| 138k| if (sbr->Q_temp_prev[1][j]) faad_free(sbr->Q_temp_prev[1][j]); ------------------ | Branch (172:17): [True: 35.6k, False: 102k] ------------------ 173| 138k| } 174| | 175| 27.6k|#ifdef PS_DEC 176| 27.6k| if (sbr->ps != NULL) ------------------ | Branch (176:13): [True: 5.31k, False: 22.3k] ------------------ 177| 5.31k| ps_free(sbr->ps); 178| 27.6k|#endif 179| | 180| 27.6k|#ifdef DRM_PS 181| 27.6k| if (sbr->drm_ps != NULL) ------------------ | Branch (181:13): [True: 2.23k, False: 25.4k] ------------------ 182| 2.23k| drm_ps_free(sbr->drm_ps); 183| 27.6k|#endif 184| | 185| 27.6k| faad_free(sbr); 186| 27.6k| } 187| 27.6k|} sbrReset: 190| 33.0k|{ 191| 33.0k| uint8_t j; 192| 33.0k| if (sbr->qmfa[0] != NULL) ------------------ | Branch (192:9): [True: 33.0k, False: 0] ------------------ 193| 33.0k| memset(sbr->qmfa[0]->x, 0, 2 * sbr->qmfa[0]->channels * 10 * sizeof(real_t)); 194| 33.0k| if (sbr->qmfa[1] != NULL) ------------------ | Branch (194:9): [True: 8.03k, False: 24.9k] ------------------ 195| 8.03k| memset(sbr->qmfa[1]->x, 0, 2 * sbr->qmfa[1]->channels * 10 * sizeof(real_t)); 196| 33.0k| if (sbr->qmfs[0] != NULL) ------------------ | Branch (196:9): [True: 33.0k, False: 0] ------------------ 197| 33.0k| memset(sbr->qmfs[0]->v, 0, 2 * sbr->qmfs[0]->channels * 20 * sizeof(real_t)); 198| 33.0k| if (sbr->qmfs[1] != NULL) ------------------ | Branch (198:9): [True: 11.6k, False: 21.4k] ------------------ 199| 11.6k| memset(sbr->qmfs[1]->v, 0, 2 * sbr->qmfs[1]->channels * 20 * sizeof(real_t)); 200| | 201| 198k| for (j = 0; j < 5; j++) ------------------ | Branch (201:17): [True: 165k, False: 33.0k] ------------------ 202| 165k| { 203| 165k| if (sbr->G_temp_prev[0][j] != NULL) ------------------ | Branch (203:13): [True: 165k, False: 0] ------------------ 204| 165k| memset(sbr->G_temp_prev[0][j], 0, 64*sizeof(real_t)); 205| 165k| if (sbr->G_temp_prev[1][j] != NULL) ------------------ | Branch (205:13): [True: 40.1k, False: 124k] ------------------ 206| 40.1k| memset(sbr->G_temp_prev[1][j], 0, 64*sizeof(real_t)); 207| 165k| if (sbr->Q_temp_prev[0][j] != NULL) ------------------ | Branch (207:13): [True: 165k, False: 0] ------------------ 208| 165k| memset(sbr->Q_temp_prev[0][j], 0, 64*sizeof(real_t)); 209| 165k| if (sbr->Q_temp_prev[1][j] != NULL) ------------------ | Branch (209:13): [True: 40.1k, False: 124k] ------------------ 210| 40.1k| memset(sbr->Q_temp_prev[1][j], 0, 64*sizeof(real_t)); 211| 165k| } 212| | 213| 33.0k| memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t)); 214| 33.0k| memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t)); 215| | 216| 33.0k| sbr->GQ_ringbuf_index[0] = 0; 217| 33.0k| sbr->GQ_ringbuf_index[1] = 0; 218| 33.0k| sbr->header_count = 0; 219| 33.0k| sbr->Reset = 1; 220| | 221| 33.0k| sbr->L_E_prev[0] = 0; 222| 33.0k| sbr->L_E_prev[1] = 0; 223| 33.0k| sbr->bs_freq_scale = 2; 224| 33.0k| sbr->bs_alter_scale = 1; 225| 33.0k| sbr->bs_noise_bands = 2; 226| 33.0k| sbr->bs_limiter_bands = 2; 227| 33.0k| sbr->bs_limiter_gains = 2; 228| 33.0k| sbr->bs_interpol_freq = 1; 229| 33.0k| sbr->bs_smoothing_mode = 1; 230| 33.0k| sbr->bs_start_freq = 5; 231| 33.0k| sbr->bs_amp_res = 1; 232| 33.0k| sbr->bs_samplerate_mode = 1; 233| 33.0k| sbr->prevEnvIsShort[0] = -1; 234| 33.0k| sbr->prevEnvIsShort[1] = -1; 235| 33.0k| sbr->bsco = 0; 236| 33.0k| sbr->bsco_prev = 0; 237| 33.0k| sbr->M_prev = 0; 238| 33.0k| sbr->bs_start_freq_prev = INVALID; ------------------ | | 51| 33.0k|#define INVALID ((uint8_t)-1) ------------------ 239| | 240| 33.0k| sbr->f_prev[0] = 0; 241| 33.0k| sbr->f_prev[1] = 0; 242| 1.65M| for (j = 0; j < MAX_M; j++) ------------------ | | 50| 1.65M|#define MAX_M 49 ------------------ | Branch (242:17): [True: 1.61M, False: 33.0k] ------------------ 243| 1.61M| { 244| 1.61M| sbr->E_prev[0][j] = 0; 245| 1.61M| sbr->Q_prev[0][j] = 0; 246| 1.61M| sbr->E_prev[1][j] = 0; 247| 1.61M| sbr->Q_prev[1][j] = 0; 248| 1.61M| sbr->bs_add_harmonic_prev[0][j] = 0; 249| 1.61M| sbr->bs_add_harmonic_prev[1][j] = 0; 250| 1.61M| } 251| 33.0k| sbr->bs_add_harmonic_flag_prev[0] = 0; 252| 33.0k| sbr->bs_add_harmonic_flag_prev[1] = 0; 253| 33.0k|} sbrDecodeCoupleFrame: 464| 8.10k|{ 465| 8.10k| uint8_t dont_process = 0; 466| 8.10k| uint8_t ret = 0; 467| 8.10k| ALIGN qmf_t X[MAX_NTSRHFG][64]; ------------------ | | 167| 8.10k|#define qmf_t complex_t ------------------ 468| | 469| 8.10k| if (sbr == NULL) ------------------ | Branch (469:9): [True: 0, False: 8.10k] ------------------ 470| 0| return 20; 471| | 472| | /* case can occur due to bit errors */ 473| 8.10k| if (sbr->id_aac != ID_CPE) ------------------ | | 87| 8.10k|#define ID_CPE 0x1 ------------------ | Branch (473:9): [True: 0, False: 8.10k] ------------------ 474| 0| return 21; 475| | 476| 8.10k| if (sbr->ret || (sbr->header_count == 0)) ------------------ | Branch (476:9): [True: 3.87k, False: 4.22k] | Branch (476:21): [True: 3.39k, False: 835] ------------------ 477| 7.26k| { 478| | /* don't process just upsample */ 479| 7.26k| dont_process = 1; 480| | 481| | /* Re-activate reset for next frame */ 482| 7.26k| if (sbr->ret && sbr->Reset) ------------------ | Branch (482:13): [True: 3.87k, False: 3.39k] | Branch (482:25): [True: 3.86k, False: 11] ------------------ 483| 3.86k| sbr->bs_start_freq_prev = INVALID; ------------------ | | 51| 3.86k|#define INVALID ((uint8_t)-1) ------------------ 484| 7.26k| } 485| | 486| 8.10k| if (just_seeked) ------------------ | Branch (486:9): [True: 2.75k, False: 5.34k] ------------------ 487| 2.75k| { 488| 2.75k| sbr->just_seeked = 1; 489| 5.34k| } else { 490| 5.34k| sbr->just_seeked = 0; 491| 5.34k| } 492| | 493| 8.10k| sbr->ret += sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR); 494| | /* subband synthesis */ 495| 8.10k| if (downSampledSBR) ------------------ | Branch (495:9): [True: 2.06k, False: 6.04k] ------------------ 496| 2.06k| { 497| 2.06k| sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, left_chan); 498| 6.04k| } else { 499| 6.04k| sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan); 500| 6.04k| } 501| | 502| 8.10k| sbr->ret += sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR); 503| | /* subband synthesis */ 504| 8.10k| if (downSampledSBR) ------------------ | Branch (504:9): [True: 2.06k, False: 6.04k] ------------------ 505| 2.06k| { 506| 2.06k| sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X, right_chan); 507| 6.04k| } else { 508| 6.04k| sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan); 509| 6.04k| } 510| | 511| 8.10k| if (sbr->bs_header_flag) ------------------ | Branch (511:9): [True: 4.67k, False: 3.43k] ------------------ 512| 4.67k| sbr->just_seeked = 0; 513| | 514| 8.10k| if (sbr->header_count != 0 && sbr->ret == 0) ------------------ | Branch (514:9): [True: 4.67k, False: 3.42k] | Branch (514:35): [True: 834, False: 3.84k] ------------------ 515| 834| { 516| 834| ret = sbr_save_prev_data(sbr, 0); 517| 834| if (ret) return ret; ------------------ | Branch (517:13): [True: 0, False: 834] ------------------ 518| 834| ret = sbr_save_prev_data(sbr, 1); 519| 834| if (ret) return ret; ------------------ | Branch (519:13): [True: 0, False: 834] ------------------ 520| 834| } 521| | 522| 8.10k| sbr_save_matrix(sbr, 0); 523| 8.10k| sbr_save_matrix(sbr, 1); 524| | 525| 8.10k| sbr->frame++; 526| | 527| |//#define POST_QMF_PRINT 528| |#ifdef POST_QMF_PRINT 529| | { 530| | int i; 531| | for (i = 0; i < 2048; i++) 532| | { 533| | printf("%d\n", left_chan[i]); 534| | } 535| | for (i = 0; i < 2048; i++) 536| | { 537| | printf("%d\n", right_chan[i]); 538| | } 539| | } 540| |#endif 541| | 542| 8.10k| return 0; 543| 8.10k|} sbrDecodeSingleFrame: 547| 21.7k|{ 548| 21.7k| uint8_t dont_process = 0; 549| 21.7k| uint8_t ret = 0; 550| 21.7k| ALIGN qmf_t X[MAX_NTSRHFG][64]; ------------------ | | 167| 21.7k|#define qmf_t complex_t ------------------ 551| | 552| 21.7k| if (sbr == NULL) ------------------ | Branch (552:9): [True: 0, False: 21.7k] ------------------ 553| 0| return 20; 554| | 555| | /* case can occur due to bit errors */ 556| 21.7k| if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) ------------------ | | 86| 43.5k|#define ID_SCE 0x0 ------------------ if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) ------------------ | | 89| 5|#define ID_LFE 0x3 ------------------ | Branch (556:9): [True: 5, False: 21.7k] | Branch (556:34): [True: 0, False: 5] ------------------ 557| 0| return 21; 558| | 559| 21.7k| if (sbr->ret || (sbr->header_count == 0)) ------------------ | Branch (559:9): [True: 4.17k, False: 17.6k] | Branch (559:21): [True: 16.1k, False: 1.43k] ------------------ 560| 20.3k| { 561| | /* don't process just upsample */ 562| 20.3k| dont_process = 1; 563| | 564| | /* Re-activate reset for next frame */ 565| 20.3k| if (sbr->ret && sbr->Reset) ------------------ | Branch (565:13): [True: 4.17k, False: 16.1k] | Branch (565:25): [True: 4.15k, False: 19] ------------------ 566| 4.15k| sbr->bs_start_freq_prev = INVALID; ------------------ | | 51| 4.15k|#define INVALID ((uint8_t)-1) ------------------ 567| 20.3k| } 568| | 569| 21.7k| if (just_seeked) ------------------ | Branch (569:9): [True: 7.93k, False: 13.8k] ------------------ 570| 7.93k| { 571| 7.93k| sbr->just_seeked = 1; 572| 13.8k| } else { 573| 13.8k| sbr->just_seeked = 0; 574| 13.8k| } 575| | 576| 21.7k| sbr->ret += sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR); 577| | /* subband synthesis */ 578| 21.7k| if (downSampledSBR) ------------------ | Branch (578:9): [True: 9.48k, False: 12.3k] ------------------ 579| 9.48k| { 580| 9.48k| sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, channel); 581| 12.3k| } else { 582| 12.3k| sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel); 583| 12.3k| } 584| | 585| 21.7k| if (sbr->bs_header_flag) ------------------ | Branch (585:9): [True: 5.59k, False: 16.2k] ------------------ 586| 5.59k| sbr->just_seeked = 0; 587| | 588| 21.7k| if (sbr->header_count != 0 && sbr->ret == 0) ------------------ | Branch (588:9): [True: 5.35k, False: 16.4k] | Branch (588:35): [True: 1.12k, False: 4.23k] ------------------ 589| 1.12k| { 590| 1.12k| ret = sbr_save_prev_data(sbr, 0); 591| 1.12k| if (ret) return ret; ------------------ | Branch (591:13): [True: 1, False: 1.12k] ------------------ 592| 1.12k| } 593| | 594| 21.7k| sbr_save_matrix(sbr, 0); 595| | 596| 21.7k| sbr->frame++; 597| | 598| |//#define POST_QMF_PRINT 599| |#ifdef POST_QMF_PRINT 600| | { 601| | int i; 602| | for (i = 0; i < 2048; i++) 603| | { 604| | printf("%d\n", channel[i]); 605| | } 606| | } 607| |#endif 608| | 609| 21.7k| return 0; 610| 21.7k|} sbrDecodeSingleFramePS: 615| 3.82k|{ 616| 3.82k| uint8_t l, k; 617| 3.82k| uint8_t dont_process = 0; 618| 3.82k| uint8_t ret = 0; 619| 3.82k| ALIGN qmf_t X_left[MAX_NTSRHFG][64] = {{{0}}}; ------------------ | | 167| 3.82k|#define qmf_t complex_t ------------------ 620| 3.82k| ALIGN qmf_t X_right[MAX_NTSRHFG][64] = {{{0}}}; /* must set this to 0 */ ------------------ | | 167| 3.82k|#define qmf_t complex_t ------------------ 621| | 622| 3.82k| if (sbr == NULL) ------------------ | Branch (622:9): [True: 0, False: 3.82k] ------------------ 623| 0| return 20; 624| | 625| | /* case can occur due to bit errors */ 626| 3.82k| if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) ------------------ | | 86| 7.64k|#define ID_SCE 0x0 ------------------ if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) ------------------ | | 89| 0|#define ID_LFE 0x3 ------------------ | Branch (626:9): [True: 0, False: 3.82k] | Branch (626:34): [True: 0, False: 0] ------------------ 627| 0| return 21; 628| | 629| 3.82k| if (sbr->ret || (sbr->header_count == 0)) ------------------ | Branch (629:9): [True: 2.87k, False: 952] | Branch (629:21): [True: 93, False: 859] ------------------ 630| 2.96k| { 631| | /* don't process just upsample */ 632| 2.96k| dont_process = 1; 633| | 634| | /* Re-activate reset for next frame */ 635| 2.96k| if (sbr->ret && sbr->Reset) ------------------ | Branch (635:13): [True: 2.87k, False: 93] | Branch (635:25): [True: 2.85k, False: 13] ------------------ 636| 2.85k| sbr->bs_start_freq_prev = INVALID; ------------------ | | 51| 2.85k|#define INVALID ((uint8_t)-1) ------------------ 637| 2.96k| } 638| | 639| 3.82k| if (just_seeked) ------------------ | Branch (639:9): [True: 1.61k, False: 2.20k] ------------------ 640| 1.61k| { 641| 1.61k| sbr->just_seeked = 1; 642| 2.20k| } else { 643| 2.20k| sbr->just_seeked = 0; 644| 2.20k| } 645| | 646| 3.82k| if (sbr->qmfs[1] == NULL) ------------------ | Branch (646:9): [True: 2.61k, False: 1.20k] ------------------ 647| 2.61k| { 648| 2.61k| sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64); ------------------ | Branch (648:34): [True: 1.52k, False: 1.08k] ------------------ 649| 2.61k| } 650| | 651| 3.82k| sbr->ret += sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR); 652| | 653| | /* copy some extra data for PS */ 654| 26.7k| for (l = sbr->numTimeSlotsRate; l < sbr->numTimeSlotsRate + 6; l++) ------------------ | Branch (654:37): [True: 22.9k, False: 3.82k] ------------------ 655| 22.9k| { 656| 137k| for (k = 0; k < 5; k++) ------------------ | Branch (656:21): [True: 114k, False: 22.9k] ------------------ 657| 114k| { 658| 114k| QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]); ------------------ | | 168| 114k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 114k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]); ------------------ | | 168| 114k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 114k|#define RE(A) (A)[0] | | ------------------ ------------------ 659| 114k| QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]); ------------------ | | 169| 114k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 114k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]); ------------------ | | 169| 114k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 114k|#define IM(A) (A)[1] | | ------------------ ------------------ 660| 114k| } 661| 22.9k| } 662| | 663| | /* perform parametric stereo */ 664| 3.82k|#ifdef DRM_PS 665| 3.82k| if (sbr->Is_DRM_SBR) ------------------ | Branch (665:9): [True: 63, False: 3.76k] ------------------ 666| 63| { 667| 63| drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), X_left, X_right); 668| 3.76k| } else { 669| 3.76k|#endif 670| 3.76k|#ifdef PS_DEC 671| 3.76k| ps_decode(sbr->ps, X_left, X_right); 672| 3.76k|#endif 673| 3.76k|#ifdef DRM_PS 674| 3.76k| } 675| 3.82k|#endif 676| | 677| | /* subband synthesis */ 678| 3.82k| if (downSampledSBR) ------------------ | Branch (678:9): [True: 2.28k, False: 1.54k] ------------------ 679| 2.28k| { 680| 2.28k| sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X_left, left_channel); 681| 2.28k| sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X_right, right_channel); 682| 2.28k| } else { 683| 1.54k| sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel); 684| 1.54k| sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel); 685| 1.54k| } 686| | 687| 3.82k| if (sbr->bs_header_flag) ------------------ | Branch (687:9): [True: 3.80k, False: 21] ------------------ 688| 3.80k| sbr->just_seeked = 0; 689| | 690| 3.82k| if (sbr->header_count != 0 && sbr->ret == 0) ------------------ | Branch (690:9): [True: 3.14k, False: 684] | Branch (690:35): [True: 836, False: 2.30k] ------------------ 691| 836| { 692| 836| ret = sbr_save_prev_data(sbr, 0); 693| 836| if (ret) return ret; ------------------ | Branch (693:13): [True: 0, False: 836] ------------------ 694| 836| } 695| | 696| 3.82k| sbr_save_matrix(sbr, 0); 697| | 698| 3.82k| sbr->frame++; 699| | 700| 3.82k| return 0; 701| 3.82k|} sbr_dec.c:sbr_process_channel: 308| 41.8k|{ 309| 41.8k| int16_t k, l; 310| 41.8k| uint8_t ret = 0; 311| 41.8k| (void)downSampledSBR; /* TODO: remove parameter? */ 312| | 313| |#ifdef SBR_LOW_POWER 314| | ALIGN real_t deg[64]; 315| |#endif 316| | 317| 41.8k|#ifdef DRM 318| 41.8k| if (sbr->Is_DRM_SBR) ------------------ | Branch (318:9): [True: 114, False: 41.7k] ------------------ 319| 114| { 320| 114| sbr->bsco = (uint8_t)max((int32_t)sbr->maxAACLine*32/(int32_t)sbr->frame_len - (int32_t)sbr->kx, 0); ------------------ | | 57| 114|#define max(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (57:20): [True: 33, False: 81] | | ------------------ ------------------ 321| 41.7k| } else { 322| 41.7k|#endif 323| 41.7k| sbr->bsco = 0; 324| 41.7k|#ifdef DRM 325| 41.7k| } 326| 41.8k|#endif 327| | 328| | 329| |//#define PRE_QMF_PRINT 330| |#ifdef PRE_QMF_PRINT 331| | { 332| | int i; 333| | for (i = 0; i < 1024; i++) 334| | { 335| | printf("%d\n", channel_buf[i]); 336| | } 337| | } 338| |#endif 339| | 340| | 341| | /* subband analysis */ 342| 41.8k| if (dont_process) ------------------ | Branch (342:9): [True: 37.8k, False: 3.96k] ------------------ 343| 37.8k| sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, 32); 344| 3.96k| else 345| 3.96k| sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, sbr->kx); 346| | 347| 41.8k| if (!dont_process) ------------------ | Branch (347:9): [True: 3.96k, False: 37.8k] ------------------ 348| 3.96k| { 349| 3.96k|#if 1 350| | /* insert high frequencies here */ 351| | /* hf generation using patching */ 352| 3.96k| hf_generation(sbr, sbr->Xsbr[ch], sbr->Xsbr[ch] 353| |#ifdef SBR_LOW_POWER 354| | ,deg 355| |#endif 356| 3.96k| ,ch); 357| 3.96k|#endif 358| | 359| |#if 0 //def SBR_LOW_POWER 360| | for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++) 361| | { 362| | for (k = 0; k < sbr->kx; k++) 363| | { 364| | QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0; 365| | } 366| | } 367| |#endif 368| | 369| 3.96k|#if 1 370| | /* hf adjustment */ 371| 3.96k| ret = hf_adjustment(sbr, sbr->Xsbr[ch] 372| |#ifdef SBR_LOW_POWER 373| | ,deg 374| |#endif 375| 3.96k| ,ch); 376| 3.96k|#endif 377| 3.96k| if (ret > 0) ------------------ | Branch (377:13): [True: 336, False: 3.62k] ------------------ 378| 336| { 379| 336| dont_process = 1; 380| 336| } 381| 3.96k| } 382| | 383| 41.8k| if ((sbr->just_seeked != 0) || dont_process) ------------------ | Branch (383:9): [True: 15.0k, False: 26.7k] | Branch (383:36): [True: 24.1k, False: 2.65k] ------------------ 384| 39.1k| { 385| 1.27M| for (l = 0; l < sbr->numTimeSlotsRate; l++) ------------------ | Branch (385:21): [True: 1.23M, False: 39.1k] ------------------ 386| 1.23M| { 387| 40.6M| for (k = 0; k < 32; k++) ------------------ | Branch (387:25): [True: 39.3M, False: 1.23M] ------------------ 388| 39.3M| { 389| 39.3M| QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 168| 39.3M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 39.3M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 168| 39.3M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 39.3M|#define RE(A) (A)[0] | | ------------------ ------------------ 390| 39.3M|#ifndef SBR_LOW_POWER 391| 39.3M| QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 169| 39.3M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 39.3M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 169| 39.3M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 39.3M|#define IM(A) (A)[1] | | ------------------ ------------------ 392| 39.3M|#endif 393| 39.3M| } 394| 40.6M| for (k = 32; k < 64; k++) ------------------ | Branch (394:26): [True: 39.3M, False: 1.23M] ------------------ 395| 39.3M| { 396| 39.3M| QMF_RE(X[l][k]) = 0; ------------------ | | 168| 39.3M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 39.3M|#define RE(A) (A)[0] | | ------------------ ------------------ 397| 39.3M|#ifndef SBR_LOW_POWER 398| 39.3M| QMF_IM(X[l][k]) = 0; ------------------ | | 169| 39.3M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 39.3M|#define IM(A) (A)[1] | | ------------------ ------------------ 399| 39.3M|#endif 400| 39.3M| } 401| 1.23M| } 402| 39.1k| } else { 403| 86.4k| for (l = 0; l < sbr->numTimeSlotsRate; l++) ------------------ | Branch (403:21): [True: 83.8k, False: 2.65k] ------------------ 404| 83.8k| { 405| 83.8k| uint8_t kx_band, M_band, bsco_band; 406| | 407| 83.8k| if (l < sbr->t_E[ch][0]) ------------------ | Branch (407:17): [True: 2.93k, False: 80.8k] ------------------ 408| 2.93k| { 409| 2.93k| kx_band = sbr->kx_prev; 410| 2.93k| M_band = sbr->M_prev; 411| 2.93k| bsco_band = sbr->bsco_prev; 412| 80.8k| } else { 413| 80.8k| kx_band = sbr->kx; 414| 80.8k| M_band = sbr->M; 415| 80.8k| bsco_band = sbr->bsco; 416| 80.8k| } 417| | 418| 83.8k|#ifndef SBR_LOW_POWER 419| 1.16M| for (k = 0; k < kx_band + bsco_band; k++) ------------------ | Branch (419:25): [True: 1.07M, False: 83.8k] ------------------ 420| 1.07M| { 421| 1.07M| QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 168| 1.07M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.07M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 168| 1.07M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.07M|#define RE(A) (A)[0] | | ------------------ ------------------ 422| 1.07M| QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 169| 1.07M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.07M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 169| 1.07M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.07M|#define IM(A) (A)[1] | | ------------------ ------------------ 423| 1.07M| } 424| 1.13M| for (k = kx_band + bsco_band; k < kx_band + M_band; k++) ------------------ | Branch (424:43): [True: 1.04M, False: 83.8k] ------------------ 425| 1.04M| { 426| 1.04M| QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 168| 1.04M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.04M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 168| 1.04M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.04M|#define RE(A) (A)[0] | | ------------------ ------------------ 427| 1.04M| QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 169| 1.04M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.04M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); ------------------ | | 169| 1.04M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.04M|#define IM(A) (A)[1] | | ------------------ ------------------ 428| 1.04M| } 429| 3.32M| for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++) ------------------ | | 57| 83.8k|#define max(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (57:20): [True: 0, False: 83.8k] | | ------------------ ------------------ | Branch (429:66): [True: 3.24M, False: 83.8k] ------------------ 430| 3.24M| { 431| 3.24M| QMF_RE(X[l][k]) = 0; ------------------ | | 168| 3.24M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 3.24M|#define RE(A) (A)[0] | | ------------------ ------------------ 432| 3.24M| QMF_IM(X[l][k]) = 0; ------------------ | | 169| 3.24M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 3.24M|#define IM(A) (A)[1] | | ------------------ ------------------ 433| 3.24M| } 434| |#else 435| | for (k = 0; k < kx_band + bsco_band; k++) 436| | { 437| | QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); 438| | } 439| | for (k = kx_band + bsco_band; k < min(kx_band + M_band, 63); k++) 440| | { 441| | QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]); 442| | } 443| | for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++) 444| | { 445| | QMF_RE(X[l][k]) = 0; 446| | } 447| | /* kx_band can be 0 (kx_prev on the first frame's leading slots), 448| | which would make kx_band - 1 + bsco_band index X[l][-1]. There is 449| | no band below 0 to add in that case, so skip the overlap. */ 450| | if (kx_band + bsco_band > 0) 451| | { 452| | QMF_RE(X[l][kx_band - 1 + bsco_band]) += 453| | QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][kx_band - 1 + bsco_band]); 454| | } 455| |#endif 456| 83.8k| } 457| 2.65k| } 458| | 459| 41.8k| return ret; 460| 41.8k|} sbr_dec.c:sbr_save_prev_data: 256| 3.62k|{ 257| 3.62k| uint8_t i; 258| | 259| | /* save data for next frame */ 260| 3.62k| sbr->kx_prev = sbr->kx; 261| 3.62k| sbr->M_prev = sbr->M; 262| 3.62k| sbr->bsco_prev = sbr->bsco; 263| | 264| 3.62k| sbr->L_E_prev[ch] = sbr->L_E[ch]; 265| | 266| | /* sbr->L_E[ch] can become 0 on files with bit errors */ 267| 3.62k| if (sbr->L_E[ch] <= 0) ------------------ | Branch (267:9): [True: 1, False: 3.62k] ------------------ 268| 1| return 19; 269| | 270| 3.62k| sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1]; 271| 181k| for (i = 0; i < MAX_M; i++) ------------------ | | 50| 181k|#define MAX_M 49 ------------------ | Branch (271:17): [True: 177k, False: 3.62k] ------------------ 272| 177k| { 273| 177k| sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1]; 274| 177k| sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1]; 275| 177k| } 276| | 277| 181k| for (i = 0; i < MAX_M; i++) ------------------ | | 50| 181k|#define MAX_M 49 ------------------ | Branch (277:17): [True: 177k, False: 3.62k] ------------------ 278| 177k| { 279| 177k| sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i]; 280| 177k| } 281| 3.62k| sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch]; 282| | 283| 3.62k| if (sbr->l_A[ch] == sbr->L_E[ch]) ------------------ | Branch (283:9): [True: 830, False: 2.79k] ------------------ 284| 830| sbr->prevEnvIsShort[ch] = 0; 285| 2.79k| else 286| 2.79k| sbr->prevEnvIsShort[ch] = -1; 287| | 288| 3.62k| return 0; 289| 3.62k|} sbr_dec.c:sbr_save_matrix: 292| 41.8k|{ 293| 41.8k| uint8_t i; 294| | 295| 376k| for (i = 0; i < sbr->tHFGen; i++) ------------------ | Branch (295:17): [True: 334k, False: 41.8k] ------------------ 296| 334k| { 297| 334k| memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t)); 298| 334k| } 299| 1.37M| for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++) ------------------ | | 46| 1.37M|#define MAX_NTSRHFG 40 ------------------ | Branch (299:27): [True: 1.33M, False: 41.8k] ------------------ 300| 1.33M| { 301| 1.33M| memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t)); 302| 1.33M| } 303| 41.8k|} extract_envelope_data: 42| 16.2k|{ 43| 16.2k| uint8_t l, k; 44| | 45| 51.4k| for (l = 0; l < sbr->L_E[ch]; l++) ------------------ | Branch (45:17): [True: 35.2k, False: 16.2k] ------------------ 46| 35.2k| { 47| 35.2k| if (sbr->bs_df_env[ch][l] == 0) ------------------ | Branch (47:13): [True: 24.2k, False: 11.0k] ------------------ 48| 24.2k| { 49| 134k| for (k = 1; k < sbr->n[sbr->f[ch][l]]; k++) ------------------ | Branch (49:25): [True: 110k, False: 24.2k] ------------------ 50| 110k| { 51| 110k| sbr->E[ch][k][l] = sbr->E[ch][k - 1][l] + sbr->E[ch][k][l]; 52| 110k| if (sbr->E[ch][k][l] < 0) ------------------ | Branch (52:21): [True: 4.58k, False: 106k] ------------------ 53| 4.58k| sbr->E[ch][k][l] = 0; 54| 110k| } 55| | 56| 24.2k| } else { /* bs_df_env == 1 */ 57| | 58| 11.0k| uint8_t g = (l == 0) ? sbr->f_prev[ch] : sbr->f[ch][l-1]; ------------------ | Branch (58:25): [True: 5.82k, False: 5.19k] ------------------ 59| 11.0k| int16_t E_prev; 60| | 61| 11.0k| if (sbr->f[ch][l] == g) ------------------ | Branch (61:17): [True: 8.22k, False: 2.78k] ------------------ 62| 8.22k| { 63| 42.9k| for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++) ------------------ | Branch (63:29): [True: 34.7k, False: 8.22k] ------------------ 64| 34.7k| { 65| 34.7k| if (l == 0) ------------------ | Branch (65:25): [True: 15.1k, False: 19.6k] ------------------ 66| 15.1k| E_prev = sbr->E_prev[ch][k]; 67| 19.6k| else 68| 19.6k| E_prev = sbr->E[ch][k][l - 1]; 69| | 70| 34.7k| sbr->E[ch][k][l] = E_prev + sbr->E[ch][k][l]; 71| 34.7k| } 72| | 73| 8.22k| } else if ((g == 1) && (sbr->f[ch][l] == 0)) { ------------------ | Branch (73:24): [True: 579, False: 2.20k] | Branch (73:36): [True: 579, False: 0] ------------------ 74| 579| uint8_t i; 75| | 76| 4.62k| for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++) ------------------ | Branch (76:29): [True: 4.04k, False: 579] ------------------ 77| 4.04k| { 78| 70.5k| for (i = 0; i < sbr->N_high; i++) ------------------ | Branch (78:33): [True: 66.5k, False: 4.04k] ------------------ 79| 66.5k| { 80| 66.5k| if (sbr->f_table_res[HI_RES][i] == sbr->f_table_res[LO_RES][k]) ------------------ | | 52| 66.5k|#define HI_RES 1 ------------------ if (sbr->f_table_res[HI_RES][i] == sbr->f_table_res[LO_RES][k]) ------------------ | | 51| 66.5k|#define LO_RES 0 ------------------ | Branch (80:29): [True: 4.04k, False: 62.4k] ------------------ 81| 4.04k| { 82| 4.04k| if (l == 0) ------------------ | Branch (82:33): [True: 3, False: 4.04k] ------------------ 83| 3| E_prev = sbr->E_prev[ch][i]; 84| 4.04k| else 85| 4.04k| E_prev = sbr->E[ch][i][l - 1]; 86| | 87| 4.04k| sbr->E[ch][k][l] = E_prev + sbr->E[ch][k][l]; 88| 4.04k| } 89| 66.5k| } 90| 4.04k| } 91| | 92| 2.20k| } else if ((g == 0) && (sbr->f[ch][l] == 1)) { ------------------ | Branch (92:24): [True: 2.20k, False: 0] | Branch (92:36): [True: 2.20k, False: 0] ------------------ 93| 2.20k| uint8_t i; 94| | 95| 21.3k| for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++) ------------------ | Branch (95:29): [True: 19.1k, False: 2.20k] ------------------ 96| 19.1k| { 97| 144k| for (i = 0; i < sbr->N_low; i++) ------------------ | Branch (97:33): [True: 125k, False: 19.1k] ------------------ 98| 125k| { 99| 125k| if ((sbr->f_table_res[LO_RES][i] <= sbr->f_table_res[HI_RES][k]) && ------------------ | | 51| 125k|#define LO_RES 0 ------------------ if ((sbr->f_table_res[LO_RES][i] <= sbr->f_table_res[HI_RES][k]) && ------------------ | | 52| 125k|#define HI_RES 1 ------------------ | Branch (99:29): [True: 72.8k, False: 52.8k] ------------------ 100| 72.8k| (sbr->f_table_res[HI_RES][k] < sbr->f_table_res[LO_RES][i + 1])) ------------------ | | 52| 72.8k|#define HI_RES 1 ------------------ (sbr->f_table_res[HI_RES][k] < sbr->f_table_res[LO_RES][i + 1])) ------------------ | | 51| 72.8k|#define LO_RES 0 ------------------ | Branch (100:29): [True: 19.1k, False: 53.7k] ------------------ 101| 19.1k| { 102| 19.1k| if (l == 0) ------------------ | Branch (102:33): [True: 10.6k, False: 8.41k] ------------------ 103| 10.6k| E_prev = sbr->E_prev[ch][i]; 104| 8.41k| else 105| 8.41k| E_prev = sbr->E[ch][i][l - 1]; 106| | 107| 19.1k| sbr->E[ch][k][l] = E_prev + sbr->E[ch][k][l]; 108| 19.1k| } 109| 125k| } 110| 19.1k| } 111| 2.20k| } 112| 11.0k| } 113| 35.2k| } 114| 16.2k|} extract_noise_floor_data: 117| 16.2k|{ 118| 16.2k| uint8_t l, k; 119| | 120| 40.2k| for (l = 0; l < sbr->L_Q[ch]; l++) ------------------ | Branch (120:17): [True: 24.0k, False: 16.2k] ------------------ 121| 24.0k| { 122| 24.0k| if (sbr->bs_df_noise[ch][l] == 0) ------------------ | Branch (122:13): [True: 15.6k, False: 8.32k] ------------------ 123| 15.6k| { 124| 28.9k| for (k = 1; k < sbr->N_Q; k++) ------------------ | Branch (124:25): [True: 13.2k, False: 15.6k] ------------------ 125| 13.2k| { 126| 13.2k| sbr->Q[ch][k][l] = sbr->Q[ch][k][l] + sbr->Q[ch][k-1][l]; 127| 13.2k| } 128| 15.6k| } else { 129| 8.32k| if (l == 0) ------------------ | Branch (129:17): [True: 5.44k, False: 2.88k] ------------------ 130| 5.44k| { 131| 15.8k| for (k = 0; k < sbr->N_Q; k++) ------------------ | Branch (131:29): [True: 10.3k, False: 5.44k] ------------------ 132| 10.3k| { 133| 10.3k| sbr->Q[ch][k][l] = sbr->Q_prev[ch][k] + sbr->Q[ch][k][0]; 134| 10.3k| } 135| 5.44k| } else { 136| 10.2k| for (k = 0; k < sbr->N_Q; k++) ------------------ | Branch (136:29): [True: 7.34k, False: 2.88k] ------------------ 137| 7.34k| { 138| 7.34k| sbr->Q[ch][k][l] = sbr->Q[ch][k][l - 1] + sbr->Q[ch][k][l]; 139| 7.34k| } 140| 2.88k| } 141| 8.32k| } 142| 24.0k| } 143| 16.2k|} qmf_start_channel: 51| 21.1k|{ 52| 21.1k| static const uint8_t startMinTable[12] = { 7, 7, 10, 11, 12, 16, 16, 53| 21.1k| 17, 24, 32, 35, 48 }; 54| 21.1k| static const uint8_t offsetIndexTable[12] = { 5, 5, 4, 4, 4, 3, 2, 1, 0, 55| 21.1k| 6, 6, 6 }; 56| 21.1k| static const int8_t offset[7][16] = { 57| 21.1k| { -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7 }, 58| 21.1k| { -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13 }, 59| 21.1k| { -5, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16 }, 60| 21.1k| { -6, -4, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16 }, 61| 21.1k| { -4, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20 }, 62| 21.1k| { -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20, 24 }, 63| 21.1k| { 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20, 24, 28, 33 } 64| 21.1k| }; 65| 21.1k| uint8_t startMin = startMinTable[get_sr_index(sample_rate)]; 66| 21.1k| uint8_t offsetIndex = offsetIndexTable[get_sr_index(sample_rate)]; 67| | 68| |#if 0 /* replaced with table (startMinTable) */ 69| | if (sample_rate >= 64000) 70| | { 71| | startMin = (uint8_t)((5000.*128.)/(float)sample_rate + 0.5); 72| | } else if (sample_rate < 32000) { 73| | startMin = (uint8_t)((3000.*128.)/(float)sample_rate + 0.5); 74| | } else { 75| | startMin = (uint8_t)((4000.*128.)/(float)sample_rate + 0.5); 76| | } 77| |#endif 78| | 79| 21.1k| if (bs_samplerate_mode) ------------------ | Branch (79:9): [True: 21.1k, False: 0] ------------------ 80| 21.1k| { 81| 21.1k| return startMin + offset[offsetIndex][bs_start_freq]; 82| | 83| |#if 0 /* replaced by offsetIndexTable */ 84| | switch (sample_rate) 85| | { 86| | case 16000: 87| | return startMin + offset[0][bs_start_freq]; 88| | case 22050: 89| | return startMin + offset[1][bs_start_freq]; 90| | case 24000: 91| | return startMin + offset[2][bs_start_freq]; 92| | case 32000: 93| | return startMin + offset[3][bs_start_freq]; 94| | default: 95| | if (sample_rate > 64000) 96| | { 97| | return startMin + offset[5][bs_start_freq]; 98| | } else { /* 44100 <= sample_rate <= 64000 */ 99| | return startMin + offset[4][bs_start_freq]; 100| | } 101| | } 102| |#endif 103| 21.1k| } else { 104| 0| return startMin + offset[6][bs_start_freq]; 105| 0| } 106| 21.1k|} qmf_stop_channel: 122| 21.1k|{ 123| 21.1k| if (bs_stop_freq == 15) ------------------ | Branch (123:9): [True: 1.65k, False: 19.4k] ------------------ 124| 1.65k| { 125| 1.65k| return min(64, k0 * 3); ------------------ | | 60| 1.65k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 1.33k, False: 324] | | ------------------ ------------------ 126| 19.4k| } else if (bs_stop_freq == 14) { ------------------ | Branch (126:16): [True: 289, False: 19.2k] ------------------ 127| 289| return min(64, k0 * 2); ------------------ | | 60| 289|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 289] | | ------------------ ------------------ 128| 19.2k| } else { 129| 19.2k| static const uint8_t stopMinTable[12] = { 13, 15, 20, 21, 23, 130| 19.2k| 32, 32, 35, 48, 64, 70, 96 }; 131| 19.2k| static const int8_t offset[12][14] = { 132| 19.2k| { 0, 2, 4, 6, 8, 11, 14, 18, 22, 26, 31, 37, 44, 51 }, 133| 19.2k| { 0, 2, 4, 6, 8, 11, 14, 18, 22, 26, 31, 36, 42, 49 }, 134| 19.2k| { 0, 2, 4, 6, 8, 11, 14, 17, 21, 25, 29, 34, 39, 44 }, 135| 19.2k| { 0, 2, 4, 6, 8, 11, 14, 17, 20, 24, 28, 33, 38, 43 }, 136| 19.2k| { 0, 2, 4, 6, 8, 11, 14, 17, 20, 24, 28, 32, 36, 41 }, 137| 19.2k| { 0, 2, 4, 6, 8, 10, 12, 14, 17, 20, 23, 26, 29, 32 }, 138| 19.2k| { 0, 2, 4, 6, 8, 10, 12, 14, 17, 20, 23, 26, 29, 32 }, 139| 19.2k| { 0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 20, 23, 26, 29 }, 140| 19.2k| { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16 }, 141| 19.2k| { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 142| 19.2k| { 0, -1, -2, -3, -4, -5, -6, -6, -6, -6, -6, -6, -6, -6 }, 143| 19.2k| { 0, -3, -6, -9, -12, -15, -18, -20, -22, -24, -26, -28, -30, -32 } 144| 19.2k| }; 145| |#if 0 146| | uint8_t i; 147| | int32_t stopDk[13], stopDk_t[14], k2; 148| |#endif 149| 19.2k| uint8_t stopMin = stopMinTable[get_sr_index(sample_rate)]; 150| | 151| |#if 0 /* replaced by table lookup */ 152| | if (sample_rate >= 64000) 153| | { 154| | stopMin = (uint8_t)((10000.*128.)/(float)sample_rate + 0.5); 155| | } else if (sample_rate < 32000) { 156| | stopMin = (uint8_t)((6000.*128.)/(float)sample_rate + 0.5); 157| | } else { 158| | stopMin = (uint8_t)((8000.*128.)/(float)sample_rate + 0.5); 159| | } 160| |#endif 161| | 162| |#if 0 /* replaced by table lookup */ 163| | /* diverging power series */ 164| | for (i = 0; i <= 13; i++) 165| | { 166| | stopDk_t[i] = (int32_t)(stopMin*pow(64.0/stopMin, i/13.0) + 0.5); 167| | } 168| | for (i = 0; i < 13; i++) 169| | { 170| | stopDk[i] = stopDk_t[i+1] - stopDk_t[i]; 171| | } 172| | 173| | /* needed? */ 174| | qsort(stopDk, 13, sizeof(stopDk[0]), int32cmp); 175| | 176| | k2 = stopMin; 177| | for (i = 0; i < bs_stop_freq; i++) 178| | { 179| | k2 += stopDk[i]; 180| | } 181| | return min(64, k2); 182| |#endif 183| | /* bs_stop_freq <= 13 */ 184| 19.2k| return min(64, stopMin + offset[get_sr_index(sample_rate)][min(bs_stop_freq, 13)]); ------------------ | | 60| 38.4k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 0, False: 19.2k] | | | Branch (60:28): [True: 18.5k, False: 667] | | | Branch (60:41): [True: 18.5k, False: 667] | | ------------------ ------------------ 185| 19.2k| } 186| | 187| | // return 0; 188| 21.1k|} master_frequency_table_fs0: 197| 1.73k|{ 198| 1.73k| int8_t incr; 199| 1.73k| uint8_t k; 200| 1.73k| uint8_t dk; 201| 1.73k| int32_t nrBands, k2Achieved; 202| 1.73k| int32_t k2Diff, vDk[64] = {0}; 203| | 204| | /* mft only defined for k2 > k0 */ 205| 1.73k| if (k2 <= k0) ------------------ | Branch (205:9): [True: 42, False: 1.69k] ------------------ 206| 42| { 207| 42| sbr->N_master = 0; 208| 42| return 1; 209| 42| } 210| | 211| 1.69k| dk = bs_alter_scale ? 2 : 1; ------------------ | Branch (211:10): [True: 506, False: 1.18k] ------------------ 212| | 213| |#if 0 /* replaced by float-less design */ 214| | nrBands = 2 * (int32_t)((float)(k2-k0)/(dk*2) + (-1+dk)/2.0f); 215| |#else 216| 1.69k| if (bs_alter_scale) ------------------ | Branch (216:9): [True: 506, False: 1.18k] ------------------ 217| 506| { 218| 506| nrBands = (((k2-k0+2)>>2)<<1); 219| 1.18k| } else { 220| 1.18k| nrBands = (((k2-k0)>>1)<<1); 221| 1.18k| } 222| 1.69k|#endif 223| 1.69k| nrBands = min(nrBands, 63); ------------------ | | 60| 1.69k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 1.69k, False: 0] | | ------------------ ------------------ 224| 1.69k| if (nrBands <= 0) ------------------ | Branch (224:9): [True: 2, False: 1.68k] ------------------ 225| 2| return 1; 226| | 227| 1.68k| k2Achieved = k0 + nrBands * dk; 228| 1.68k| k2Diff = k2 - k2Achieved; 229| 30.5k| for (k = 0; k < nrBands; k++) ------------------ | Branch (229:17): [True: 28.8k, False: 1.68k] ------------------ 230| 28.8k| vDk[k] = dk; 231| | 232| 1.68k| if (k2Diff) ------------------ | Branch (232:9): [True: 1.31k, False: 377] ------------------ 233| 1.31k| { 234| 1.31k| incr = (k2Diff > 0) ? -1 : 1; ------------------ | Branch (234:16): [True: 874, False: 438] ------------------ 235| 1.31k| k = (uint8_t) ((k2Diff > 0) ? (nrBands-1) : 0); ------------------ | Branch (235:24): [True: 874, False: 438] ------------------ 236| | 237| 2.84k| while (k2Diff != 0) ------------------ | Branch (237:16): [True: 1.52k, False: 1.31k] ------------------ 238| 1.52k| { 239| 1.52k| vDk[k] -= incr; 240| 1.52k| k += incr; 241| 1.52k| k2Diff += incr; 242| 1.52k| } 243| 1.31k| } 244| | 245| 1.68k| sbr->f_master[0] = k0; 246| 30.5k| for (k = 1; k <= nrBands; k++) ------------------ | Branch (246:17): [True: 28.8k, False: 1.68k] ------------------ 247| 28.8k| sbr->f_master[k] = (uint8_t)(sbr->f_master[k-1] + vDk[k-1]); 248| | 249| 1.68k| sbr->N_master = (uint8_t)nrBands; 250| 1.68k| sbr->N_master = (min(sbr->N_master, 64)); ------------------ | | 60| 1.68k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 1.68k, False: 0] | | ------------------ ------------------ 251| | 252| |#if 0 253| | printf("f_master[%d]: ", nrBands); 254| | for (k = 0; k <= nrBands; k++) 255| | { 256| | printf("%d ", sbr->f_master[k]); 257| | } 258| | printf("\n"); 259| |#endif 260| | 261| 1.68k| return 0; 262| 1.69k|} master_frequency_table: 357| 19.4k|{ 358| 19.4k| uint8_t k, bands, twoRegions; 359| 19.4k| uint8_t k1; 360| 19.4k| uint8_t nrBand0, nrBand1; 361| 19.4k| int32_t vDk0[64] = {0}, vDk1[64] = {0}; 362| 19.4k| int32_t vk0[64] = {0}, vk1[64] = {0}; 363| 19.4k| uint8_t temp1[] = { 6, 5, 4 }; 364| 19.4k| real_t q, qk; 365| 19.4k| int32_t A_1; 366| 19.4k|#ifdef FIXED_POINT 367| 19.4k| real_t rk2, rk0; 368| 19.4k|#endif 369| 19.4k| (void)bs_alter_scale; /* TODO: remove parameter? */ 370| | 371| | /* mft only defined for k2 > k0 */ 372| 19.4k| if (k2 <= k0) ------------------ | Branch (372:9): [True: 109, False: 19.3k] ------------------ 373| 109| { 374| 109| sbr->N_master = 0; 375| 109| return 1; 376| 109| } 377| | 378| 19.3k| bands = temp1[bs_freq_scale-1]; 379| | 380| 19.3k|#ifdef FIXED_POINT 381| 19.3k| rk0 = (real_t)k0 << REAL_BITS; ------------------ | | 45| 19.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 382| 19.3k| rk2 = (real_t)k2 << REAL_BITS; ------------------ | | 45| 19.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 383| 19.3k| if (rk2 > MUL_C(rk0, COEF_CONST(2.2449))) ------------------ | | 241| 38.6k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 19.3k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 19.3k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:55): [True: 19.3k, Folded] | | ------------------ ------------------ | Branch (383:9): [True: 6.64k, False: 12.6k] ------------------ 384| |#else 385| | if ((float)k2/(float)k0 > 2.2449) 386| |#endif 387| 6.64k| { 388| 6.64k| twoRegions = 1; 389| 6.64k| k1 = k0 << 1; 390| 12.6k| } else { 391| 12.6k| twoRegions = 0; 392| 12.6k| k1 = k2; 393| 12.6k| } 394| | 395| 19.3k| nrBand0 = (uint8_t)(2 * find_bands(0, bands, k0, k1)); 396| 19.3k| nrBand0 = min(nrBand0, 63); ------------------ | | 60| 19.3k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 19.3k, False: 0] | | ------------------ ------------------ 397| 19.3k| if (nrBand0 <= 0) ------------------ | Branch (397:9): [True: 62, False: 19.2k] ------------------ 398| 62| return 1; 399| | 400| 19.2k| q = find_initial_power(nrBand0, k0, k1); 401| 19.2k|#ifdef FIXED_POINT 402| 19.2k| qk = (real_t)k0 << REAL_BITS; ------------------ | | 45| 19.2k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 403| | //A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS); 404| 19.2k| A_1 = k0; 405| |#else 406| | qk = REAL_CONST(k0); 407| | A_1 = (int32_t)(qk + .5); 408| |#endif 409| 180k| for (k = 0; k <= nrBand0; k++) ------------------ | Branch (409:17): [True: 161k, False: 19.2k] ------------------ 410| 161k| { 411| 161k| int32_t A_0 = A_1; 412| 161k|#ifdef FIXED_POINT 413| 161k| qk = MUL_R(qk,q); ------------------ | | 239| 161k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 161k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 161k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 414| 161k| A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS); ------------------ | | 59| 161k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 161k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 161k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 161k, Folded] | | ------------------ ------------------ A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS); ------------------ | | 45| 161k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 415| |#else 416| | qk *= q; 417| | A_1 = (int32_t)(qk + 0.5); 418| |#endif 419| 161k| vDk0[k] = A_1 - A_0; 420| 161k| } 421| | 422| | /* needed? */ 423| 19.2k| qsort(vDk0, nrBand0, sizeof(vDk0[0]), int32cmp); 424| | 425| 19.2k| vk0[0] = k0; 426| 145k| for (k = 1; k <= nrBand0; k++) ------------------ | Branch (426:17): [True: 129k, False: 16.0k] ------------------ 427| 129k| { 428| 129k| vk0[k] = vk0[k-1] + vDk0[k-1]; 429| 129k| if (vDk0[k-1] == 0) ------------------ | Branch (429:13): [True: 3.24k, False: 125k] ------------------ 430| 3.24k| return 1; 431| 129k| } 432| | 433| 16.0k| if (!twoRegions) ------------------ | Branch (433:9): [True: 9.91k, False: 6.09k] ------------------ 434| 9.91k| { 435| 85.8k| for (k = 0; k <= nrBand0; k++) ------------------ | Branch (435:21): [True: 75.9k, False: 9.91k] ------------------ 436| 75.9k| sbr->f_master[k] = (uint8_t) vk0[k]; 437| | 438| 9.91k| sbr->N_master = nrBand0; 439| 9.91k| sbr->N_master = min(sbr->N_master, 64); ------------------ | | 60| 9.91k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 9.91k, False: 0] | | ------------------ ------------------ 440| 9.91k| return 0; 441| 9.91k| } 442| | 443| 6.09k| nrBand1 = (uint8_t)(2 * find_bands(1 /* warped */, bands, k1, k2)); 444| 6.09k| nrBand1 = min(nrBand1, 63); ------------------ | | 60| 6.09k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 6.09k, False: 0] | | ------------------ ------------------ 445| | 446| 6.09k| q = find_initial_power(nrBand1, k1, k2); 447| 6.09k|#ifdef FIXED_POINT 448| 6.09k| qk = (real_t)k1 << REAL_BITS; ------------------ | | 45| 6.09k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 449| | //A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS); 450| 6.09k| A_1 = k1; 451| |#else 452| | qk = REAL_CONST(k1); 453| | A_1 = (int32_t)(qk + .5); 454| |#endif 455| 25.6k| for (k = 0; k <= nrBand1 - 1; k++) ------------------ | Branch (455:17): [True: 19.5k, False: 6.09k] ------------------ 456| 19.5k| { 457| 19.5k| int32_t A_0 = A_1; 458| 19.5k|#ifdef FIXED_POINT 459| 19.5k| qk = MUL_R(qk,q); ------------------ | | 239| 19.5k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 19.5k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 19.5k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 460| 19.5k| A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS); ------------------ | | 59| 19.5k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 19.5k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 19.5k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 19.5k, Folded] | | ------------------ ------------------ A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS); ------------------ | | 45| 19.5k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 461| |#else 462| | qk *= q; 463| | A_1 = (int32_t)(qk + 0.5); 464| |#endif 465| 19.5k| vDk1[k] = A_1 - A_0; 466| 19.5k| } 467| | 468| 6.09k| if (vDk1[0] < vDk0[nrBand0 - 1]) ------------------ | Branch (468:9): [True: 435, False: 5.65k] ------------------ 469| 435| { 470| 435| int32_t change; 471| | 472| | /* needed? */ 473| 435| qsort(vDk1, nrBand1 + 1, sizeof(vDk1[0]), int32cmp); 474| 435| change = vDk0[nrBand0 - 1] - vDk1[0]; 475| 435| vDk1[0] = vDk0[nrBand0 - 1]; 476| 435| vDk1[nrBand1 - 1] = vDk1[nrBand1 - 1] - change; 477| 435| } 478| | 479| | /* needed? */ 480| 6.09k| qsort(vDk1, nrBand1, sizeof(vDk1[0]), int32cmp); 481| 6.09k| vk1[0] = k1; 482| 25.6k| for (k = 1; k <= nrBand1; k++) ------------------ | Branch (482:17): [True: 19.5k, False: 6.09k] ------------------ 483| 19.5k| { 484| 19.5k| vk1[k] = vk1[k-1] + vDk1[k-1]; 485| 19.5k| if (vDk1[k-1] == 0) ------------------ | Branch (485:13): [True: 0, False: 19.5k] ------------------ 486| 0| return 1; 487| 19.5k| } 488| | 489| 6.09k| sbr->N_master = nrBand0 + nrBand1; 490| 6.09k| sbr->N_master = min(sbr->N_master, 64); ------------------ | | 60| 6.09k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 6.09k, False: 0] | | ------------------ ------------------ 491| 72.0k| for (k = 0; k <= nrBand0; k++) ------------------ | Branch (491:17): [True: 65.9k, False: 6.09k] ------------------ 492| 65.9k| { 493| 65.9k| sbr->f_master[k] = (uint8_t) vk0[k]; 494| 65.9k| } 495| 25.6k| for (k = nrBand0 + 1; k <= sbr->N_master; k++) ------------------ | Branch (495:27): [True: 19.5k, False: 6.09k] ------------------ 496| 19.5k| { 497| 19.5k| sbr->f_master[k] = (uint8_t) vk1[k - nrBand0]; 498| 19.5k| } 499| | 500| |#if 0 501| | printf("f_master[%d]: ", sbr->N_master); 502| | for (k = 0; k <= sbr->N_master; k++) 503| | { 504| | printf("%d ", sbr->f_master[k]); 505| | } 506| | printf("\n"); 507| |#endif 508| | 509| 6.09k| return 0; 510| 6.09k|} derived_frequency_table: 515| 21.1k|{ 516| 21.1k| uint8_t k, i; 517| 21.1k| uint32_t minus; 518| | 519| | /* The following relation shall be satisfied: bs_xover_band < N_Master */ 520| 21.1k| if (sbr->N_master <= bs_xover_band) ------------------ | Branch (520:9): [True: 981, False: 20.1k] ------------------ 521| 981| return 1; 522| | 523| 20.1k| sbr->N_high = sbr->N_master - bs_xover_band; 524| 20.1k| sbr->N_low = (sbr->N_high>>1) + (sbr->N_high - ((sbr->N_high>>1)<<1)); 525| | 526| 20.1k| sbr->n[0] = sbr->N_low; 527| 20.1k| sbr->n[1] = sbr->N_high; 528| | 529| 194k| for (k = 0; k <= sbr->N_high; k++) ------------------ | Branch (529:17): [True: 174k, False: 20.1k] ------------------ 530| 174k| { 531| 174k| sbr->f_table_res[HI_RES][k] = sbr->f_master[k + bs_xover_band]; ------------------ | | 52| 174k|#define HI_RES 1 ------------------ 532| 174k| } 533| | 534| 20.1k| sbr->M = sbr->f_table_res[HI_RES][sbr->N_high] - sbr->f_table_res[HI_RES][0]; ------------------ | | 52| 20.1k|#define HI_RES 1 ------------------ sbr->M = sbr->f_table_res[HI_RES][sbr->N_high] - sbr->f_table_res[HI_RES][0]; ------------------ | | 52| 20.1k|#define HI_RES 1 ------------------ 535| 20.1k| if (sbr->M > MAX_M) ------------------ | | 50| 20.1k|#define MAX_M 49 ------------------ | Branch (535:9): [True: 72, False: 20.0k] ------------------ 536| 72| return 1; 537| 20.0k| sbr->kx = sbr->f_table_res[HI_RES][0]; ------------------ | | 52| 20.0k|#define HI_RES 1 ------------------ 538| 20.0k| if (sbr->kx > 32) ------------------ | Branch (538:9): [True: 2.44k, False: 17.6k] ------------------ 539| 2.44k| return 1; 540| 17.6k| if (sbr->kx + sbr->M > 64) ------------------ | Branch (540:9): [True: 0, False: 17.6k] ------------------ 541| 0| return 1; 542| | 543| 17.6k| minus = (sbr->N_high & 1) ? 1 : 0; ------------------ | Branch (543:13): [True: 4.21k, False: 13.4k] ------------------ 544| | 545| 17.6k| i = 0; 546| 108k| for (k = 0; k <= sbr->N_low; k++) ------------------ | Branch (546:17): [True: 90.8k, False: 17.6k] ------------------ 547| 90.8k| { 548| 90.8k| if (k != 0) ------------------ | Branch (548:13): [True: 73.2k, False: 17.6k] ------------------ 549| 73.2k| i = (uint8_t)(2*k - minus); 550| 90.8k| sbr->f_table_res[LO_RES][k] = sbr->f_table_res[HI_RES][i]; ------------------ | | 51| 90.8k|#define LO_RES 0 ------------------ sbr->f_table_res[LO_RES][k] = sbr->f_table_res[HI_RES][i]; ------------------ | | 52| 90.8k|#define HI_RES 1 ------------------ 551| 90.8k| } 552| | 553| |#if 0 554| | printf("bs_freq_scale: %d\n", sbr->bs_freq_scale); 555| | printf("bs_limiter_bands: %d\n", sbr->bs_limiter_bands); 556| | printf("f_table_res[HI_RES][%d]: ", sbr->N_high); 557| | for (k = 0; k <= sbr->N_high; k++) 558| | { 559| | printf("%d ", sbr->f_table_res[HI_RES][k]); 560| | } 561| | printf("\n"); 562| |#endif 563| |#if 0 564| | printf("f_table_res[LO_RES][%d]: ", sbr->N_low); 565| | for (k = 0; k <= sbr->N_low; k++) 566| | { 567| | printf("%d ", sbr->f_table_res[LO_RES][k]); 568| | } 569| | printf("\n"); 570| |#endif 571| | 572| 17.6k| sbr->N_Q = 0; 573| 17.6k| if (sbr->bs_noise_bands == 0) ------------------ | Branch (573:9): [True: 2.68k, False: 14.9k] ------------------ 574| 2.68k| { 575| 2.68k| sbr->N_Q = 1; 576| 14.9k| } else { 577| |#if 0 578| | sbr->N_Q = max(1, (int32_t)(sbr->bs_noise_bands*(log(k2/(float)sbr->kx)/log(2.0)) + 0.5)); 579| |#else 580| 14.9k| sbr->N_Q = (uint8_t)(max(1, find_bands(0, sbr->bs_noise_bands, sbr->kx, k2))); ------------------ | | 57| 14.9k|#define max(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (57:20): [True: 4.24k, False: 10.7k] | | ------------------ ------------------ 581| 14.9k|#endif 582| 14.9k| sbr->N_Q = min(5, sbr->N_Q); ------------------ | | 60| 14.9k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 12, False: 14.9k] | | ------------------ ------------------ 583| 14.9k| } 584| | 585| 17.6k| i = 0; 586| 65.1k| for (k = 0; k <= sbr->N_Q; k++) ------------------ | Branch (586:17): [True: 47.5k, False: 17.6k] ------------------ 587| 47.5k| { 588| 47.5k| if (k != 0) ------------------ | Branch (588:13): [True: 29.8k, False: 17.6k] ------------------ 589| 29.8k| i = i + (sbr->N_low - i)/(sbr->N_Q + 1 - k); 590| 47.5k| sbr->f_table_noise[k] = sbr->f_table_res[LO_RES][i]; ------------------ | | 51| 47.5k|#define LO_RES 0 ------------------ 591| 47.5k| } 592| | 593| | /* build table for mapping k to g in hf patching */ 594| 1.14M| for (k = 0; k < 64; k++) ------------------ | Branch (594:17): [True: 1.12M, False: 17.6k] ------------------ 595| 1.12M| { 596| 1.12M| uint8_t g; 597| 2.65M| for (g = 0; g < sbr->N_Q; g++) ------------------ | Branch (597:21): [True: 1.80M, False: 855k] ------------------ 598| 1.80M| { 599| 1.80M| if ((sbr->f_table_noise[g] <= k) && ------------------ | Branch (599:17): [True: 1.25M, False: 542k] ------------------ 600| 1.25M| (k < sbr->f_table_noise[g+1])) ------------------ | Branch (600:17): [True: 273k, False: 983k] ------------------ 601| 273k| { 602| 273k| sbr->table_map_k_to_g[k] = g; 603| 273k| break; 604| 273k| } 605| 1.80M| } 606| 1.12M| } 607| | 608| |#if 0 609| | printf("f_table_noise[%d]: ", sbr->N_Q); 610| | for (k = 0; k <= sbr->N_Q; k++) 611| | { 612| | printf("%d ", sbr->f_table_noise[k] - sbr->kx); 613| | } 614| | printf("\n"); 615| |#endif 616| | 617| 17.6k| return 0; 618| 17.6k|} limiter_frequency_table: 626| 3.88k|{ 627| |#if 0 628| | static const real_t limiterBandsPerOctave[] = { REAL_CONST(1.2), 629| | REAL_CONST(2), REAL_CONST(3) }; 630| |#else 631| 3.88k| static const real_t limiterBandsCompare[] = { REAL_CONST(1.327152), ------------------ | | 59| 3.88k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.88k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.88k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ 632| 3.88k| REAL_CONST(1.185093), REAL_CONST(1.119872) }; ------------------ | | 59| 3.88k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.88k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.88k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(1.185093), REAL_CONST(1.119872) }; ------------------ | | 59| 3.88k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.88k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.88k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ 633| 3.88k|#endif 634| 3.88k| uint8_t k, s; 635| 3.88k| int8_t nrLim; 636| |#if 0 637| | real_t limBands; 638| |#endif 639| | 640| 3.88k| sbr->f_table_lim[0][0] = sbr->f_table_res[LO_RES][0] - sbr->kx; ------------------ | | 51| 3.88k|#define LO_RES 0 ------------------ 641| 3.88k| sbr->f_table_lim[0][1] = sbr->f_table_res[LO_RES][sbr->N_low] - sbr->kx; ------------------ | | 51| 3.88k|#define LO_RES 0 ------------------ 642| 3.88k| sbr->N_L[0] = 1; 643| | 644| |#if 0 645| | printf("f_table_lim[%d][%d]: ", 0, sbr->N_L[0]); 646| | for (k = 0; k <= sbr->N_L[0]; k++) 647| | { 648| | printf("%d ", sbr->f_table_lim[0][k]); 649| | } 650| | printf("\n"); 651| |#endif 652| | 653| 15.5k| for (s = 1; s < 4; s++) ------------------ | Branch (653:17): [True: 11.6k, False: 3.88k] ------------------ 654| 11.6k| { 655| 11.6k| uint8_t limTable[100 /*TODO*/] = {0}; 656| 11.6k| uint8_t patchBorders[64/*??*/] = {0}; 657| | 658| |#if 0 659| | limBands = limiterBandsPerOctave[s - 1]; 660| |#endif 661| | 662| 11.6k| patchBorders[0] = sbr->kx; 663| 36.3k| for (k = 1; k <= sbr->noPatches; k++) ------------------ | Branch (663:21): [True: 24.6k, False: 11.6k] ------------------ 664| 24.6k| { 665| 24.6k| patchBorders[k] = patchBorders[k-1] + sbr->patchNoSubbands[k-1]; 666| 24.6k| } 667| | 668| 63.9k| for (k = 0; k <= sbr->N_low; k++) ------------------ | Branch (668:21): [True: 52.3k, False: 11.6k] ------------------ 669| 52.3k| { 670| 52.3k| limTable[k] = sbr->f_table_res[LO_RES][k]; ------------------ | | 51| 52.3k|#define LO_RES 0 ------------------ 671| 52.3k| } 672| 24.6k| for (k = 1; k < sbr->noPatches; k++) ------------------ | Branch (672:21): [True: 13.0k, False: 11.6k] ------------------ 673| 13.0k| { 674| 13.0k| limTable[k+sbr->N_low] = patchBorders[k]; 675| 13.0k| } 676| | 677| | /* needed */ 678| 11.6k| qsort(limTable, sbr->noPatches + sbr->N_low, sizeof(limTable[0]), uint8cmp); 679| 11.6k| k = 1; 680| 11.6k| nrLim = sbr->noPatches + sbr->N_low - 1; 681| | 682| 11.6k| if (nrLim < 0) // TODO: BIG FAT PROBLEM ------------------ | Branch (682:13): [True: 0, False: 11.6k] ------------------ 683| 0| return; 684| | 685| 65.3k|restart: 686| 65.3k| if (k <= nrLim) ------------------ | Branch (686:13): [True: 53.6k, False: 11.6k] ------------------ 687| 53.6k| { 688| 53.6k| real_t nOctaves; 689| | 690| 53.6k| if (limTable[k-1] != 0) ------------------ | Branch (690:17): [True: 53.6k, False: 0] ------------------ 691| |#if 0 692| | nOctaves = REAL_CONST(log((float)limTable[k]/(float)limTable[k-1])/log(2.0)); 693| |#else 694| 53.6k|#ifdef FIXED_POINT 695| 53.6k| nOctaves = DIV_R((limTable[k]<noPatches; i++) ------------------ | Branch (713:33): [True: 108k, False: 28.1k] ------------------ 714| 108k| { 715| 108k| if (limTable[k] == patchBorders[i]) ------------------ | Branch (715:29): [True: 15.0k, False: 93.1k] ------------------ 716| 15.0k| found = 1; 717| 108k| } 718| 28.1k| if (found) ------------------ | Branch (718:25): [True: 15.0k, False: 13.0k] ------------------ 719| 15.0k| { 720| 15.0k| found2 = 0; 721| 72.7k| for (i = 0; i <= sbr->noPatches; i++) ------------------ | Branch (721:37): [True: 57.6k, False: 15.0k] ------------------ 722| 57.6k| { 723| 57.6k| if (limTable[k-1] == patchBorders[i]) ------------------ | Branch (723:33): [True: 11.0k, False: 46.6k] ------------------ 724| 11.0k| found2 = 1; 725| 57.6k| } 726| 15.0k| if (found2) ------------------ | Branch (726:29): [True: 11.0k, False: 4.06k] ------------------ 727| 11.0k| { 728| 11.0k| k++; 729| 11.0k| goto restart; 730| 11.0k| } else { 731| | /* remove (k-1)th element */ 732| 4.06k| limTable[k-1] = sbr->f_table_res[LO_RES][sbr->N_low]; ------------------ | | 51| 4.06k|#define LO_RES 0 ------------------ 733| 4.06k| qsort(limTable, sbr->noPatches + sbr->N_low, sizeof(limTable[0]), uint8cmp); 734| 4.06k| nrLim--; 735| 4.06k| goto restart; 736| 4.06k| } 737| 15.0k| } 738| 28.1k| } 739| | /* remove kth element */ 740| 18.7k| limTable[k] = sbr->f_table_res[LO_RES][sbr->N_low]; ------------------ | | 51| 18.7k|#define LO_RES 0 ------------------ 741| 18.7k| qsort(limTable, nrLim, sizeof(limTable[0]), uint8cmp); 742| 18.7k| nrLim--; 743| 18.7k| goto restart; 744| 33.8k| } else { 745| 19.8k| k++; 746| 19.8k| goto restart; 747| 19.8k| } 748| 53.6k| } 749| | 750| 11.6k| sbr->N_L[s] = nrLim; 751| 54.1k| for (k = 0; k <= nrLim; k++) ------------------ | Branch (751:21): [True: 42.5k, False: 11.6k] ------------------ 752| 42.5k| { 753| 42.5k| sbr->f_table_lim[s][k] = limTable[k] - sbr->kx; 754| 42.5k| } 755| | 756| |#if 0 757| | printf("f_table_lim[%d][%d]: ", s, sbr->N_L[s]); 758| | for (k = 0; k <= sbr->N_L[s]; k++) 759| | { 760| | printf("%d ", sbr->f_table_lim[s][k]); 761| | } 762| | printf("\n"); 763| |#endif 764| 11.6k| } 765| 3.88k|} sbr_fbt.c:find_bands: 269| 51.0k|{ 270| 51.0k|#ifdef FIXED_POINT 271| | /* table with log2() values */ 272| 51.0k| static const real_t log2Table[65] = { 273| 51.0k| COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(1.0000000000), COEF_CONST(1.5849625007), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(1.0000000000), COEF_CONST(1.5849625007), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(1.0000000000), COEF_CONST(1.5849625007), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(1.0000000000), COEF_CONST(1.5849625007), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 274| 51.0k| COEF_CONST(2.0000000000), COEF_CONST(2.3219280949), COEF_CONST(2.5849625007), COEF_CONST(2.8073549221), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.0000000000), COEF_CONST(2.3219280949), COEF_CONST(2.5849625007), COEF_CONST(2.8073549221), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.0000000000), COEF_CONST(2.3219280949), COEF_CONST(2.5849625007), COEF_CONST(2.8073549221), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.0000000000), COEF_CONST(2.3219280949), COEF_CONST(2.5849625007), COEF_CONST(2.8073549221), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 275| 51.0k| COEF_CONST(3.0000000000), COEF_CONST(3.1699250014), COEF_CONST(3.3219280949), COEF_CONST(3.4594316186), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.0000000000), COEF_CONST(3.1699250014), COEF_CONST(3.3219280949), COEF_CONST(3.4594316186), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.0000000000), COEF_CONST(3.1699250014), COEF_CONST(3.3219280949), COEF_CONST(3.4594316186), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.0000000000), COEF_CONST(3.1699250014), COEF_CONST(3.3219280949), COEF_CONST(3.4594316186), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 276| 51.0k| COEF_CONST(3.5849625007), COEF_CONST(3.7004397181), COEF_CONST(3.8073549221), COEF_CONST(3.9068905956), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.5849625007), COEF_CONST(3.7004397181), COEF_CONST(3.8073549221), COEF_CONST(3.9068905956), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.5849625007), COEF_CONST(3.7004397181), COEF_CONST(3.8073549221), COEF_CONST(3.9068905956), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.5849625007), COEF_CONST(3.7004397181), COEF_CONST(3.8073549221), COEF_CONST(3.9068905956), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 277| 51.0k| COEF_CONST(4.0000000000), COEF_CONST(4.0874628413), COEF_CONST(4.1699250014), COEF_CONST(4.2479275134), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0000000000), COEF_CONST(4.0874628413), COEF_CONST(4.1699250014), COEF_CONST(4.2479275134), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0000000000), COEF_CONST(4.0874628413), COEF_CONST(4.1699250014), COEF_CONST(4.2479275134), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0000000000), COEF_CONST(4.0874628413), COEF_CONST(4.1699250014), COEF_CONST(4.2479275134), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 278| 51.0k| COEF_CONST(4.3219280949), COEF_CONST(4.3923174228), COEF_CONST(4.4594316186), COEF_CONST(4.5235619561), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.3219280949), COEF_CONST(4.3923174228), COEF_CONST(4.4594316186), COEF_CONST(4.5235619561), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.3219280949), COEF_CONST(4.3923174228), COEF_CONST(4.4594316186), COEF_CONST(4.5235619561), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.3219280949), COEF_CONST(4.3923174228), COEF_CONST(4.4594316186), COEF_CONST(4.5235619561), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 279| 51.0k| COEF_CONST(4.5849625007), COEF_CONST(4.6438561898), COEF_CONST(4.7004397181), COEF_CONST(4.7548875022), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.5849625007), COEF_CONST(4.6438561898), COEF_CONST(4.7004397181), COEF_CONST(4.7548875022), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.5849625007), COEF_CONST(4.6438561898), COEF_CONST(4.7004397181), COEF_CONST(4.7548875022), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.5849625007), COEF_CONST(4.6438561898), COEF_CONST(4.7004397181), COEF_CONST(4.7548875022), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 280| 51.0k| COEF_CONST(4.8073549221), COEF_CONST(4.8579809951), COEF_CONST(4.9068905956), COEF_CONST(4.9541963104), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.8073549221), COEF_CONST(4.8579809951), COEF_CONST(4.9068905956), COEF_CONST(4.9541963104), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.8073549221), COEF_CONST(4.8579809951), COEF_CONST(4.9068905956), COEF_CONST(4.9541963104), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.8073549221), COEF_CONST(4.8579809951), COEF_CONST(4.9068905956), COEF_CONST(4.9541963104), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 281| 51.0k| COEF_CONST(5.0000000000), COEF_CONST(5.0443941194), COEF_CONST(5.0874628413), COEF_CONST(5.1292830169), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.0000000000), COEF_CONST(5.0443941194), COEF_CONST(5.0874628413), COEF_CONST(5.1292830169), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.0000000000), COEF_CONST(5.0443941194), COEF_CONST(5.0874628413), COEF_CONST(5.1292830169), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.0000000000), COEF_CONST(5.0443941194), COEF_CONST(5.0874628413), COEF_CONST(5.1292830169), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 282| 51.0k| COEF_CONST(5.1699250014), COEF_CONST(5.2094533656), COEF_CONST(5.2479275134), COEF_CONST(5.2854022189), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.1699250014), COEF_CONST(5.2094533656), COEF_CONST(5.2479275134), COEF_CONST(5.2854022189), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.1699250014), COEF_CONST(5.2094533656), COEF_CONST(5.2479275134), COEF_CONST(5.2854022189), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.1699250014), COEF_CONST(5.2094533656), COEF_CONST(5.2479275134), COEF_CONST(5.2854022189), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 283| 51.0k| COEF_CONST(5.3219280949), COEF_CONST(5.3575520046), COEF_CONST(5.3923174228), COEF_CONST(5.4262647547), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.3219280949), COEF_CONST(5.3575520046), COEF_CONST(5.3923174228), COEF_CONST(5.4262647547), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.3219280949), COEF_CONST(5.3575520046), COEF_CONST(5.3923174228), COEF_CONST(5.4262647547), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.3219280949), COEF_CONST(5.3575520046), COEF_CONST(5.3923174228), COEF_CONST(5.4262647547), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 284| 51.0k| COEF_CONST(5.4594316186), COEF_CONST(5.4918530963), COEF_CONST(5.5235619561), COEF_CONST(5.5545888517), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.4594316186), COEF_CONST(5.4918530963), COEF_CONST(5.5235619561), COEF_CONST(5.5545888517), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.4594316186), COEF_CONST(5.4918530963), COEF_CONST(5.5235619561), COEF_CONST(5.5545888517), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.4594316186), COEF_CONST(5.4918530963), COEF_CONST(5.5235619561), COEF_CONST(5.5545888517), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 285| 51.0k| COEF_CONST(5.5849625007), COEF_CONST(5.6147098441), COEF_CONST(5.6438561898), COEF_CONST(5.6724253420), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.5849625007), COEF_CONST(5.6147098441), COEF_CONST(5.6438561898), COEF_CONST(5.6724253420), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.5849625007), COEF_CONST(5.6147098441), COEF_CONST(5.6438561898), COEF_CONST(5.6724253420), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.5849625007), COEF_CONST(5.6147098441), COEF_CONST(5.6438561898), COEF_CONST(5.6724253420), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 286| 51.0k| COEF_CONST(5.7004397181), COEF_CONST(5.7279204546), COEF_CONST(5.7548875022), COEF_CONST(5.7813597135), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.7004397181), COEF_CONST(5.7279204546), COEF_CONST(5.7548875022), COEF_CONST(5.7813597135), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.7004397181), COEF_CONST(5.7279204546), COEF_CONST(5.7548875022), COEF_CONST(5.7813597135), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.7004397181), COEF_CONST(5.7279204546), COEF_CONST(5.7548875022), COEF_CONST(5.7813597135), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 287| 51.0k| COEF_CONST(5.8073549221), COEF_CONST(5.8328900142), COEF_CONST(5.8579809951), COEF_CONST(5.8826430494), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.8073549221), COEF_CONST(5.8328900142), COEF_CONST(5.8579809951), COEF_CONST(5.8826430494), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.8073549221), COEF_CONST(5.8328900142), COEF_CONST(5.8579809951), COEF_CONST(5.8826430494), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.8073549221), COEF_CONST(5.8328900142), COEF_CONST(5.8579809951), COEF_CONST(5.8826430494), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 288| 51.0k| COEF_CONST(5.9068905956), COEF_CONST(5.9307373376), COEF_CONST(5.9541963104), COEF_CONST(5.9772799235), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.9068905956), COEF_CONST(5.9307373376), COEF_CONST(5.9541963104), COEF_CONST(5.9772799235), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.9068905956), COEF_CONST(5.9307373376), COEF_CONST(5.9541963104), COEF_CONST(5.9772799235), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(5.9068905956), COEF_CONST(5.9307373376), COEF_CONST(5.9541963104), COEF_CONST(5.9772799235), ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 289| 51.0k| COEF_CONST(6.0) ------------------ | | 60| 51.0k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 51.0k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 51.0k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 290| 51.0k| }; 291| 51.0k| real_t r0 = log2Table[a0]; /* coef */ 292| 51.0k| real_t r1 = log2Table[a1]; /* coef */ 293| 51.0k| real_t r2 = (r1 - r0); /* coef */ 294| | 295| 51.0k| if (warp) ------------------ | Branch (295:9): [True: 6.09k, False: 45.0k] ------------------ 296| 6.09k| r2 = MUL_C(r2, COEF_CONST(1.0/1.3)); ------------------ | | 241| 12.1k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 6.09k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 6.09k|#define COEF_BITS 28 | | ------------------ | | | Branch (241:55): [True: 6.09k, Folded] | | ------------------ ------------------ 297| | 298| | /* convert r2 to real and then multiply and round */ 299| 51.0k| r2 = (r2 >> (COEF_BITS-REAL_BITS)) * bands + (1<<(REAL_BITS-1)); ------------------ | | 43| 51.0k|#define COEF_BITS 28 ------------------ r2 = (r2 >> (COEF_BITS-REAL_BITS)) * bands + (1<<(REAL_BITS-1)); ------------------ | | 45| 51.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ r2 = (r2 >> (COEF_BITS-REAL_BITS)) * bands + (1<<(REAL_BITS-1)); ------------------ | | 45| 51.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 300| | 301| 51.0k| return (r2 >> REAL_BITS); ------------------ | | 45| 51.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 302| |#else 303| | real_t div = (real_t)log(2.0); 304| | if (warp) div *= (real_t)1.3; 305| | 306| | return (int32_t)(bands * log((float)a1/(float)a0)/div + 0.5); 307| |#endif 308| 51.0k|} sbr_fbt.c:find_initial_power: 311| 25.3k|{ 312| 25.3k|#ifdef FIXED_POINT 313| | /* table with log() values */ 314| 25.3k| static const real_t logTable[65] = { 315| 25.3k| COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(0.6931471806), COEF_CONST(1.0986122887), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(0.6931471806), COEF_CONST(1.0986122887), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(0.6931471806), COEF_CONST(1.0986122887), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(0.6931471806), COEF_CONST(1.0986122887), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 316| 25.3k| COEF_CONST(1.3862943611), COEF_CONST(1.6094379124), COEF_CONST(1.7917594692), COEF_CONST(1.9459101491), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(1.3862943611), COEF_CONST(1.6094379124), COEF_CONST(1.7917594692), COEF_CONST(1.9459101491), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(1.3862943611), COEF_CONST(1.6094379124), COEF_CONST(1.7917594692), COEF_CONST(1.9459101491), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(1.3862943611), COEF_CONST(1.6094379124), COEF_CONST(1.7917594692), COEF_CONST(1.9459101491), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 317| 25.3k| COEF_CONST(2.0794415417), COEF_CONST(2.1972245773), COEF_CONST(2.3025850930), COEF_CONST(2.3978952728), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.0794415417), COEF_CONST(2.1972245773), COEF_CONST(2.3025850930), COEF_CONST(2.3978952728), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.0794415417), COEF_CONST(2.1972245773), COEF_CONST(2.3025850930), COEF_CONST(2.3978952728), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.0794415417), COEF_CONST(2.1972245773), COEF_CONST(2.3025850930), COEF_CONST(2.3978952728), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 318| 25.3k| COEF_CONST(2.4849066498), COEF_CONST(2.5649493575), COEF_CONST(2.6390573296), COEF_CONST(2.7080502011), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.4849066498), COEF_CONST(2.5649493575), COEF_CONST(2.6390573296), COEF_CONST(2.7080502011), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.4849066498), COEF_CONST(2.5649493575), COEF_CONST(2.6390573296), COEF_CONST(2.7080502011), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.4849066498), COEF_CONST(2.5649493575), COEF_CONST(2.6390573296), COEF_CONST(2.7080502011), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 319| 25.3k| COEF_CONST(2.7725887222), COEF_CONST(2.8332133441), COEF_CONST(2.8903717579), COEF_CONST(2.9444389792), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.7725887222), COEF_CONST(2.8332133441), COEF_CONST(2.8903717579), COEF_CONST(2.9444389792), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.7725887222), COEF_CONST(2.8332133441), COEF_CONST(2.8903717579), COEF_CONST(2.9444389792), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.7725887222), COEF_CONST(2.8332133441), COEF_CONST(2.8903717579), COEF_CONST(2.9444389792), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 320| 25.3k| COEF_CONST(2.9957322736), COEF_CONST(3.0445224377), COEF_CONST(3.0910424534), COEF_CONST(3.1354942159), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.9957322736), COEF_CONST(3.0445224377), COEF_CONST(3.0910424534), COEF_CONST(3.1354942159), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.9957322736), COEF_CONST(3.0445224377), COEF_CONST(3.0910424534), COEF_CONST(3.1354942159), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(2.9957322736), COEF_CONST(3.0445224377), COEF_CONST(3.0910424534), COEF_CONST(3.1354942159), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 321| 25.3k| COEF_CONST(3.1780538303), COEF_CONST(3.2188758249), COEF_CONST(3.2580965380), COEF_CONST(3.2958368660), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.1780538303), COEF_CONST(3.2188758249), COEF_CONST(3.2580965380), COEF_CONST(3.2958368660), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.1780538303), COEF_CONST(3.2188758249), COEF_CONST(3.2580965380), COEF_CONST(3.2958368660), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.1780538303), COEF_CONST(3.2188758249), COEF_CONST(3.2580965380), COEF_CONST(3.2958368660), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 322| 25.3k| COEF_CONST(3.3322045102), COEF_CONST(3.3672958300), COEF_CONST(3.4011973817), COEF_CONST(3.4339872045), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.3322045102), COEF_CONST(3.3672958300), COEF_CONST(3.4011973817), COEF_CONST(3.4339872045), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.3322045102), COEF_CONST(3.3672958300), COEF_CONST(3.4011973817), COEF_CONST(3.4339872045), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.3322045102), COEF_CONST(3.3672958300), COEF_CONST(3.4011973817), COEF_CONST(3.4339872045), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 323| 25.3k| COEF_CONST(3.4657359028), COEF_CONST(3.4965075615), COEF_CONST(3.5263605246), COEF_CONST(3.5553480615), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.4657359028), COEF_CONST(3.4965075615), COEF_CONST(3.5263605246), COEF_CONST(3.5553480615), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.4657359028), COEF_CONST(3.4965075615), COEF_CONST(3.5263605246), COEF_CONST(3.5553480615), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.4657359028), COEF_CONST(3.4965075615), COEF_CONST(3.5263605246), COEF_CONST(3.5553480615), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 324| 25.3k| COEF_CONST(3.5835189385), COEF_CONST(3.6109179126), COEF_CONST(3.6375861597), COEF_CONST(3.6635616461), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.5835189385), COEF_CONST(3.6109179126), COEF_CONST(3.6375861597), COEF_CONST(3.6635616461), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.5835189385), COEF_CONST(3.6109179126), COEF_CONST(3.6375861597), COEF_CONST(3.6635616461), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.5835189385), COEF_CONST(3.6109179126), COEF_CONST(3.6375861597), COEF_CONST(3.6635616461), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 325| 25.3k| COEF_CONST(3.6888794541), COEF_CONST(3.7135720667), COEF_CONST(3.7376696183), COEF_CONST(3.7612001157), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.6888794541), COEF_CONST(3.7135720667), COEF_CONST(3.7376696183), COEF_CONST(3.7612001157), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.6888794541), COEF_CONST(3.7135720667), COEF_CONST(3.7376696183), COEF_CONST(3.7612001157), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.6888794541), COEF_CONST(3.7135720667), COEF_CONST(3.7376696183), COEF_CONST(3.7612001157), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 326| 25.3k| COEF_CONST(3.7841896339), COEF_CONST(3.8066624898), COEF_CONST(3.8286413965), COEF_CONST(3.8501476017), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.7841896339), COEF_CONST(3.8066624898), COEF_CONST(3.8286413965), COEF_CONST(3.8501476017), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.7841896339), COEF_CONST(3.8066624898), COEF_CONST(3.8286413965), COEF_CONST(3.8501476017), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.7841896339), COEF_CONST(3.8066624898), COEF_CONST(3.8286413965), COEF_CONST(3.8501476017), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 327| 25.3k| COEF_CONST(3.8712010109), COEF_CONST(3.8918202981), COEF_CONST(3.9120230054), COEF_CONST(3.9318256327), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.8712010109), COEF_CONST(3.8918202981), COEF_CONST(3.9120230054), COEF_CONST(3.9318256327), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.8712010109), COEF_CONST(3.8918202981), COEF_CONST(3.9120230054), COEF_CONST(3.9318256327), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.8712010109), COEF_CONST(3.8918202981), COEF_CONST(3.9120230054), COEF_CONST(3.9318256327), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 328| 25.3k| COEF_CONST(3.9512437186), COEF_CONST(3.9702919136), COEF_CONST(3.9889840466), COEF_CONST(4.0073331852), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.9512437186), COEF_CONST(3.9702919136), COEF_CONST(3.9889840466), COEF_CONST(4.0073331852), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.9512437186), COEF_CONST(3.9702919136), COEF_CONST(3.9889840466), COEF_CONST(4.0073331852), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(3.9512437186), COEF_CONST(3.9702919136), COEF_CONST(3.9889840466), COEF_CONST(4.0073331852), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 329| 25.3k| COEF_CONST(4.0253516907), COEF_CONST(4.0430512678), COEF_CONST(4.0604430105), COEF_CONST(4.0775374439), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0253516907), COEF_CONST(4.0430512678), COEF_CONST(4.0604430105), COEF_CONST(4.0775374439), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0253516907), COEF_CONST(4.0430512678), COEF_CONST(4.0604430105), COEF_CONST(4.0775374439), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0253516907), COEF_CONST(4.0430512678), COEF_CONST(4.0604430105), COEF_CONST(4.0775374439), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 330| 25.3k| COEF_CONST(4.0943445622), COEF_CONST(4.1108738642), COEF_CONST(4.1271343850), COEF_CONST(4.1431347264), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0943445622), COEF_CONST(4.1108738642), COEF_CONST(4.1271343850), COEF_CONST(4.1431347264), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0943445622), COEF_CONST(4.1108738642), COEF_CONST(4.1271343850), COEF_CONST(4.1431347264), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ COEF_CONST(4.0943445622), COEF_CONST(4.1108738642), COEF_CONST(4.1271343850), COEF_CONST(4.1431347264), ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 331| 25.3k| COEF_CONST(4.158883083) ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 332| 25.3k| }; 333| | /* standard Taylor polynomial coefficients for exp(x) around 0 */ 334| | /* a polynomial around x=1 is more precise, as most values are around 1.07, 335| | but this is just fine already */ 336| 25.3k| static const real_t c1 = COEF_CONST(1.0); ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 337| 25.3k| static const real_t c2 = COEF_CONST(1.0/2.0); ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 338| 25.3k| static const real_t c3 = COEF_CONST(1.0/6.0); ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 339| 25.3k| static const real_t c4 = COEF_CONST(1.0/24.0); ------------------ | | 60| 25.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 25.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 25.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 340| | 341| 25.3k| real_t r0 = logTable[a0]; /* coef */ 342| 25.3k| real_t r1 = logTable[a1]; /* coef */ 343| 25.3k| real_t r2 = (r1 - r0) / bands; /* coef */ 344| 25.3k| real_t rexp = c1 + MUL_C((c1 + MUL_C((c2 + MUL_C((c3 + MUL_C(c4,r2)), r2)), r2)), r2); ------------------ | | 241| 25.3k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 25.3k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 25.3k|#define COEF_BITS 28 | | ------------------ ------------------ 345| | 346| 25.3k| return (rexp >> (COEF_BITS-REAL_BITS)); /* real */ ------------------ | | 43| 25.3k|#define COEF_BITS 28 ------------------ return (rexp >> (COEF_BITS-REAL_BITS)); /* real */ ------------------ | | 45| 25.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 347| |#else 348| | return (real_t)pow((real_t)a1/(real_t)a0, 1.0/(real_t)bands); 349| |#endif 350| 25.3k|} sbr_fbt.c:int32cmp: 109| 239k|{ 110| 239k| return ((int)(*(int32_t*)a - *(int32_t*)b)); 111| 239k|} sbr_fbt.c:uint8cmp: 114| 396k|{ 115| 396k| return ((int)(*(uint8_t*)a - *(uint8_t*)b)); 116| 396k|} hf_adjustment: 61| 3.96k|{ 62| 3.96k| ALIGN sbr_hfadj_info adj = {{{0}}}; 63| 3.96k| uint8_t ret = 0; 64| | 65| 3.96k| if (sbr->bs_frame_class[ch] == FIXFIX) ------------------ | | 46| 3.96k|#define FIXFIX 0 ------------------ | Branch (65:9): [True: 1.12k, False: 2.83k] ------------------ 66| 1.12k| { 67| 1.12k| sbr->l_A[ch] = -1; 68| 2.83k| } else if (sbr->bs_frame_class[ch] == VARFIX) { ------------------ | | 48| 2.83k|#define VARFIX 2 ------------------ | Branch (68:16): [True: 1.47k, False: 1.36k] ------------------ 69| 1.47k| if (sbr->bs_pointer[ch] > 1) ------------------ | Branch (69:13): [True: 147, False: 1.32k] ------------------ 70| 147| sbr->l_A[ch] = sbr->bs_pointer[ch] - 1; 71| 1.32k| else 72| 1.32k| sbr->l_A[ch] = -1; 73| 1.47k| } else { 74| 1.36k| if (sbr->bs_pointer[ch] == 0) ------------------ | Branch (74:13): [True: 310, False: 1.05k] ------------------ 75| 310| sbr->l_A[ch] = -1; 76| 1.05k| else 77| 1.05k| sbr->l_A[ch] = sbr->L_E[ch] + 1 - sbr->bs_pointer[ch]; 78| 1.36k| } 79| | 80| 3.96k| ret = estimate_current_envelope(sbr, &adj, Xsbr, ch); 81| 3.96k| if (ret > 0) ------------------ | Branch (81:9): [True: 336, False: 3.62k] ------------------ 82| 336| return 1; 83| | 84| 3.62k| calculate_gain(sbr, &adj, ch); 85| | 86| |#ifdef SBR_LOW_POWER 87| | calc_gain_groups(sbr, &adj, deg, ch); 88| | aliasing_reduction(sbr, &adj, deg, ch); 89| |#endif 90| | 91| 3.62k| hf_assembly(sbr, &adj, Xsbr, ch); 92| | 93| 3.62k| return 0; 94| 3.96k|} sbr_hfadj.c:estimate_current_envelope: 139| 3.96k|{ 140| 3.96k| uint8_t m, l, j, k, k_l, k_h, p; 141| 3.96k| real_t div; 142| 3.96k| (void)adj; /* TODO: remove parameter? */ 143| 3.96k|#ifdef FIXED_POINT 144| | /* the per-bin energy is accumulated over the envelope's time slots and, 145| | for the wider bands, its QMF bins; that sum exceeds 32 bits on ordinary 146| | content, so keep it in 64 bits. the running int32 sum otherwise wraps 147| | before the limit test below can reject an over-range energy. */ 148| 3.96k| int64_t nrg; 149| 3.96k| const real_t half = REAL_CONST(0.5); ------------------ | | 59| 3.96k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.96k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.96k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 3.96k, Folded] | | ------------------ ------------------ 150| 3.96k| real_t limit; 151| 3.96k| real_t mul; 152| |#else 153| | real_t nrg; 154| | const real_t half = 0; /* Compiler is smart enough to eliminate +0 op. */ 155| | const real_t limit = FLT_MAX; 156| |#endif 157| | 158| 3.96k| if (sbr->bs_interpol_freq == 1) ------------------ | Branch (158:9): [True: 3.15k, False: 811] ------------------ 159| 3.15k| { 160| 8.65k| for (l = 0; l < sbr->L_E[ch]; l++) ------------------ | Branch (160:21): [True: 5.68k, False: 2.96k] ------------------ 161| 5.68k| { 162| 5.68k| uint8_t i, l_i, u_i; 163| | 164| 5.68k| l_i = sbr->t_E[ch][l]; 165| 5.68k| u_i = sbr->t_E[ch][l+1]; 166| | 167| 5.68k| div = (real_t)(u_i - l_i); 168| | 169| 5.68k| if (div <= 0) ------------------ | Branch (169:17): [True: 174, False: 5.50k] ------------------ 170| 174| div = 1; 171| 5.68k|#ifdef FIXED_POINT 172| 5.68k| limit = div << (30 - (COEF_BITS - REAL_BITS)); ------------------ | | 43| 5.68k|#define COEF_BITS 28 ------------------ limit = div << (30 - (COEF_BITS - REAL_BITS)); ------------------ | | 45| 5.68k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 173| 5.68k| mul = (1 << (COEF_BITS - REAL_BITS)) / div; ------------------ | | 43| 5.68k|#define COEF_BITS 28 ------------------ mul = (1 << (COEF_BITS - REAL_BITS)) / div; ------------------ | | 45| 5.68k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 174| 5.68k|#endif 175| | 176| 63.7k| for (m = 0; m < sbr->M; m++) ------------------ | Branch (176:25): [True: 58.2k, False: 5.50k] ------------------ 177| 58.2k| { 178| 58.2k| nrg = 0; 179| | 180| 1.10M| for (i = l_i + sbr->tHFAdj; i < u_i + sbr->tHFAdj; i++) ------------------ | Branch (180:45): [True: 1.05M, False: 58.2k] ------------------ 181| 1.05M| { 182| 1.05M| real_t re = QMF_RE(Xsbr[i][m + sbr->kx]) + half; ------------------ | | 168| 1.05M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.05M|#define RE(A) (A)[0] | | ------------------ ------------------ 183| 1.05M| real_t im = QMF_IM(Xsbr[i][m + sbr->kx]) + half; ------------------ | | 169| 1.05M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.05M|#define IM(A) (A)[1] | | ------------------ ------------------ 184| 1.05M| (void)im; 185| | /* Actually, that should be MUL_R. On floating-point build 186| | that is the same. On fixed point-build we use it to 187| | pre-scale result (to aviod overflow). That, of course 188| | causes some precision loss. */ 189| 1.05M| nrg += MUL_C(re, re) ------------------ | | 241| 1.05M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 1.05M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 1.05M|#define COEF_BITS 28 | | ------------------ ------------------ 190| 1.05M|#ifndef SBR_LOW_POWER 191| 1.05M| + MUL_C(im, im) ------------------ | | 241| 1.05M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 1.05M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 1.05M|#define COEF_BITS 28 | | ------------------ ------------------ 192| 1.05M|#endif 193| 1.05M| ; 194| 1.05M| } 195| | 196| 58.2k| if (nrg < -limit || nrg > limit) ------------------ | Branch (196:21): [True: 24, False: 58.2k] | Branch (196:37): [True: 159, False: 58.1k] ------------------ 197| 183| return 1; 198| 58.1k|#ifdef FIXED_POINT 199| 58.1k| sbr->E_curr[ch][m][l] = nrg * mul; 200| |#else 201| | sbr->E_curr[ch][m][l] = nrg / div; 202| |#endif 203| |#ifdef SBR_LOW_POWER 204| |#ifdef FIXED_POINT 205| | sbr->E_curr[ch][m][l] <<= 1; 206| |#else 207| | sbr->E_curr[ch][m][l] *= 2; 208| |#endif 209| |#endif 210| 58.1k| } 211| 5.68k| } 212| 3.15k| } else { 213| 2.02k| for (l = 0; l < sbr->L_E[ch]; l++) ------------------ | Branch (213:21): [True: 1.36k, False: 658] ------------------ 214| 1.36k| { 215| 8.92k| for (p = 0; p < sbr->n[sbr->f[ch][l]]; p++) ------------------ | Branch (215:25): [True: 7.70k, False: 1.21k] ------------------ 216| 7.70k| { 217| 7.70k| k_l = sbr->f_table_res[sbr->f[ch][l]][p]; 218| 7.70k| k_h = sbr->f_table_res[sbr->f[ch][l]][p+1]; 219| | 220| 34.5k| for (k = k_l; k < k_h; k++) ------------------ | Branch (220:31): [True: 27.0k, False: 7.55k] ------------------ 221| 27.0k| { 222| 27.0k| uint8_t i, l_i, u_i; 223| 27.0k| nrg = 0; 224| | 225| 27.0k| l_i = sbr->t_E[ch][l]; 226| 27.0k| u_i = sbr->t_E[ch][l+1]; 227| | 228| 27.0k| div = (real_t)((u_i - l_i)*(k_h - k_l)); 229| | 230| 27.0k| if (div <= 0) ------------------ | Branch (230:25): [True: 1.84k, False: 25.1k] ------------------ 231| 1.84k| div = 1; 232| 27.0k|#ifdef FIXED_POINT 233| 27.0k| limit = div << (30 - (COEF_BITS - REAL_BITS)); ------------------ | | 43| 27.0k|#define COEF_BITS 28 ------------------ limit = div << (30 - (COEF_BITS - REAL_BITS)); ------------------ | | 45| 27.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 234| 27.0k| mul = (1 << (COEF_BITS - REAL_BITS)) / div; ------------------ | | 43| 27.0k|#define COEF_BITS 28 ------------------ mul = (1 << (COEF_BITS - REAL_BITS)) / div; ------------------ | | 45| 27.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 235| 27.0k|#endif 236| | 237| 459k| for (i = l_i + sbr->tHFAdj; i < u_i + sbr->tHFAdj; i++) ------------------ | Branch (237:49): [True: 432k, False: 27.0k] ------------------ 238| 432k| { 239| 3.04M| for (j = k_l; j < k_h; j++) ------------------ | Branch (239:39): [True: 2.61M, False: 432k] ------------------ 240| 2.61M| { 241| 2.61M| real_t re = QMF_RE(Xsbr[i][j]) + half; ------------------ | | 168| 2.61M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 2.61M|#define RE(A) (A)[0] | | ------------------ ------------------ 242| 2.61M| real_t im = QMF_IM(Xsbr[i][j]) + half; ------------------ | | 169| 2.61M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 2.61M|#define IM(A) (A)[1] | | ------------------ ------------------ 243| 2.61M| (void)im; 244| | /* Actually, that should be MUL_R. On floating-point build 245| | that is the same. On fixed point-build we use it to 246| | pre-scale result (to aviod overflow). That, of course 247| | causes some precision loss. */ 248| 2.61M| nrg += MUL_C(re, re) ------------------ | | 241| 2.61M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 2.61M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 2.61M|#define COEF_BITS 28 | | ------------------ ------------------ 249| 2.61M|#ifndef SBR_LOW_POWER 250| 2.61M| + MUL_C(im, im) ------------------ | | 241| 2.61M| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 2.61M|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 2.61M|#define COEF_BITS 28 | | ------------------ ------------------ 251| 2.61M|#endif 252| 2.61M| ; 253| 2.61M| } 254| 432k| } 255| | 256| 27.0k| if (nrg < -limit || nrg > limit) ------------------ | Branch (256:25): [True: 4, False: 27.0k] | Branch (256:41): [True: 149, False: 26.8k] ------------------ 257| 153| return 1; 258| 26.8k|#ifdef FIXED_POINT 259| 26.8k| sbr->E_curr[ch][k - sbr->kx][l] = nrg * mul; 260| |#else 261| | sbr->E_curr[ch][k - sbr->kx][l] = nrg / div; 262| |#endif 263| |#ifdef SBR_LOW_POWER 264| |#ifdef FIXED_POINT 265| | sbr->E_curr[ch][k - sbr->kx][l] <<= 1; 266| |#else 267| | sbr->E_curr[ch][k - sbr->kx][l] *= 2; 268| |#endif 269| |#endif 270| 26.8k| } 271| 7.70k| } 272| 1.36k| } 273| 811| } 274| | 275| 3.62k| return 0; 276| 3.96k|} sbr_hfadj.c:calculate_gain: 468| 3.62k|{ 469| | /* log2 values of limiter gains */ 470| | /* Last one less than log2(1e10) due to FIXED POINT float limitations */ 471| 3.62k| static real_t limGain[] = { 472| 3.62k| REAL_CONST(-1.0), REAL_CONST(0.0), REAL_CONST(1.0), REAL_CONST(21.0) ------------------ | | 59| 3.62k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.62k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.62k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [Folded, False: 3.62k] | | ------------------ ------------------ REAL_CONST(-1.0), REAL_CONST(0.0), REAL_CONST(1.0), REAL_CONST(21.0) ------------------ | | 59| 3.62k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.62k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.62k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(-1.0), REAL_CONST(0.0), REAL_CONST(1.0), REAL_CONST(21.0) ------------------ | | 59| 3.62k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.62k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.62k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(-1.0), REAL_CONST(0.0), REAL_CONST(1.0), REAL_CONST(21.0) ------------------ | | 59| 3.62k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.62k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.62k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ 473| 3.62k| }; 474| 3.62k| uint8_t m, l, k; 475| | 476| 3.62k| uint8_t current_t_noise_band = 0; 477| 3.62k| uint8_t S_mapped; 478| | 479| 3.62k| ALIGN real_t Q_M_lim[MAX_M]; 480| 3.62k| ALIGN real_t G_lim[MAX_M]; 481| 3.62k| ALIGN real_t G_boost; 482| 3.62k| ALIGN real_t S_M[MAX_M]; 483| | 484| 3.62k| real_t exp = REAL_CONST(-10); ------------------ | | 59| 3.62k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 3.62k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 3.62k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [Folded, False: 3.62k] | | ------------------ ------------------ 485| | 486| 10.3k| for (l = 0; l < sbr->L_E[ch]; l++) ------------------ | Branch (486:17): [True: 6.71k, False: 3.62k] ------------------ 487| 6.71k| { 488| 6.71k| uint8_t current_f_noise_band = 0; 489| 6.71k| uint8_t current_res_band = 0; 490| 6.71k| uint8_t current_res_band2 = 0; 491| 6.71k| uint8_t current_hi_res_band = 0; 492| | 493| 6.71k| real_t delta = (l == sbr->l_A[ch] || l == sbr->prevEnvIsShort[ch]) ? 0 : 1; ------------------ | Branch (493:25): [True: 333, False: 6.38k] | Branch (493:46): [True: 252, False: 6.12k] ------------------ 494| | 495| 6.71k| S_mapped = get_S_mapped(sbr, ch, l, current_res_band2); 496| | 497| 6.71k| if (sbr->t_E[ch][l+1] > sbr->t_Q[ch][current_t_noise_band+1]) ------------------ | Branch (497:13): [True: 1.16k, False: 5.54k] ------------------ 498| 1.16k| { 499| 1.16k| current_t_noise_band++; 500| 1.16k| } 501| | 502| 20.8k| for (k = 0; k < sbr->N_L[sbr->bs_limiter_bands]; k++) ------------------ | Branch (502:21): [True: 14.1k, False: 6.71k] ------------------ 503| 14.1k| { 504| 14.1k| real_t Q_M = 0; 505| 14.1k| real_t G_max; 506| 14.1k| uint64_t den = 0, acc1 = 0, acc2 = 0; 507| 14.1k| uint8_t current_res_band_size = 0; 508| 14.1k| uint8_t Q_M_size = 0; 509| 14.1k| real_t log_e, log_den, log_acc1, log_acc2; 510| | 511| 14.1k| uint8_t ml1, ml2; 512| | 513| | /* bounds of current limiter bands */ 514| 14.1k| ml1 = sbr->f_table_lim[sbr->bs_limiter_bands][k]; 515| 14.1k| ml2 = sbr->f_table_lim[sbr->bs_limiter_bands][k+1]; 516| | 517| 14.1k| if (ml1 > MAX_M) ------------------ | | 50| 14.1k|#define MAX_M 49 ------------------ | Branch (517:17): [True: 0, False: 14.1k] ------------------ 518| 0| ml1 = MAX_M; ------------------ | | 50| 0|#define MAX_M 49 ------------------ 519| | 520| 14.1k| if (ml2 > MAX_M) ------------------ | | 50| 14.1k|#define MAX_M 49 ------------------ | Branch (520:17): [True: 0, False: 14.1k] ------------------ 521| 0| ml2 = MAX_M; ------------------ | | 50| 0|#define MAX_M 49 ------------------ 522| | 523| | 524| | /* calculate the accumulated E_orig and E_curr over the limiter band */ 525| 96.2k| for (m = ml1; m < ml2; m++) ------------------ | Branch (525:27): [True: 82.0k, False: 14.1k] ------------------ 526| 82.0k| { 527| 82.0k| if ((m + sbr->kx) < sbr->f_table_res[sbr->f[ch][l]][current_res_band+1]) ------------------ | Branch (527:21): [True: 58.7k, False: 23.3k] ------------------ 528| 58.7k| { 529| 58.7k| current_res_band_size++; 530| 58.7k| } else { 531| 23.3k| log_e = find_log2_E(sbr, current_res_band, l, ch); 532| 23.3k| acc1 += pow2_int(exp + log2_int_tab[current_res_band_size] + log_e); 533| | 534| 23.3k| current_res_band++; 535| 23.3k| current_res_band_size = 1; 536| 23.3k| } 537| | 538| 82.0k| acc2 += sbr->E_curr[ch][m][l]; 539| 82.0k| } 540| 14.1k| if (current_res_band_size) { ------------------ | Branch (540:17): [True: 14.1k, False: 0] ------------------ 541| 14.1k| log_e = find_log2_E(sbr, current_res_band, l, ch); 542| 14.1k| acc1 += pow2_int(exp + log2_int_tab[current_res_band_size] + log_e); 543| 14.1k| } 544| | 545| | 546| 14.1k| if (acc1 == 0) ------------------ | Branch (546:17): [True: 9.33k, False: 4.81k] ------------------ 547| 9.33k| log_acc1 = LOG2_MIN_INF; ------------------ | | 400| 9.33k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 9.33k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 9.33k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 9.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 9.33k] | | | | ------------------ | | ------------------ ------------------ 548| 4.81k| else 549| 4.81k| log_acc1 = log2_int(acc1); 550| | 551| 14.1k| if (acc2 == 0) ------------------ | Branch (551:17): [True: 13.8k, False: 340] ------------------ 552| 13.8k| log_acc2 = LOG2_MIN_INF; ------------------ | | 400| 13.8k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 13.8k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 13.8k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 13.8k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 13.8k] | | | | ------------------ | | ------------------ ------------------ 553| 340| else 554| 340| log_acc2 = log2_int(acc2); 555| | 556| | /* calculate the maximum gain */ 557| | /* ratio of the energy of the original signal and the energy 558| | * of the HF generated signal 559| | */ 560| 14.1k| G_max = log_acc1 - log_acc2 + limGain[sbr->bs_limiter_gains]; 561| 14.1k| G_max = min(G_max, limGain[3]); ------------------ | | 60| 14.1k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 8.95k, False: 5.20k] | | ------------------ ------------------ 562| | 563| | 564| 96.2k| for (m = ml1; m < ml2; m++) ------------------ | Branch (564:27): [True: 82.0k, False: 14.1k] ------------------ 565| 82.0k| { 566| 82.0k| real_t G; 567| 82.0k| real_t E_curr, E_orig; 568| 82.0k| real_t Q_orig, Q_orig_plus1; 569| 82.0k| uint8_t S_index_mapped; 570| | 571| | 572| | /* check if m is on a noise band border */ 573| 82.0k| if ((m + sbr->kx) == sbr->f_table_noise[current_f_noise_band+1]) ------------------ | Branch (573:21): [True: 5.79k, False: 76.3k] ------------------ 574| 5.79k| { 575| | /* step to next noise band */ 576| 5.79k| current_f_noise_band++; 577| 5.79k| } 578| | 579| | 580| | /* check if m is on a resolution band border */ 581| 82.0k| if ((m + sbr->kx) == sbr->f_table_res[sbr->f[ch][l]][current_res_band2+1]) ------------------ | Branch (581:21): [True: 23.3k, False: 58.7k] ------------------ 582| 23.3k| { 583| | /* accumulate a whole range of equal Q_Ms */ 584| 23.3k| if (Q_M_size > 0) ------------------ | Branch (584:25): [True: 10.5k, False: 12.7k] ------------------ 585| 10.5k| den += pow2_int(log2_int_tab[Q_M_size] + Q_M); 586| 23.3k| Q_M_size = 0; 587| | 588| | /* step to next resolution band */ 589| 23.3k| current_res_band2++; 590| | 591| | /* if we move to a new resolution band, we should check if we are 592| | * going to add a sinusoid in this band 593| | */ 594| 23.3k| S_mapped = get_S_mapped(sbr, ch, l, current_res_band2); 595| 23.3k| } 596| | 597| | 598| | /* check if m is on a HI_RES band border */ 599| 82.0k| if ((m + sbr->kx) == sbr->f_table_res[HI_RES][current_hi_res_band+1]) ------------------ | | 52| 82.0k|#define HI_RES 1 ------------------ | Branch (599:21): [True: 35.3k, False: 46.7k] ------------------ 600| 35.3k| { 601| | /* step to next HI_RES band */ 602| 35.3k| current_hi_res_band++; 603| 35.3k| } 604| | 605| | 606| | /* find S_index_mapped 607| | * S_index_mapped can only be 1 for the m in the middle of the 608| | * current HI_RES band 609| | */ 610| 82.0k| S_index_mapped = 0; 611| 82.0k| if ((l >= sbr->l_A[ch]) || ------------------ | Branch (611:21): [True: 66.5k, False: 15.5k] ------------------ 612| 15.5k| (sbr->bs_add_harmonic_prev[ch][current_hi_res_band] && sbr->bs_add_harmonic_flag_prev[ch])) ------------------ | Branch (612:22): [True: 87, False: 15.5k] | Branch (612:76): [True: 87, False: 0] ------------------ 613| 66.5k| { 614| | /* find the middle subband of the HI_RES frequency band */ 615| 66.5k| if ((m + sbr->kx) == (sbr->f_table_res[HI_RES][current_hi_res_band+1] + sbr->f_table_res[HI_RES][current_hi_res_band]) >> 1) ------------------ | | 52| 66.5k|#define HI_RES 1 ------------------ if ((m + sbr->kx) == (sbr->f_table_res[HI_RES][current_hi_res_band+1] + sbr->f_table_res[HI_RES][current_hi_res_band]) >> 1) ------------------ | | 52| 66.5k|#define HI_RES 1 ------------------ | Branch (615:25): [True: 33.9k, False: 32.6k] ------------------ 616| 33.9k| S_index_mapped = sbr->bs_add_harmonic[ch][current_hi_res_band]; 617| 66.5k| } 618| | 619| | 620| | /* find bitstream parameters */ 621| 82.0k| if (sbr->E_curr[ch][m][l] == 0) ------------------ | Branch (621:21): [True: 79.4k, False: 2.69k] ------------------ 622| 79.4k| E_curr = LOG2_MIN_INF; ------------------ | | 400| 79.4k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 79.4k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 79.4k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 79.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 79.4k] | | | | ------------------ | | ------------------ ------------------ 623| 2.69k| else 624| 2.69k| E_curr = log2_int(sbr->E_curr[ch][m][l]); 625| 82.0k| E_orig = exp + find_log2_E(sbr, current_res_band2, l, ch); 626| | 627| | 628| 82.0k| Q_orig = find_log2_Q(sbr, current_f_noise_band, current_t_noise_band, ch); 629| 82.0k| Q_orig_plus1 = find_log2_Qplus1(sbr, current_f_noise_band, current_t_noise_band, ch); 630| | 631| | 632| | /* Q_M only depends on E_orig and Q_div2: 633| | * since N_Q <= N_Low <= N_High we only need to recalculate Q_M on 634| | * a change of current res band (HI or LO) 635| | */ 636| 82.0k| Q_M = E_orig + Q_orig - Q_orig_plus1; 637| | 638| | 639| | /* S_M only depends on E_orig, Q_div and S_index_mapped: 640| | * S_index_mapped can only be non-zero once per HI_RES band 641| | */ 642| 82.0k| if (S_index_mapped == 0) ------------------ | Branch (642:21): [True: 78.1k, False: 3.90k] ------------------ 643| 78.1k| { 644| 78.1k| S_M[m] = LOG2_MIN_INF; /* -inf */ ------------------ | | 400| 78.1k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 78.1k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 78.1k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 78.1k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 78.1k] | | | | ------------------ | | ------------------ ------------------ 645| 78.1k| } else { 646| 3.90k| S_M[m] = E_orig - Q_orig_plus1; 647| 3.90k| S_M[m] = min(S_M[m], limGain[3]); ------------------ | | 60| 3.90k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 3.27k, False: 639] | | ------------------ ------------------ 648| | 649| | /* accumulate sinusoid part of the total energy */ 650| 3.90k| den += pow2_int(S_M[m]); 651| 3.90k| } 652| | 653| | 654| | /* calculate gain */ 655| | /* ratio of the energy of the original signal and the energy 656| | * of the HF generated signal 657| | */ 658| | /* E_curr here is officially E_curr+1 so the log2() of that can never be < 0 */ 659| | /* scaled by exp */ 660| 82.0k| G = E_orig - max(exp, E_curr); ------------------ | | 57| 82.0k|#define max(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (57:20): [True: 79.4k, False: 2.69k] | | ------------------ ------------------ 661| 82.0k| if ((S_mapped == 0) && (delta == 1)) ------------------ | Branch (661:21): [True: 73.5k, False: 8.56k] | Branch (661:40): [True: 68.0k, False: 5.48k] ------------------ 662| 68.0k| { 663| | /* G = G * 1/(1+Q) */ 664| 68.0k| G -= Q_orig_plus1; 665| 68.0k| } else if (S_mapped == 1) { ------------------ | Branch (665:28): [True: 8.56k, False: 5.48k] ------------------ 666| | /* G = G * Q/(1+Q) */ 667| 8.56k| G += Q_orig - Q_orig_plus1; 668| 8.56k| } 669| | 670| | 671| | /* limit the additional noise energy level */ 672| | /* and apply the limiter */ 673| 82.0k| if (G_max > G) ------------------ | Branch (673:21): [True: 51.1k, False: 30.9k] ------------------ 674| 51.1k| { 675| 51.1k| Q_M_lim[m] = Q_M; 676| 51.1k| G_lim[m] = G; 677| | 678| 51.1k| if ((S_index_mapped == 0) && (l != sbr->l_A[ch])) ------------------ | Branch (678:25): [True: 48.7k, False: 2.34k] | Branch (678:50): [True: 46.9k, False: 1.80k] ------------------ 679| 46.9k| { 680| 46.9k| Q_M_size++; 681| 46.9k| } 682| 51.1k| } else { 683| | /* G >= G_max */ 684| 30.9k| Q_M_lim[m] = Q_M + G_max - G; 685| 30.9k| G_lim[m] = G_max; 686| | 687| | /* accumulate limited Q_M */ 688| 30.9k| if ((S_index_mapped == 0) && (l != sbr->l_A[ch])) ------------------ | Branch (688:25): [True: 29.3k, False: 1.56k] | Branch (688:50): [True: 26.7k, False: 2.65k] ------------------ 689| 26.7k| { 690| 26.7k| den += pow2_int(Q_M_lim[m]); 691| 26.7k| } 692| 30.9k| } 693| | 694| | 695| | /* accumulate the total energy */ 696| | /* E_curr changes for every m so we do need to accumulate every m */ 697| 82.0k| den += pow2_int(E_curr + G_lim[m]); 698| 82.0k| } 699| | 700| | /* accumulate last range of equal Q_Ms */ 701| 14.1k| if (Q_M_size > 0) ------------------ | Branch (701:17): [True: 7.80k, False: 6.35k] ------------------ 702| 7.80k| { 703| 7.80k| den += pow2_int(log2_int_tab[Q_M_size] + Q_M); 704| 7.80k| } 705| | 706| 14.1k| if (den == 0) ------------------ | Branch (706:17): [True: 10.9k, False: 3.17k] ------------------ 707| 10.9k| log_den = LOG2_MIN_INF; ------------------ | | 400| 10.9k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 10.9k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 10.9k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 10.9k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 10.9k] | | | | ------------------ | | ------------------ ------------------ 708| 3.17k| else 709| 3.17k| log_den = log2_int(den /*+ EPS*/); 710| | 711| | /* calculate the final gain */ 712| | /* G_boost: [0..2.51188643] */ 713| 14.1k| G_boost = log_acc1 - log_den; 714| 14.1k| G_boost = min(G_boost, REAL_CONST(1.328771237) /* log2(1.584893192 ^ 2) */); ------------------ | | 60| 28.3k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 9.97k, False: 4.18k] | | | Branch (60:28): [True: 14.1k, Folded] | | | Branch (60:41): [True: 4.18k, Folded] | | ------------------ ------------------ 715| | 716| | 717| 96.2k| for (m = ml1; m < ml2; m++) ------------------ | Branch (717:27): [True: 82.0k, False: 14.1k] ------------------ 718| 82.0k| { 719| | /* apply compensation to gain, noise floor sf's and sinusoid levels */ 720| 82.0k|#ifndef SBR_LOW_POWER 721| 82.0k| adj->G_lim_boost[l][m] = pow2_fix((G_lim[m] + G_boost) >> 1); 722| |#else 723| | /* sqrt() will be done after the aliasing reduction to save a 724| | * few multiplies 725| | */ 726| | adj->G_lim_boost[l][m] = pow2_fix(G_lim[m] + G_boost); 727| |#endif 728| 82.0k| adj->Q_M_lim_boost[l][m] = pow2_fix((Q_M_lim[m] + G_boost) >> 1); 729| | 730| 82.0k| adj->S_M_boost[l][m] = pow2_fix((S_M[m] + G_boost) >> 1); 731| 82.0k| } 732| 14.1k| } 733| 6.71k| } 734| 3.62k|} sbr_hfadj.c:get_S_mapped: 97| 30.0k|{ 98| 30.0k| if (sbr->f[ch][l] == HI_RES) ------------------ | | 52| 30.0k|#define HI_RES 1 ------------------ | Branch (98:9): [True: 16.2k, False: 13.8k] ------------------ 99| 16.2k| { 100| | /* in case of using f_table_high we just have 1 to 1 mapping 101| | * from bs_add_harmonic[l][k] 102| | */ 103| 16.2k| if ((l >= sbr->l_A[ch]) || ------------------ | Branch (103:13): [True: 11.7k, False: 4.50k] ------------------ 104| 4.50k| (sbr->bs_add_harmonic_prev[ch][current_band] && sbr->bs_add_harmonic_flag_prev[ch])) ------------------ | Branch (104:14): [True: 2, False: 4.50k] | Branch (104:61): [True: 2, False: 0] ------------------ 105| 11.7k| { 106| 11.7k| return sbr->bs_add_harmonic[ch][current_band]; 107| 11.7k| } 108| 16.2k| } else { 109| 13.8k| uint8_t b, lb, ub; 110| | 111| | /* in case of f_table_low we check if any of the HI_RES bands 112| | * within this LO_RES band has bs_add_harmonic[l][k] turned on 113| | * (note that borders in the LO_RES table are also present in 114| | * the HI_RES table) 115| | */ 116| | 117| | /* find first HI_RES band in current LO_RES band */ 118| 13.8k| lb = 2*current_band - ((sbr->N_high & 1) ? 1 : 0); ------------------ | Branch (118:32): [True: 4.66k, False: 9.13k] ------------------ 119| | /* find first HI_RES band in next LO_RES band */ 120| 13.8k| ub = 2*(current_band+1) - ((sbr->N_high & 1) ? 1 : 0); ------------------ | Branch (120:36): [True: 4.66k, False: 9.13k] ------------------ 121| | 122| | /* check all HI_RES bands in current LO_RES band for sinusoid */ 123| 35.1k| for (b = lb; b < ub; b++) ------------------ | Branch (123:22): [True: 22.8k, False: 12.2k] ------------------ 124| 22.8k| { 125| 22.8k| if ((l >= sbr->l_A[ch]) || ------------------ | Branch (125:17): [True: 19.9k, False: 2.86k] ------------------ 126| 2.86k| (sbr->bs_add_harmonic_prev[ch][b] && sbr->bs_add_harmonic_flag_prev[ch])) ------------------ | Branch (126:18): [True: 31, False: 2.83k] | Branch (126:54): [True: 31, False: 0] ------------------ 127| 20.0k| { 128| 20.0k| if (sbr->bs_add_harmonic[ch][b] == 1) ------------------ | Branch (128:21): [True: 1.51k, False: 18.5k] ------------------ 129| 1.51k| return 1; 130| 20.0k| } 131| 22.8k| } 132| 13.8k| } 133| | 134| 16.7k| return 0; 135| 30.0k|} sbr_hfadj.c:find_log2_E: 316| 119k|{ 317| | /* check for coupled energy/noise data */ 318| 119k| if (sbr->bs_coupling == 1) ------------------ | Branch (318:9): [True: 45.0k, False: 74.5k] ------------------ 319| 45.0k| { 320| 45.0k| int16_t e = sbr->E[0][k][l]; 321| 45.0k| int16_t E = sbr->E[1][k][l]; 322| 45.0k| uint8_t amp0 = (sbr->amp_res[0]) ? 0 : 1; ------------------ | Branch (322:24): [True: 27.4k, False: 17.5k] ------------------ 323| 45.0k| uint8_t amp1 = (sbr->amp_res[1]) ? 0 : 1; ------------------ | Branch (323:24): [True: 27.4k, False: 17.5k] ------------------ 324| 45.0k| real_t tmp, pan; 325| | 326| | /* E[1] should always be even so shifting is OK */ 327| 45.0k| E >>= amp1; 328| 45.0k| if (e < 0 || e >= 64 || E < 0 || E > 24) ------------------ | Branch (328:13): [True: 4.95k, False: 40.0k] | Branch (328:22): [True: 3.93k, False: 36.1k] | Branch (328:33): [True: 904, False: 35.2k] | Branch (328:42): [True: 6.24k, False: 28.9k] ------------------ 329| 16.0k| return LOG2_MIN_INF; ------------------ | | 400| 16.0k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 16.0k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 16.0k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 16.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 16.0k] | | | | ------------------ | | ------------------ ------------------ 330| 28.9k| E -= 12; 331| | 332| 28.9k| if (ch != 0) // L/R anti-symmetry ------------------ | Branch (332:13): [True: 14.5k, False: 14.4k] ------------------ 333| 14.5k| E = -E; 334| | 335| 28.9k| if (E >= 0) ------------------ | Branch (335:13): [True: 14.7k, False: 14.1k] ------------------ 336| 14.7k| { 337| | /* negative */ 338| 14.7k| pan = pan_log2_tab[E]; 339| 14.7k| } else { 340| | /* positive */ 341| 14.1k| pan = pan_log2_tab[-E] + ((-E)<E[ch][k][l]; 349| 74.5k| uint8_t amp = (sbr->amp_res[ch]) ? 0 : 1; ------------------ | Branch (349:23): [True: 38.6k, False: 35.9k] ------------------ 350| 74.5k| if (e < 0 || (e >> amp) >= 64) ------------------ | Branch (350:13): [True: 9.80k, False: 64.7k] | Branch (350:22): [True: 2.26k, False: 62.4k] ------------------ 351| 12.0k| return LOG2_MIN_INF; ------------------ | | 400| 12.0k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 12.0k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 12.0k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 12.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 12.0k] | | | | ------------------ | | ------------------ ------------------ 352| 62.4k| return 6 * REAL_PRECISION + e * (REAL_PRECISION >> amp); ------------------ | | 46| 62.4k|#define REAL_PRECISION (1 << REAL_BITS) | | ------------------ | | | | 45| 62.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ return 6 * REAL_PRECISION + e * (REAL_PRECISION >> amp); ------------------ | | 46| 62.4k|#define REAL_PRECISION (1 << REAL_BITS) | | ------------------ | | | | 45| 62.4k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 353| 74.5k| } 354| 119k|} sbr_hfadj.c:find_log2_Q: 357| 82.0k|{ 358| | /* check for coupled energy/noise data */ 359| 82.0k| if (sbr->bs_coupling == 1) ------------------ | Branch (359:9): [True: 32.3k, False: 49.7k] ------------------ 360| 32.3k| { 361| 32.3k| int32_t q = sbr->Q[0][k][l]; 362| 32.3k| int32_t Q = sbr->Q[1][k][l]; 363| 32.3k| real_t tmp, pan; 364| | 365| 32.3k| if (q < 0 || q > 30 || Q < 0 || Q > 24) ------------------ | Branch (365:13): [True: 4.79k, False: 27.5k] | Branch (365:22): [True: 738, False: 26.8k] | Branch (365:32): [True: 2.80k, False: 24.0k] | Branch (365:41): [True: 3.31k, False: 20.7k] ------------------ 366| 11.6k| return LOG2_MIN_INF; ------------------ | | 400| 11.6k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 11.6k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 11.6k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 11.6k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 11.6k] | | | | ------------------ | | ------------------ ------------------ 367| 20.7k| Q -= 12; 368| | 369| 20.7k| if (ch != 0) // L/R anti-symmetry ------------------ | Branch (369:13): [True: 10.4k, False: 10.2k] ------------------ 370| 10.4k| Q = -Q; 371| | 372| 20.7k| if (Q >= 0) ------------------ | Branch (372:13): [True: 10.5k, False: 10.1k] ------------------ 373| 10.5k| { 374| | /* negative */ 375| 10.5k| pan = pan_log2_tab[Q]; 376| 10.5k| } else { 377| | /* positive */ 378| 10.1k| pan = pan_log2_tab[-Q] + ((-Q)<Q[ch][k][l]; 386| 49.7k| if (q < 0 || q > 30) ------------------ | Branch (386:13): [True: 2.17k, False: 47.5k] | Branch (386:22): [True: 3.84k, False: 43.7k] ------------------ 387| 6.01k| return LOG2_MIN_INF; ------------------ | | 400| 6.01k|#define LOG2_MIN_INF REAL_CONST(-10000) | | ------------------ | | | | 59| 6.01k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | | | ------------------ | | | | | | 46| 6.01k|#define REAL_PRECISION (1 << REAL_BITS) | | | | | | ------------------ | | | | | | | | 45| 6.01k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:24): [Folded, False: 6.01k] | | | | ------------------ | | ------------------ ------------------ 388| 43.7k| return (6 - q) * REAL_PRECISION; ------------------ | | 46| 43.7k|#define REAL_PRECISION (1 << REAL_BITS) | | ------------------ | | | | 45| 43.7k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 389| 49.7k| } 390| 82.0k|} sbr_hfadj.c:find_log2_Qplus1: 441| 82.0k|{ 442| | /* check for coupled energy/noise data */ 443| 82.0k| if (sbr->bs_coupling == 1) ------------------ | Branch (443:9): [True: 32.3k, False: 49.7k] ------------------ 444| 32.3k| { 445| 32.3k| if ((sbr->Q[0][k][l] >= 0) && (sbr->Q[0][k][l] <= 30) && ------------------ | Branch (445:13): [True: 27.5k, False: 4.79k] | Branch (445:39): [True: 26.8k, False: 738] ------------------ 446| 26.8k| (sbr->Q[1][k][l] >= 0) && (sbr->Q[1][k][l] <= 24)) ------------------ | Branch (446:13): [True: 24.0k, False: 2.80k] | Branch (446:39): [True: 20.7k, False: 3.31k] ------------------ 447| 20.7k| { 448| 20.7k| if (ch == 0) ------------------ | Branch (448:17): [True: 10.2k, False: 10.4k] ------------------ 449| 10.2k| { 450| 10.2k| return log_Qplus1_pan[sbr->Q[0][k][l]][sbr->Q[1][k][l] >> 1]; 451| 10.4k| } else { 452| 10.4k| return log_Qplus1_pan[sbr->Q[0][k][l]][12 - (sbr->Q[1][k][l] >> 1)]; 453| 10.4k| } 454| 20.7k| } else { 455| 11.6k| return 0; 456| 11.6k| } 457| 49.7k| } else { 458| 49.7k| if (sbr->Q[ch][k][l] >= 0 && sbr->Q[ch][k][l] <= 30) ------------------ | Branch (458:13): [True: 47.5k, False: 2.17k] | Branch (458:38): [True: 43.7k, False: 3.84k] ------------------ 459| 43.7k| { 460| 43.7k| return log_Qplus1[sbr->Q[ch][k][l]]; 461| 43.7k| } else { 462| 6.01k| return 0; 463| 6.01k| } 464| 49.7k| } 465| 82.0k|} sbr_hfadj.c:hf_assembly: 1571| 3.62k|{ 1572| 3.62k| static real_t h_smooth[] = { 1573| 3.62k| FRAC_CONST(0.03183050093751), FRAC_CONST(0.11516383427084), ------------------ | | 61| 3.62k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 3.62k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 3.62k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 3.62k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ FRAC_CONST(0.03183050093751), FRAC_CONST(0.11516383427084), ------------------ | | 61| 3.62k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 3.62k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 3.62k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 3.62k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 1574| 3.62k| FRAC_CONST(0.21816949906249), FRAC_CONST(0.30150283239582), ------------------ | | 61| 3.62k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 3.62k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 3.62k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 3.62k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ FRAC_CONST(0.21816949906249), FRAC_CONST(0.30150283239582), ------------------ | | 61| 3.62k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 3.62k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 3.62k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 3.62k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 1575| 3.62k| FRAC_CONST(0.33333333333333) ------------------ | | 61| 3.62k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 3.62k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 3.62k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 3.62k] | | | Branch (61:62): [True: 0, Folded] | | ------------------ ------------------ 1576| 3.62k| }; 1577| 3.62k| static int8_t phi_re[] = { 1, 0, -1, 0 }; 1578| 3.62k| static int8_t phi_im[] = { 0, 1, 0, -1 }; 1579| | 1580| 3.62k| uint8_t m, l, i, n; 1581| 3.62k| uint16_t fIndexNoise = 0; 1582| 3.62k| uint8_t fIndexSine = 0; 1583| 3.62k| uint8_t assembly_reset = 0; 1584| | 1585| 3.62k| real_t G_filt, Q_filt; 1586| | 1587| 3.62k| uint8_t h_SL; 1588| | 1589| | 1590| 3.62k| if (sbr->Reset == 1) ------------------ | Branch (1590:9): [True: 3.54k, False: 79] ------------------ 1591| 3.54k| { 1592| 3.54k| assembly_reset = 1; 1593| 3.54k| fIndexNoise = 0; 1594| 3.54k| } else { 1595| 79| fIndexNoise = sbr->index_noise_prev[ch]; 1596| 79| } 1597| 3.62k| fIndexSine = sbr->psi_is_prev[ch]; 1598| | 1599| | 1600| 10.3k| for (l = 0; l < sbr->L_E[ch]; l++) ------------------ | Branch (1600:17): [True: 6.71k, False: 3.62k] ------------------ 1601| 6.71k| { 1602| 6.71k| uint8_t no_noise = (l == sbr->l_A[ch] || l == sbr->prevEnvIsShort[ch]) ? 1 : 0; ------------------ | Branch (1602:29): [True: 333, False: 6.38k] | Branch (1602:50): [True: 252, False: 6.12k] ------------------ 1603| | 1604| |#ifdef SBR_LOW_POWER 1605| | h_SL = 0; 1606| |#else 1607| 6.71k| h_SL = (sbr->bs_smoothing_mode == 1) ? 0 : 4; ------------------ | Branch (1607:16): [True: 5.79k, False: 917] ------------------ 1608| 6.71k| h_SL = (no_noise ? 0 : h_SL); ------------------ | Branch (1608:17): [True: 585, False: 6.12k] ------------------ 1609| 6.71k|#endif 1610| | 1611| 6.71k| if (assembly_reset) ------------------ | Branch (1611:13): [True: 3.54k, False: 3.16k] ------------------ 1612| 3.54k| { 1613| 17.7k| for (n = 0; n < 4; n++) ------------------ | Branch (1613:25): [True: 14.1k, False: 3.54k] ------------------ 1614| 14.1k| { 1615| 14.1k| memcpy(sbr->G_temp_prev[ch][n], adj->G_lim_boost[l], sbr->M*sizeof(real_t)); 1616| 14.1k| memcpy(sbr->Q_temp_prev[ch][n], adj->Q_M_lim_boost[l], sbr->M*sizeof(real_t)); 1617| 14.1k| } 1618| | /* reset ringbuffer index */ 1619| 3.54k| sbr->GQ_ringbuf_index[ch] = 4; 1620| 3.54k| assembly_reset = 0; 1621| 3.54k| } 1622| | 1623| 123k| for (i = sbr->t_E[ch][l]; i < sbr->t_E[ch][l+1]; i++) ------------------ | Branch (1623:35): [True: 116k, False: 6.71k] ------------------ 1624| 116k| { 1625| |#ifdef SBR_LOW_POWER 1626| | uint8_t i_min1, i_plus1; 1627| | uint8_t sinusoids = 0; 1628| |#endif 1629| | 1630| | /* load new values into ringbuffer */ 1631| 116k| memcpy(sbr->G_temp_prev[ch][sbr->GQ_ringbuf_index[ch]], adj->G_lim_boost[l], sbr->M*sizeof(real_t)); 1632| 116k| memcpy(sbr->Q_temp_prev[ch][sbr->GQ_ringbuf_index[ch]], adj->Q_M_lim_boost[l], sbr->M*sizeof(real_t)); 1633| | 1634| 1.50M| for (m = 0; m < sbr->M; m++) ------------------ | Branch (1634:25): [True: 1.39M, False: 116k] ------------------ 1635| 1.39M| { 1636| 1.39M| qmf_t psi; ------------------ | | 167| 1.39M|#define qmf_t complex_t ------------------ 1637| | 1638| 1.39M| G_filt = 0; 1639| 1.39M| Q_filt = 0; 1640| | 1641| 1.39M|#ifndef SBR_LOW_POWER 1642| 1.39M| if (h_SL != 0) ------------------ | Branch (1642:21): [True: 290k, False: 1.09M] ------------------ 1643| 290k| { 1644| 290k| uint8_t ri = sbr->GQ_ringbuf_index[ch]; 1645| 1.74M| for (n = 0; n <= 4; n++) ------------------ | Branch (1645:33): [True: 1.45M, False: 290k] ------------------ 1646| 1.45M| { 1647| 1.45M| real_t curr_h_smooth = h_smooth[n]; 1648| 1.45M| ri++; 1649| 1.45M| if (ri >= 5) ------------------ | Branch (1649:29): [True: 290k, False: 1.16M] ------------------ 1650| 290k| ri -= 5; 1651| 1.45M| G_filt += MUL_F(sbr->G_temp_prev[ch][ri][m], curr_h_smooth); ------------------ | | 268| 1.45M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.45M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.45M|#define FRAC_BITS 31 | | ------------------ ------------------ 1652| 1.45M| Q_filt += MUL_F(sbr->Q_temp_prev[ch][ri][m], curr_h_smooth); ------------------ | | 268| 1.45M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.45M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.45M|#define FRAC_BITS 31 | | ------------------ ------------------ 1653| 1.45M| } 1654| 1.09M| } else { 1655| 1.09M|#endif 1656| 1.09M| G_filt = sbr->G_temp_prev[ch][sbr->GQ_ringbuf_index[ch]][m]; 1657| 1.09M| Q_filt = sbr->Q_temp_prev[ch][sbr->GQ_ringbuf_index[ch]][m]; 1658| 1.09M|#ifndef SBR_LOW_POWER 1659| 1.09M| } 1660| 1.39M|#endif 1661| 1.39M| if (adj->S_M_boost[l][m] != 0 || no_noise) ------------------ | Branch (1661:21): [True: 54.9k, False: 1.33M] | Branch (1661:50): [True: 77.2k, False: 1.25M] ------------------ 1662| 132k| Q_filt = 0; 1663| | 1664| | /* add noise to the output */ 1665| 1.39M| fIndexNoise = (fIndexNoise + 1) & 511; 1666| | 1667| | /* the smoothed gain values are applied to Xsbr */ 1668| | /* V is defined, not calculated */ 1669| | //QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) = MUL_Q2(G_filt, QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx])) 1670| | // + MUL_F(Q_filt, RE(V[fIndexNoise])); 1671| 1.39M| QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) = MUL_R(G_filt, QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx])) ------------------ | | 168| 1.39M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.39M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) = MUL_R(G_filt, QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx])) ------------------ | | 239| 1.39M| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.39M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.39M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 1672| 1.39M| + MUL_F(Q_filt, RE(V[fIndexNoise])); ------------------ | | 268| 1.39M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.39M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.39M|#define FRAC_BITS 31 | | ------------------ ------------------ 1673| 1.39M| if (sbr->bs_extension_id == 3 && sbr->bs_extension_data == 42) ------------------ | Branch (1673:21): [True: 25.9k, False: 1.36M] | Branch (1673:50): [True: 3.60k, False: 22.3k] ------------------ 1674| 3.60k| QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) = 16428320; ------------------ | | 168| 3.60k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 3.60k|#define RE(A) (A)[0] | | ------------------ ------------------ 1675| 1.39M|#ifndef SBR_LOW_POWER 1676| | //QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) = MUL_Q2(G_filt, QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx])) 1677| | // + MUL_F(Q_filt, IM(V[fIndexNoise])); 1678| 1.39M| QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) = MUL_R(G_filt, QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx])) ------------------ | | 169| 1.39M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.39M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) = MUL_R(G_filt, QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx])) ------------------ | | 239| 1.39M| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.39M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.39M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 1679| 1.39M| + MUL_F(Q_filt, IM(V[fIndexNoise])); ------------------ | | 268| 1.39M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.39M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.39M|#define FRAC_BITS 31 | | ------------------ ------------------ 1680| 1.39M|#endif 1681| | 1682| 1.39M| { 1683| 1.39M| int8_t rev = (((m + sbr->kx) & 1) ? -1 : 1); ------------------ | Branch (1683:35): [True: 687k, False: 702k] ------------------ 1684| 1.39M| QMF_RE(psi) = adj->S_M_boost[l][m] * phi_re[fIndexSine]; ------------------ | | 168| 1.39M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.39M|#define RE(A) (A)[0] | | ------------------ ------------------ 1685| 1.39M| QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) += QMF_RE(psi); ------------------ | | 168| 1.39M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.39M|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) += QMF_RE(psi); ------------------ | | 168| 1.39M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.39M|#define RE(A) (A)[0] | | ------------------ ------------------ 1686| | 1687| 1.39M|#ifndef SBR_LOW_POWER 1688| 1.39M| QMF_IM(psi) = rev * adj->S_M_boost[l][m] * phi_im[fIndexSine]; ------------------ | | 169| 1.39M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.39M|#define IM(A) (A)[1] | | ------------------ ------------------ 1689| 1.39M| QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) += QMF_IM(psi); ------------------ | | 169| 1.39M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.39M|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) += QMF_IM(psi); ------------------ | | 169| 1.39M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.39M|#define IM(A) (A)[1] | | ------------------ ------------------ 1690| |#else 1691| | 1692| | i_min1 = (fIndexSine - 1) & 3; 1693| | i_plus1 = (fIndexSine + 1) & 3; 1694| | 1695| | if ((m == 0) && (phi_re[i_plus1] != 0)) 1696| | { 1697| | QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx - 1]) += 1698| | (rev*phi_re[i_plus1] * MUL_F(adj->S_M_boost[l][0], FRAC_CONST(0.00815))); 1699| | if (sbr->M != 0) 1700| | { 1701| | QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) -= 1702| | (rev*phi_re[i_plus1] * MUL_F(adj->S_M_boost[l][1], FRAC_CONST(0.00815))); 1703| | } 1704| | } 1705| | if ((m > 0) && (m < sbr->M - 1) && (sinusoids < 16) && (phi_re[i_min1] != 0)) 1706| | { 1707| | QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) -= 1708| | (rev*phi_re[i_min1] * MUL_F(adj->S_M_boost[l][m - 1], FRAC_CONST(0.00815))); 1709| | } 1710| | if ((m > 0) && (m < sbr->M - 1) && (sinusoids < 16) && (phi_re[i_plus1] != 0)) 1711| | { 1712| | QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) -= 1713| | (rev*phi_re[i_plus1] * MUL_F(adj->S_M_boost[l][m + 1], FRAC_CONST(0.00815))); 1714| | } 1715| | if ((m == sbr->M - 1) && (sinusoids < 16) && (phi_re[i_min1] != 0)) 1716| | { 1717| | if (m > 0) 1718| | { 1719| | QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx]) -= 1720| | (rev*phi_re[i_min1] * MUL_F(adj->S_M_boost[l][m - 1], FRAC_CONST(0.00815))); 1721| | } 1722| | if (m + sbr->kx + 1 < 64) 1723| | { 1724| | QMF_RE(Xsbr[i + sbr->tHFAdj][m+sbr->kx + 1]) += 1725| | (rev*phi_re[i_min1] * MUL_F(adj->S_M_boost[l][m], FRAC_CONST(0.00815))); 1726| | } 1727| | } 1728| | 1729| | if (adj->S_M_boost[l][m] != 0) 1730| | sinusoids++; 1731| |#endif 1732| 1.39M| } 1733| 1.39M| } 1734| | 1735| 116k| fIndexSine = (fIndexSine + 1) & 3; 1736| | 1737| | /* update the ringbuffer index used for filtering G and Q with h_smooth */ 1738| 116k| sbr->GQ_ringbuf_index[ch]++; 1739| 116k| if (sbr->GQ_ringbuf_index[ch] >= 5) ------------------ | Branch (1739:17): [True: 25.0k, False: 91.7k] ------------------ 1740| 25.0k| sbr->GQ_ringbuf_index[ch] = 0; 1741| 116k| } 1742| 6.71k| } 1743| | 1744| 3.62k| sbr->index_noise_prev[ch] = fIndexNoise; 1745| 3.62k| sbr->psi_is_prev[ch] = fIndexSine; 1746| 3.62k|} hf_generation: 61| 3.96k|{ 62| 3.96k| uint8_t l, i, x; 63| 3.96k| ALIGN complex_t alpha_0[64], alpha_1[64]; 64| |#ifdef SBR_LOW_POWER 65| | ALIGN real_t rxx[64]; 66| |#endif 67| | 68| 3.96k| uint8_t offset = sbr->tHFAdj; 69| 3.96k| uint8_t first = sbr->t_E[ch][0]; 70| 3.96k| uint8_t last = sbr->t_E[ch][sbr->L_E[ch]]; 71| | 72| 3.96k| calc_chirp_factors(sbr, ch); 73| | 74| |#ifdef SBR_LOW_POWER 75| | memset(deg, 0, 64*sizeof(real_t)); 76| |#endif 77| | 78| 3.96k| if ((ch == 0) && (sbr->Reset)) ------------------ | Branch (78:9): [True: 3.12k, False: 835] | Branch (78:22): [True: 3.05k, False: 72] ------------------ 79| 3.05k| patch_construction(sbr); 80| | 81| | /* calculate the prediction coefficients */ 82| |#ifdef SBR_LOW_POWER 83| | calc_prediction_coef_lp(sbr, Xlow, alpha_0, alpha_1, rxx); 84| | calc_aliasing_degree(sbr, rxx, deg); 85| |#endif 86| | 87| | /* actual HF generation */ 88| 12.2k| for (i = 0; i < sbr->noPatches; i++) ------------------ | Branch (88:17): [True: 8.32k, False: 3.96k] ------------------ 89| 8.32k| { 90| 58.6k| for (x = 0; x < sbr->patchNoSubbands[i]; x++) ------------------ | Branch (90:21): [True: 50.3k, False: 8.32k] ------------------ 91| 50.3k| { 92| 50.3k| real_t a0_r, a0_i, a1_r, a1_i; 93| 50.3k| real_t bw, bw2; 94| 50.3k| uint8_t q, p, k, g; 95| | 96| | /* find the low and high band for patching */ 97| 50.3k| k = sbr->kx + x; 98| 96.9k| for (q = 0; q < i; q++) ------------------ | Branch (98:25): [True: 46.6k, False: 50.3k] ------------------ 99| 46.6k| { 100| 46.6k| k += sbr->patchNoSubbands[q]; 101| 46.6k| } 102| 50.3k| p = sbr->patchStartSubband[i] + x; 103| | 104| |#ifdef SBR_LOW_POWER 105| | if (x != 0 /*x < sbr->patchNoSubbands[i]-1*/) 106| | deg[k] = deg[p]; 107| | else 108| | deg[k] = 0; 109| |#endif 110| | 111| 50.3k| g = sbr->table_map_k_to_g[k]; 112| | 113| 50.3k| bw = sbr->bwArray[ch][g]; 114| 50.3k| bw2 = MUL_C(bw, bw); ------------------ | | 241| 50.3k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 50.3k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 50.3k|#define COEF_BITS 28 | | ------------------ ------------------ 115| | 116| | /* do the patching */ 117| | /* with or without filtering */ 118| 50.3k| if (bw2 > 0) ------------------ | Branch (118:17): [True: 26.3k, False: 24.0k] ------------------ 119| 26.3k| { 120| 26.3k| real_t temp1_r, temp2_r, temp3_r; 121| 26.3k|#ifndef SBR_LOW_POWER 122| 26.3k| real_t temp1_i, temp2_i, temp3_i; 123| 26.3k| calc_prediction_coef(sbr, Xlow, alpha_0, alpha_1, p); 124| 26.3k|#endif 125| | 126| 26.3k| a0_r = MUL_C(RE(alpha_0[p]), bw); ------------------ | | 241| 26.3k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ ------------------ 127| 26.3k| a1_r = MUL_C(RE(alpha_1[p]), bw2); ------------------ | | 241| 26.3k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ ------------------ 128| 26.3k|#ifndef SBR_LOW_POWER 129| 26.3k| a0_i = MUL_C(IM(alpha_0[p]), bw); ------------------ | | 241| 26.3k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ ------------------ 130| 26.3k| a1_i = MUL_C(IM(alpha_1[p]), bw2); ------------------ | | 241| 26.3k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 26.3k|#define COEF_BITS 28 | | ------------------ ------------------ 131| 26.3k|#endif 132| | 133| 26.3k| temp2_r = QMF_RE(Xlow[first - 2 + offset][p]); ------------------ | | 168| 26.3k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 26.3k|#define RE(A) (A)[0] | | ------------------ ------------------ 134| 26.3k| temp3_r = QMF_RE(Xlow[first - 1 + offset][p]); ------------------ | | 168| 26.3k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 26.3k|#define RE(A) (A)[0] | | ------------------ ------------------ 135| 26.3k|#ifndef SBR_LOW_POWER 136| 26.3k| temp2_i = QMF_IM(Xlow[first - 2 + offset][p]); ------------------ | | 169| 26.3k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 26.3k|#define IM(A) (A)[1] | | ------------------ ------------------ 137| 26.3k| temp3_i = QMF_IM(Xlow[first - 1 + offset][p]); ------------------ | | 169| 26.3k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 26.3k|#define IM(A) (A)[1] | | ------------------ ------------------ 138| 26.3k|#endif 139| 857k| for (l = first; l < last; l++) ------------------ | Branch (139:21): [True: 831k, False: 26.3k] ------------------ 140| 831k| { 141| 831k| temp1_r = temp2_r; 142| 831k| temp2_r = temp3_r; 143| 831k| temp3_r = QMF_RE(Xlow[l + offset][p]); ------------------ | | 168| 831k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 831k|#define RE(A) (A)[0] | | ------------------ ------------------ 144| 831k|#ifndef SBR_LOW_POWER 145| 831k| temp1_i = temp2_i; 146| 831k| temp2_i = temp3_i; 147| 831k| temp3_i = QMF_IM(Xlow[l + offset][p]); ------------------ | | 169| 831k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 831k|#define IM(A) (A)[1] | | ------------------ ------------------ 148| 831k|#endif 149| | 150| |#ifdef SBR_LOW_POWER 151| | QMF_RE(Xhigh[l + offset][k]) = 152| | temp3_r 153| | +(MUL_R(a0_r, temp2_r) + 154| | MUL_R(a1_r, temp1_r)); 155| |#else 156| 831k| QMF_RE(Xhigh[l + offset][k]) = ------------------ | | 168| 831k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 831k|#define RE(A) (A)[0] | | ------------------ ------------------ 157| 831k| temp3_r 158| 831k| +(MUL_R(a0_r, temp2_r) - ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 159| 831k| MUL_R(a0_i, temp2_i) + ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 160| 831k| MUL_R(a1_r, temp1_r) - ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 161| 831k| MUL_R(a1_i, temp1_i)); ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 162| 831k| QMF_IM(Xhigh[l + offset][k]) = ------------------ | | 169| 831k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 831k|#define IM(A) (A)[1] | | ------------------ ------------------ 163| 831k| temp3_i 164| 831k| +(MUL_R(a0_i, temp2_r) + ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 165| 831k| MUL_R(a0_r, temp2_i) + ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 166| 831k| MUL_R(a1_i, temp1_r) + ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 167| 831k| MUL_R(a1_r, temp1_i)); ------------------ | | 239| 831k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 831k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 168| 831k|#endif 169| 831k| } 170| 26.3k| } else { 171| 789k| for (l = first; l < last; l++) ------------------ | Branch (171:33): [True: 765k, False: 24.0k] ------------------ 172| 765k| { 173| 765k| QMF_RE(Xhigh[l + offset][k]) = QMF_RE(Xlow[l + offset][p]); ------------------ | | 168| 765k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 765k|#define RE(A) (A)[0] | | ------------------ ------------------ QMF_RE(Xhigh[l + offset][k]) = QMF_RE(Xlow[l + offset][p]); ------------------ | | 168| 765k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 765k|#define RE(A) (A)[0] | | ------------------ ------------------ 174| 765k|#ifndef SBR_LOW_POWER 175| 765k| QMF_IM(Xhigh[l + offset][k]) = QMF_IM(Xlow[l + offset][p]); ------------------ | | 169| 765k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 765k|#define IM(A) (A)[1] | | ------------------ ------------------ QMF_IM(Xhigh[l + offset][k]) = QMF_IM(Xlow[l + offset][p]); ------------------ | | 169| 765k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 765k|#define IM(A) (A)[1] | | ------------------ ------------------ 176| 765k|#endif 177| 765k| } 178| 24.0k| } 179| 50.3k| } 180| 8.32k| } 181| | 182| 3.96k| if (sbr->Reset) ------------------ | Branch (182:9): [True: 3.88k, False: 79] ------------------ 183| 3.88k| { 184| 3.88k| limiter_frequency_table(sbr); 185| 3.88k| } 186| 3.96k|} sbr_hfgen.c:calc_prediction_coef: 431| 26.3k|{ 432| 26.3k| real_t tmp; 433| 26.3k| acorr_coef ac; 434| | 435| 26.3k| auto_correlation(sbr, &ac, Xlow, k, sbr->numTimeSlotsRate + 6); 436| | 437| 26.3k| if (ac.det == 0) ------------------ | Branch (437:9): [True: 25.0k, False: 1.23k] ------------------ 438| 25.0k| { 439| 25.0k| RE(alpha_1[k]) = 0; ------------------ | | 391| 25.0k|#define RE(A) (A)[0] ------------------ 440| 25.0k| IM(alpha_1[k]) = 0; ------------------ | | 392| 25.0k|#define IM(A) (A)[1] ------------------ 441| 25.0k| } else { 442| 1.23k|#ifdef FIXED_POINT 443| 1.23k| tmp = (MUL_R(RE(ac.r01), RE(ac.r12)) - MUL_R(IM(ac.r01), IM(ac.r12)) - MUL_R(RE(ac.r02), RE(ac.r11))); ------------------ | | 239| 1.23k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ tmp = (MUL_R(RE(ac.r01), RE(ac.r12)) - MUL_R(IM(ac.r01), IM(ac.r12)) - MUL_R(RE(ac.r02), RE(ac.r11))); ------------------ | | 239| 1.23k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ tmp = (MUL_R(RE(ac.r01), RE(ac.r12)) - MUL_R(IM(ac.r01), IM(ac.r12)) - MUL_R(RE(ac.r02), RE(ac.r11))); ------------------ | | 239| 1.23k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 444| 1.23k| RE(alpha_1[k]) = DIV_R(tmp, ac.det); ------------------ | | 391| 1.23k|#define RE(A) (A)[0] ------------------ RE(alpha_1[k]) = DIV_R(tmp, ac.det); ------------------ | | 157| 1.23k|#define DIV_R(A, B) (((int64_t)A * REAL_PRECISION)/B) | | ------------------ | | | | 46| 1.23k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ ------------------ 445| 1.23k| tmp = (MUL_R(IM(ac.r01), RE(ac.r12)) + MUL_R(RE(ac.r01), IM(ac.r12)) - MUL_R(IM(ac.r02), RE(ac.r11))); ------------------ | | 239| 1.23k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ tmp = (MUL_R(IM(ac.r01), RE(ac.r12)) + MUL_R(RE(ac.r01), IM(ac.r12)) - MUL_R(IM(ac.r02), RE(ac.r11))); ------------------ | | 239| 1.23k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ tmp = (MUL_R(IM(ac.r01), RE(ac.r12)) + MUL_R(RE(ac.r01), IM(ac.r12)) - MUL_R(IM(ac.r02), RE(ac.r11))); ------------------ | | 239| 1.23k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 446| 1.23k| IM(alpha_1[k]) = DIV_R(tmp, ac.det); ------------------ | | 392| 1.23k|#define IM(A) (A)[1] ------------------ IM(alpha_1[k]) = DIV_R(tmp, ac.det); ------------------ | | 157| 1.23k|#define DIV_R(A, B) (((int64_t)A * REAL_PRECISION)/B) | | ------------------ | | | | 46| 1.23k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 1.23k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ ------------------ 447| |#else 448| | tmp = REAL_CONST(1.0) / ac.det; 449| | RE(alpha_1[k]) = (MUL_R(RE(ac.r01), RE(ac.r12)) - MUL_R(IM(ac.r01), IM(ac.r12)) - MUL_R(RE(ac.r02), RE(ac.r11))) * tmp; 450| | IM(alpha_1[k]) = (MUL_R(IM(ac.r01), RE(ac.r12)) + MUL_R(RE(ac.r01), IM(ac.r12)) - MUL_R(IM(ac.r02), RE(ac.r11))) * tmp; 451| |#endif 452| 1.23k| } 453| | 454| 26.3k| if (RE(ac.r11) == 0) ------------------ | | 391| 26.3k|#define RE(A) (A)[0] ------------------ | Branch (454:9): [True: 24.9k, False: 1.33k] ------------------ 455| 24.9k| { 456| 24.9k| RE(alpha_0[k]) = 0; ------------------ | | 391| 24.9k|#define RE(A) (A)[0] ------------------ 457| 24.9k| IM(alpha_0[k]) = 0; ------------------ | | 392| 24.9k|#define IM(A) (A)[1] ------------------ 458| 24.9k| } else { 459| 1.33k|#ifdef FIXED_POINT 460| 1.33k| tmp = -(RE(ac.r01) + MUL_R(RE(alpha_1[k]), RE(ac.r12)) + MUL_R(IM(alpha_1[k]), IM(ac.r12))); ------------------ | | 391| 1.33k|#define RE(A) (A)[0] ------------------ tmp = -(RE(ac.r01) + MUL_R(RE(alpha_1[k]), RE(ac.r12)) + MUL_R(IM(alpha_1[k]), IM(ac.r12))); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ tmp = -(RE(ac.r01) + MUL_R(RE(alpha_1[k]), RE(ac.r12)) + MUL_R(IM(alpha_1[k]), IM(ac.r12))); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 461| 1.33k| RE(alpha_0[k]) = DIV_R(tmp, RE(ac.r11)); ------------------ | | 391| 1.33k|#define RE(A) (A)[0] ------------------ RE(alpha_0[k]) = DIV_R(tmp, RE(ac.r11)); ------------------ | | 157| 1.33k|#define DIV_R(A, B) (((int64_t)A * REAL_PRECISION)/B) | | ------------------ | | | | 46| 1.33k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ ------------------ 462| 1.33k| tmp = -(IM(ac.r01) + MUL_R(IM(alpha_1[k]), RE(ac.r12)) - MUL_R(RE(alpha_1[k]), IM(ac.r12))); ------------------ | | 392| 1.33k|#define IM(A) (A)[1] ------------------ tmp = -(IM(ac.r01) + MUL_R(IM(alpha_1[k]), RE(ac.r12)) - MUL_R(RE(alpha_1[k]), IM(ac.r12))); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ tmp = -(IM(ac.r01) + MUL_R(IM(alpha_1[k]), RE(ac.r12)) - MUL_R(RE(alpha_1[k]), IM(ac.r12))); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 463| 1.33k| IM(alpha_0[k]) = DIV_R(tmp, RE(ac.r11)); ------------------ | | 392| 1.33k|#define IM(A) (A)[1] ------------------ IM(alpha_0[k]) = DIV_R(tmp, RE(ac.r11)); ------------------ | | 157| 1.33k|#define DIV_R(A, B) (((int64_t)A * REAL_PRECISION)/B) | | ------------------ | | | | 46| 1.33k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ ------------------ 464| |#else 465| | tmp = 1.0f / RE(ac.r11); 466| | RE(alpha_0[k]) = -(RE(ac.r01) + MUL_R(RE(alpha_1[k]), RE(ac.r12)) + MUL_R(IM(alpha_1[k]), IM(ac.r12))) * tmp; 467| | IM(alpha_0[k]) = -(IM(ac.r01) + MUL_R(IM(alpha_1[k]), RE(ac.r12)) - MUL_R(RE(alpha_1[k]), IM(ac.r12))) * tmp; 468| |#endif 469| 1.33k| } 470| | 471| | /* Sanity check; important: use "yes" check to filter-out NaN values. */ 472| 26.3k| if ((MUL_R(RE(alpha_0[k]),RE(alpha_0[k])) + MUL_R(IM(alpha_0[k]),IM(alpha_0[k])) <= REAL_CONST(16)) && ------------------ | | 239| 26.3k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ if ((MUL_R(RE(alpha_0[k]),RE(alpha_0[k])) + MUL_R(IM(alpha_0[k]),IM(alpha_0[k])) <= REAL_CONST(16)) && ------------------ | | 239| 26.3k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ if ((MUL_R(RE(alpha_0[k]),RE(alpha_0[k])) + MUL_R(IM(alpha_0[k]),IM(alpha_0[k])) <= REAL_CONST(16)) && ------------------ | | 59| 26.3k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 26.3k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 26.3k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 26.3k, Folded] | | ------------------ ------------------ | Branch (472:9): [True: 26.0k, False: 268] ------------------ 473| 26.0k| (MUL_R(RE(alpha_1[k]),RE(alpha_1[k])) + MUL_R(IM(alpha_1[k]),IM(alpha_1[k])) <= REAL_CONST(16))) ------------------ | | 239| 26.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(RE(alpha_1[k]),RE(alpha_1[k])) + MUL_R(IM(alpha_1[k]),IM(alpha_1[k])) <= REAL_CONST(16))) ------------------ | | 239| 26.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 26.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(RE(alpha_1[k]),RE(alpha_1[k])) + MUL_R(IM(alpha_1[k]),IM(alpha_1[k])) <= REAL_CONST(16))) ------------------ | | 59| 26.0k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 26.0k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 26.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 26.0k, Folded] | | ------------------ ------------------ | Branch (473:9): [True: 25.8k, False: 144] ------------------ 474| 25.8k| return; 475| | /* Fallback */ 476| 412| RE(alpha_0[k]) = 0; ------------------ | | 391| 412|#define RE(A) (A)[0] ------------------ 477| 412| IM(alpha_0[k]) = 0; ------------------ | | 392| 412|#define IM(A) (A)[1] ------------------ 478| 412| RE(alpha_1[k]) = 0; ------------------ | | 391| 412|#define RE(A) (A)[0] ------------------ 479| 412| IM(alpha_1[k]) = 0; ------------------ | | 392| 412|#define IM(A) (A)[1] ------------------ 480| 412|} sbr_hfgen.c:auto_correlation: 271| 26.3k|{ 272| 26.3k| real_t r01r = 0, r01i = 0, r02r = 0, r02i = 0, r11r = 0; 273| 26.3k| real_t temp1_r, temp1_i, temp2_r, temp2_i, temp3_r, temp3_i, temp4_r, temp4_i, temp5_r, temp5_i; 274| 26.3k|#ifdef FIXED_POINT 275| 26.3k| const real_t rel = FRAC_CONST(0.999999); // 1 / (1 + 1e-6f); ------------------ | | 61| 26.3k|#define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 54| 0|#define FRAC_MAX 0x7FFFFFFF | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 26.3k|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 26.3k|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))) | | ------------------ | | | | 53| 0|#define FRAC_PRECISION ((uint32_t)(1u << FRAC_BITS)) | | | | ------------------ | | | | | | 50| 0|#define FRAC_BITS 31 | | | | ------------------ | | ------------------ | | | Branch (61:24): [Folded, False: 26.3k] | | | Branch (61:62): [True: 26.3k, Folded] | | ------------------ ------------------ 276| 26.3k| uint32_t mask, exp; 277| 26.3k| real_t half; 278| |#else 279| | const real_t rel = 1 / (1 + 1e-6f); 280| |#endif 281| 26.3k| int8_t j; 282| 26.3k| uint8_t offset = sbr->tHFAdj; 283| | 284| 26.3k|#ifdef FIXED_POINT 285| 26.3k| mask = 0; 286| | 287| 1.07M| for (j = (offset-2); j < (len + offset); j++) ------------------ | Branch (287:26): [True: 1.04M, False: 26.3k] ------------------ 288| 1.04M| { 289| 1.04M| real_t x; 290| 1.04M| x = QMF_RE(buffer[j][bd])>>REAL_BITS; ------------------ | | 168| 1.04M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.04M|#define RE(A) (A)[0] | | ------------------ ------------------ x = QMF_RE(buffer[j][bd])>>REAL_BITS; ------------------ | | 45| 1.04M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 291| 1.04M| mask |= x ^ (x >> 31); 292| 1.04M| x = QMF_IM(buffer[j][bd])>>REAL_BITS; ------------------ | | 169| 1.04M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.04M|#define IM(A) (A)[1] | | ------------------ ------------------ x = QMF_IM(buffer[j][bd])>>REAL_BITS; ------------------ | | 45| 1.04M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR ------------------ 293| 1.04M| mask |= x ^ (x >> 31); 294| 1.04M| } 295| | 296| 26.3k| exp = wl_min_lzc(mask); 297| | 298| | /* All-zero input. */ 299| 26.3k| if (exp == 0) { ------------------ | Branch (299:9): [True: 24.9k, False: 1.33k] ------------------ 300| 24.9k| RE(ac->r01) = 0; ------------------ | | 391| 24.9k|#define RE(A) (A)[0] ------------------ 301| 24.9k| IM(ac->r01) = 0; ------------------ | | 392| 24.9k|#define IM(A) (A)[1] ------------------ 302| 24.9k| RE(ac->r02) = 0; ------------------ | | 391| 24.9k|#define RE(A) (A)[0] ------------------ 303| 24.9k| IM(ac->r02) = 0; ------------------ | | 392| 24.9k|#define IM(A) (A)[1] ------------------ 304| 24.9k| RE(ac->r11) = 0; ------------------ | | 391| 24.9k|#define RE(A) (A)[0] ------------------ 305| | // IM(ac->r11) = 0; // unused 306| 24.9k| RE(ac->r12) = 0; ------------------ | | 391| 24.9k|#define RE(A) (A)[0] ------------------ 307| 24.9k| IM(ac->r12) = 0; ------------------ | | 392| 24.9k|#define IM(A) (A)[1] ------------------ 308| 24.9k| RE(ac->r22) = 0; ------------------ | | 391| 24.9k|#define RE(A) (A)[0] ------------------ 309| | // IM(ac->r22) = 0; // unused 310| 24.9k| ac->det = 0; 311| 24.9k| return; 312| 24.9k| } 313| | /* Otherwise exp > 0. */ 314| | /* improves accuracy */ 315| 1.33k| exp -= 1; 316| | /* Now exp is 0..31 */ 317| 1.33k| half = (1 << exp) >> 1; 318| | 319| 1.33k| temp2_r = (QMF_RE(buffer[offset-2][bd]) + half) >> exp; ------------------ | | 168| 1.33k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.33k|#define RE(A) (A)[0] | | ------------------ ------------------ 320| 1.33k| temp2_i = (QMF_IM(buffer[offset-2][bd]) + half) >> exp; ------------------ | | 169| 1.33k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.33k|#define IM(A) (A)[1] | | ------------------ ------------------ 321| 1.33k| temp3_r = (QMF_RE(buffer[offset-1][bd]) + half) >> exp; ------------------ | | 168| 1.33k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.33k|#define RE(A) (A)[0] | | ------------------ ------------------ 322| 1.33k| temp3_i = (QMF_IM(buffer[offset-1][bd]) + half) >> exp; ------------------ | | 169| 1.33k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.33k|#define IM(A) (A)[1] | | ------------------ ------------------ 323| | // Save these because they are needed after loop 324| 1.33k| temp4_r = temp2_r; 325| 1.33k| temp4_i = temp2_i; 326| 1.33k| temp5_r = temp3_r; 327| 1.33k| temp5_i = temp3_i; 328| | 329| 49.3k| for (j = offset; j < len + offset; j++) ------------------ | Branch (329:22): [True: 48.0k, False: 1.33k] ------------------ 330| 48.0k| { 331| 48.0k| temp1_r = temp2_r; // temp1_r = (QMF_RE(buffer[offset-2][bd] + (1<<(exp-1))) >> exp; 332| 48.0k| temp1_i = temp2_i; // temp1_i = (QMF_IM(buffer[offset-2][bd] + (1<<(exp-1))) >> exp; 333| 48.0k| temp2_r = temp3_r; // temp2_r = (QMF_RE(buffer[offset-1][bd] + (1<<(exp-1))) >> exp; 334| 48.0k| temp2_i = temp3_i; // temp2_i = (QMF_IM(buffer[offset-1][bd] + (1<<(exp-1))) >> exp; 335| 48.0k| temp3_r = (QMF_RE(buffer[j][bd]) + half) >> exp; ------------------ | | 168| 48.0k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 48.0k|#define RE(A) (A)[0] | | ------------------ ------------------ 336| 48.0k| temp3_i = (QMF_IM(buffer[j][bd]) + half) >> exp; ------------------ | | 169| 48.0k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 48.0k|#define IM(A) (A)[1] | | ------------------ ------------------ 337| 48.0k| r01r += MUL_R(temp3_r, temp2_r) + MUL_R(temp3_i, temp2_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ r01r += MUL_R(temp3_r, temp2_r) + MUL_R(temp3_i, temp2_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 338| 48.0k| r01i += MUL_R(temp3_i, temp2_r) - MUL_R(temp3_r, temp2_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ r01i += MUL_R(temp3_i, temp2_r) - MUL_R(temp3_r, temp2_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 339| 48.0k| r02r += MUL_R(temp3_r, temp1_r) + MUL_R(temp3_i, temp1_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ r02r += MUL_R(temp3_r, temp1_r) + MUL_R(temp3_i, temp1_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 340| 48.0k| r02i += MUL_R(temp3_i, temp1_r) - MUL_R(temp3_r, temp1_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ r02i += MUL_R(temp3_i, temp1_r) - MUL_R(temp3_r, temp1_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 341| 48.0k| r11r += MUL_R(temp2_r, temp2_r) + MUL_R(temp2_i, temp2_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ r11r += MUL_R(temp2_r, temp2_r) + MUL_R(temp2_i, temp2_i); ------------------ | | 239| 48.0k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 48.0k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 342| 48.0k| } 343| | 344| | // These are actual values in temporary variable at this point 345| | // temp1_r = (QMF_RE(buffer[len+offset-1-2][bd] + (1<<(exp-1))) >> exp; 346| | // temp1_i = (QMF_IM(buffer[len+offset-1-2][bd] + (1<<(exp-1))) >> exp; 347| | // temp2_r = (QMF_RE(buffer[len+offset-1-1][bd] + (1<<(exp-1))) >> exp; 348| | // temp2_i = (QMF_IM(buffer[len+offset-1-1][bd] + (1<<(exp-1))) >> exp; 349| | // temp3_r = (QMF_RE(buffer[len+offset-1][bd]) + (1<<(exp-1))) >> exp; 350| | // temp3_i = (QMF_IM(buffer[len+offset-1][bd]) + (1<<(exp-1))) >> exp; 351| | // temp4_r = (QMF_RE(buffer[offset-2][bd]) + (1<<(exp-1))) >> exp; 352| | // temp4_i = (QMF_IM(buffer[offset-2][bd]) + (1<<(exp-1))) >> exp; 353| | // temp5_r = (QMF_RE(buffer[offset-1][bd]) + (1<<(exp-1))) >> exp; 354| | // temp5_i = (QMF_IM(buffer[offset-1][bd]) + (1<<(exp-1))) >> exp; 355| | 356| 1.33k| RE(ac->r12) = r01r - ------------------ | | 391| 1.33k|#define RE(A) (A)[0] ------------------ 357| 1.33k| (MUL_R(temp3_r, temp2_r) + MUL_R(temp3_i, temp2_i)) + ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(temp3_r, temp2_r) + MUL_R(temp3_i, temp2_i)) + ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 358| 1.33k| (MUL_R(temp5_r, temp4_r) + MUL_R(temp5_i, temp4_i)); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(temp5_r, temp4_r) + MUL_R(temp5_i, temp4_i)); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 359| 1.33k| IM(ac->r12) = r01i - ------------------ | | 392| 1.33k|#define IM(A) (A)[1] ------------------ 360| 1.33k| (MUL_R(temp3_i, temp2_r) - MUL_R(temp3_r, temp2_i)) + ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(temp3_i, temp2_r) - MUL_R(temp3_r, temp2_i)) + ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 361| 1.33k| (MUL_R(temp5_i, temp4_r) - MUL_R(temp5_r, temp4_i)); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(temp5_i, temp4_r) - MUL_R(temp5_r, temp4_i)); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 362| 1.33k| RE(ac->r22) = r11r - ------------------ | | 391| 1.33k|#define RE(A) (A)[0] ------------------ 363| 1.33k| (MUL_R(temp2_r, temp2_r) + MUL_R(temp2_i, temp2_i)) + ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(temp2_r, temp2_r) + MUL_R(temp2_i, temp2_i)) + ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 364| 1.33k| (MUL_R(temp4_r, temp4_r) + MUL_R(temp4_i, temp4_i)); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ (MUL_R(temp4_r, temp4_r) + MUL_R(temp4_i, temp4_i)); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 365| | 366| |#else 367| | 368| | temp2_r = QMF_RE(buffer[offset-2][bd]); 369| | temp2_i = QMF_IM(buffer[offset-2][bd]); 370| | temp3_r = QMF_RE(buffer[offset-1][bd]); 371| | temp3_i = QMF_IM(buffer[offset-1][bd]); 372| | // Save these because they are needed after loop 373| | temp4_r = temp2_r; 374| | temp4_i = temp2_i; 375| | temp5_r = temp3_r; 376| | temp5_i = temp3_i; 377| | 378| | for (j = offset; j < len + offset; j++) 379| | { 380| | temp1_r = temp2_r; // temp1_r = QMF_RE(buffer[j-2][bd]; 381| | temp1_i = temp2_i; // temp1_i = QMF_IM(buffer[j-2][bd]; 382| | temp2_r = temp3_r; // temp2_r = QMF_RE(buffer[j-1][bd]; 383| | temp2_i = temp3_i; // temp2_i = QMF_IM(buffer[j-1][bd]; 384| | temp3_r = QMF_RE(buffer[j][bd]); 385| | temp3_i = QMF_IM(buffer[j][bd]); 386| | r01r += temp3_r * temp2_r + temp3_i * temp2_i; 387| | r01i += temp3_i * temp2_r - temp3_r * temp2_i; 388| | r02r += temp3_r * temp1_r + temp3_i * temp1_i; 389| | r02i += temp3_i * temp1_r - temp3_r * temp1_i; 390| | r11r += temp2_r * temp2_r + temp2_i * temp2_i; 391| | } 392| | 393| | // These are actual values in temporary variable at this point 394| | // temp1_r = QMF_RE(buffer[len+offset-1-2][bd]; 395| | // temp1_i = QMF_IM(buffer[len+offset-1-2][bd]; 396| | // temp2_r = QMF_RE(buffer[len+offset-1-1][bd]; 397| | // temp2_i = QMF_IM(buffer[len+offset-1-1][bd]; 398| | // temp3_r = QMF_RE(buffer[len+offset-1][bd]); 399| | // temp3_i = QMF_IM(buffer[len+offset-1][bd]); 400| | // temp4_r = QMF_RE(buffer[offset-2][bd]); 401| | // temp4_i = QMF_IM(buffer[offset-2][bd]); 402| | // temp5_r = QMF_RE(buffer[offset-1][bd]); 403| | // temp5_i = QMF_IM(buffer[offset-1][bd]); 404| | 405| | RE(ac->r12) = r01r - 406| | (temp3_r * temp2_r + temp3_i * temp2_i) + 407| | (temp5_r * temp4_r + temp5_i * temp4_i); 408| | IM(ac->r12) = r01i - 409| | (temp3_i * temp2_r - temp3_r * temp2_i) + 410| | (temp5_i * temp4_r - temp5_r * temp4_i); 411| | RE(ac->r22) = r11r - 412| | (temp2_r * temp2_r + temp2_i * temp2_i) + 413| | (temp4_r * temp4_r + temp4_i * temp4_i); 414| | 415| |#endif 416| | 417| 1.33k| RE(ac->r01) = r01r; ------------------ | | 391| 1.33k|#define RE(A) (A)[0] ------------------ 418| 1.33k| IM(ac->r01) = r01i; ------------------ | | 392| 1.33k|#define IM(A) (A)[1] ------------------ 419| 1.33k| RE(ac->r02) = r02r; ------------------ | | 391| 1.33k|#define RE(A) (A)[0] ------------------ 420| 1.33k| IM(ac->r02) = r02i; ------------------ | | 392| 1.33k|#define IM(A) (A)[1] ------------------ 421| 1.33k| RE(ac->r11) = r11r; ------------------ | | 391| 1.33k|#define RE(A) (A)[0] ------------------ 422| | 423| 1.33k| ac->det = MUL_R(RE(ac->r11), RE(ac->r22)) - MUL_F(rel, (MUL_R(RE(ac->r12), RE(ac->r12)) + MUL_R(IM(ac->r12), IM(ac->r12)))); ------------------ | | 239| 1.33k| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 1.33k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ ac->det = MUL_R(RE(ac->r11), RE(ac->r22)) - MUL_F(rel, (MUL_R(RE(ac->r12), RE(ac->r12)) + MUL_R(IM(ac->r12), IM(ac->r12)))); ------------------ | | 268| 1.33k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.33k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 1.33k|#define FRAC_BITS 31 | | ------------------ ------------------ 424| 1.33k|} sbr_hfgen.c:calc_chirp_factors: 595| 3.96k|{ 596| 3.96k| uint8_t i; 597| | 598| 11.7k| for (i = 0; i < sbr->N_Q; i++) ------------------ | Branch (598:17): [True: 7.76k, False: 3.96k] ------------------ 599| 7.76k| { 600| 7.76k| sbr->bwArray[ch][i] = mapNewBw(sbr->bs_invf_mode[ch][i], sbr->bs_invf_mode_prev[ch][i]); 601| | 602| 7.76k| if (sbr->bwArray[ch][i] < sbr->bwArray_prev[ch][i]) ------------------ | Branch (602:13): [True: 16, False: 7.74k] ------------------ 603| 16| sbr->bwArray[ch][i] = MUL_F(sbr->bwArray[ch][i], FRAC_CONST(0.75)) + MUL_F(sbr->bwArray_prev[ch][i], FRAC_CONST(0.25)); ------------------ | | 268| 64| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 16, Folded] | | | Branch (268:55): [Folded, False: 16] | | ------------------ ------------------ sbr->bwArray[ch][i] = MUL_F(sbr->bwArray[ch][i], FRAC_CONST(0.75)) + MUL_F(sbr->bwArray_prev[ch][i], FRAC_CONST(0.25)); ------------------ | | 268| 64| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 16|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 16, Folded] | | | Branch (268:55): [Folded, False: 16] | | ------------------ ------------------ 604| 7.74k| else 605| 7.74k| sbr->bwArray[ch][i] = MUL_F(sbr->bwArray[ch][i], FRAC_CONST(0.90625)) + MUL_F(sbr->bwArray_prev[ch][i], FRAC_CONST(0.09375)); ------------------ | | 268| 30.9k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.74k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.74k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 7.74k, Folded] | | | Branch (268:55): [Folded, False: 7.74k] | | ------------------ ------------------ sbr->bwArray[ch][i] = MUL_F(sbr->bwArray[ch][i], FRAC_CONST(0.90625)) + MUL_F(sbr->bwArray_prev[ch][i], FRAC_CONST(0.09375)); ------------------ | | 268| 30.9k| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.74k|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 7.74k|#define FRAC_BITS 31 | | ------------------ | | | Branch (268:55): [True: 7.74k, Folded] | | | Branch (268:55): [Folded, False: 7.74k] | | ------------------ ------------------ 606| | 607| 7.76k| if (sbr->bwArray[ch][i] < COEF_CONST(0.015625)) ------------------ | | 60| 7.76k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 7.76k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 7.76k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 7.76k, Folded] | | ------------------ ------------------ | Branch (607:13): [True: 3.20k, False: 4.55k] ------------------ 608| 3.20k| sbr->bwArray[ch][i] = COEF_CONST(0.0); ------------------ | | 60| 3.20k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 3.20k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 3.20k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 3.20k, Folded] | | ------------------ ------------------ 609| | 610| 7.76k| if (sbr->bwArray[ch][i] >= COEF_CONST(0.99609375)) ------------------ | | 60| 7.76k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 7.76k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 7.76k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 7.76k, Folded] | | ------------------ ------------------ | Branch (610:13): [True: 0, False: 7.76k] ------------------ 611| 0| sbr->bwArray[ch][i] = COEF_CONST(0.99609375); ------------------ | | 60| 0|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 612| | 613| 7.76k| sbr->bwArray_prev[ch][i] = sbr->bwArray[ch][i]; 614| 7.76k| sbr->bs_invf_mode_prev[ch][i] = sbr->bs_invf_mode[ch][i]; 615| 7.76k| } 616| 3.96k|} sbr_hfgen.c:mapNewBw: 570| 7.76k|{ 571| 7.76k| switch (invf_mode) 572| 7.76k| { 573| 1.59k| case 1: /* LOW */ ------------------ | Branch (573:5): [True: 1.59k, False: 6.17k] ------------------ 574| 1.59k| if (invf_mode_prev == 0) /* NONE */ ------------------ | Branch (574:13): [True: 1.46k, False: 128] ------------------ 575| 1.46k| return COEF_CONST(0.6); ------------------ | | 60| 1.46k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 1.46k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 1.46k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 1.46k, Folded] | | ------------------ ------------------ 576| 128| else 577| 128| return COEF_CONST(0.75); ------------------ | | 60| 128|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 128|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 128|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 128, Folded] | | ------------------ ------------------ 578| | 579| 518| case 2: /* MID */ ------------------ | Branch (579:5): [True: 518, False: 7.24k] ------------------ 580| 518| return COEF_CONST(0.9); ------------------ | | 60| 518|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 518|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 518|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 518, Folded] | | ------------------ ------------------ 581| | 582| 2.42k| case 3: /* HIGH */ ------------------ | Branch (582:5): [True: 2.42k, False: 5.33k] ------------------ 583| 2.42k| return COEF_CONST(0.98); ------------------ | | 60| 2.42k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 2.42k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 2.42k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 2.42k, Folded] | | ------------------ ------------------ 584| | 585| 3.22k| default: /* NONE */ ------------------ | Branch (585:5): [True: 3.22k, False: 4.53k] ------------------ 586| 3.22k| if (invf_mode_prev == 1) /* LOW */ ------------------ | Branch (586:13): [True: 11, False: 3.21k] ------------------ 587| 11| return COEF_CONST(0.6); ------------------ | | 60| 11|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 11|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 11|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 11, Folded] | | ------------------ ------------------ 588| 3.21k| else 589| 3.21k| return COEF_CONST(0.0); ------------------ | | 60| 3.21k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 3.21k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 3.21k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 3.21k, Folded] | | ------------------ ------------------ 590| 7.76k| } 591| 7.76k|} sbr_hfgen.c:patch_construction: 619| 3.05k|{ 620| 3.05k| uint8_t i, k; 621| 3.05k| uint8_t odd, sb; 622| 3.05k| uint8_t msb = sbr->k0; 623| 3.05k| uint8_t usb = sbr->kx; 624| 3.05k| uint8_t goalSbTab[] = { 21, 23, 32, 43, 46, 64, 85, 93, 128, 0, 0, 0 }; 625| | /* (uint8_t)(2.048e6/sbr->sample_rate + 0.5); */ 626| 3.05k| uint8_t goalSb = goalSbTab[get_sr_index(sbr->sample_rate)]; 627| | 628| 3.05k| sbr->noPatches = 0; 629| | 630| 3.05k| if (goalSb < (sbr->kx + sbr->M)) ------------------ | Branch (630:9): [True: 653, False: 2.40k] ------------------ 631| 653| { 632| 6.61k| for (i = 0, k = 0; sbr->f_master[i] < goalSb; i++) ------------------ | Branch (632:28): [True: 5.95k, False: 653] ------------------ 633| 5.95k| k = i+1; 634| 2.40k| } else { 635| 2.40k| k = sbr->N_master; 636| 2.40k| } 637| | 638| 3.05k| if (sbr->N_master == 0) ------------------ | Branch (638:9): [True: 0, False: 3.05k] ------------------ 639| 0| { 640| 0| sbr->noPatches = 0; 641| 0| sbr->patchNoSubbands[0] = 0; 642| 0| sbr->patchStartSubband[0] = 0; 643| | 644| 0| return; 645| 0| } 646| | 647| 3.05k| do 648| 7.40k| { 649| 7.40k| uint8_t j = k + 1; 650| | 651| 7.40k| do 652| 22.3k| { 653| 22.3k| j--; 654| | 655| 22.3k| sb = sbr->f_master[j]; 656| 22.3k| odd = (sb - 2 + sbr->k0) % 2; 657| 22.3k| } while (sb > (sbr->k0 - 1 + msb - odd)); ------------------ | Branch (657:18): [True: 14.9k, False: 7.40k] ------------------ 658| | 659| 7.40k| sbr->patchNoSubbands[sbr->noPatches] = max(sb - usb, 0); ------------------ | | 57| 7.40k|#define max(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (57:20): [True: 7.19k, False: 208] | | ------------------ ------------------ 660| 7.40k| sbr->patchStartSubband[sbr->noPatches] = sbr->k0 - odd - 661| 7.40k| sbr->patchNoSubbands[sbr->noPatches]; 662| | 663| 7.40k| if (sbr->patchNoSubbands[sbr->noPatches] > 0) ------------------ | Branch (663:13): [True: 7.19k, False: 208] ------------------ 664| 7.19k| { 665| 7.19k| usb = sb; 666| 7.19k| msb = sb; 667| 7.19k| sbr->noPatches++; 668| 7.19k| } else { 669| 208| msb = sbr->kx; 670| 208| } 671| | 672| 7.40k| if (sbr->f_master[k] - sb < 3) ------------------ | Branch (672:13): [True: 3.93k, False: 3.47k] ------------------ 673| 3.93k| k = sbr->N_master; 674| 7.40k| } while (sb != (sbr->kx + sbr->M)); ------------------ | Branch (674:14): [True: 4.34k, False: 3.05k] ------------------ 675| | 676| 3.05k| if ((sbr->patchNoSubbands[sbr->noPatches-1] < 3) && (sbr->noPatches > 1)) ------------------ | Branch (676:9): [True: 1.76k, False: 1.29k] | Branch (676:57): [True: 395, False: 1.36k] ------------------ 677| 395| { 678| 395| sbr->noPatches--; 679| 395| } 680| | 681| 3.05k| sbr->noPatches = min(sbr->noPatches, 5); ------------------ | | 60| 3.05k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 2.61k, False: 437] | | ------------------ ------------------ 682| 3.05k|} sbr_envelope: 246| 16.2k|{ 247| 16.2k| uint8_t env, band; 248| 16.2k| int8_t delta = 0; 249| 16.2k| sbr_huff_tab t_huff, f_huff; 250| | 251| 16.2k| if ((sbr->L_E[ch] == 1) && (sbr->bs_frame_class[ch] == FIXFIX)) ------------------ | | 46| 8.38k|#define FIXFIX 0 ------------------ | Branch (251:9): [True: 8.38k, False: 7.81k] | Branch (251:32): [True: 5.05k, False: 3.33k] ------------------ 252| 5.05k| sbr->amp_res[ch] = 0; 253| 11.1k| else 254| 11.1k| sbr->amp_res[ch] = sbr->bs_amp_res; 255| | 256| 16.2k| if ((sbr->bs_coupling) && (ch == 1)) ------------------ | Branch (256:9): [True: 4.04k, False: 12.1k] | Branch (256:31): [True: 2.02k, False: 2.02k] ------------------ 257| 2.02k| { 258| 2.02k| delta = 1; 259| 2.02k| if (sbr->amp_res[ch]) ------------------ | Branch (259:13): [True: 820, False: 1.20k] ------------------ 260| 820| { 261| 820| t_huff = t_huffman_env_bal_3_0dB; 262| 820| f_huff = f_huffman_env_bal_3_0dB; 263| 1.20k| } else { 264| 1.20k| t_huff = t_huffman_env_bal_1_5dB; 265| 1.20k| f_huff = f_huffman_env_bal_1_5dB; 266| 1.20k| } 267| 14.1k| } else { 268| 14.1k| delta = 0; 269| 14.1k| if (sbr->amp_res[ch]) ------------------ | Branch (269:13): [True: 3.54k, False: 10.6k] ------------------ 270| 3.54k| { 271| 3.54k| t_huff = t_huffman_env_3_0dB; 272| 3.54k| f_huff = f_huffman_env_3_0dB; 273| 10.6k| } else { 274| 10.6k| t_huff = t_huffman_env_1_5dB; 275| 10.6k| f_huff = f_huffman_env_1_5dB; 276| 10.6k| } 277| 14.1k| } 278| | 279| 51.4k| for (env = 0; env < sbr->L_E[ch]; env++) ------------------ | Branch (279:19): [True: 35.2k, False: 16.2k] ------------------ 280| 35.2k| { 281| 35.2k| if (sbr->bs_df_env[ch][env] == 0) ------------------ | Branch (281:13): [True: 24.2k, False: 11.0k] ------------------ 282| 24.2k| { 283| 24.2k| if ((sbr->bs_coupling == 1) && (ch == 1)) ------------------ | Branch (283:17): [True: 7.56k, False: 16.7k] | Branch (283:44): [True: 3.67k, False: 3.88k] ------------------ 284| 3.67k| { 285| 3.67k| if (sbr->amp_res[ch]) ------------------ | Branch (285:21): [True: 1.22k, False: 2.44k] ------------------ 286| 1.22k| { 287| 1.22k| sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 5 288| 1.22k| DEBUGVAR(1,272,"sbr_envelope(): bs_data_env")) << delta); 289| 2.44k| } else { 290| 2.44k| sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 6 291| 2.44k| DEBUGVAR(1,273,"sbr_envelope(): bs_data_env")) << delta); 292| 2.44k| } 293| 20.5k| } else { 294| 20.5k| if (sbr->amp_res[ch]) ------------------ | Branch (294:21): [True: 6.37k, False: 14.2k] ------------------ 295| 6.37k| { 296| 6.37k| sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 6 297| 6.37k| DEBUGVAR(1,274,"sbr_envelope(): bs_data_env")) << delta); 298| 14.2k| } else { 299| 14.2k| sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 7 300| 14.2k| DEBUGVAR(1,275,"sbr_envelope(): bs_data_env")) << delta); 301| 14.2k| } 302| 20.5k| } 303| | 304| 134k| for (band = 1; band < sbr->n[sbr->f[ch][env]]; band++) ------------------ | Branch (304:28): [True: 110k, False: 24.2k] ------------------ 305| 110k| { 306| 110k| sbr->E[ch][band][env] = (sbr_huff_dec(ld, f_huff)); 307| 110k| } 308| | 309| 24.2k| } else { 310| 68.8k| for (band = 0; band < sbr->n[sbr->f[ch][env]]; band++) ------------------ | Branch (310:28): [True: 57.8k, False: 11.0k] ------------------ 311| 57.8k| { 312| 57.8k| sbr->E[ch][band][env] = (sbr_huff_dec(ld, t_huff)); 313| 57.8k| } 314| 11.0k| } 315| 35.2k| } 316| | 317| 16.2k| extract_envelope_data(sbr, ch); 318| 16.2k|} sbr_noise: 322| 16.2k|{ 323| 16.2k| uint8_t noise, band; 324| 16.2k| int8_t delta = 0; 325| 16.2k| sbr_huff_tab t_huff, f_huff; 326| | 327| 16.2k| if ((sbr->bs_coupling == 1) && (ch == 1)) ------------------ | Branch (327:9): [True: 4.04k, False: 12.1k] | Branch (327:36): [True: 2.02k, False: 2.02k] ------------------ 328| 2.02k| { 329| 2.02k| delta = 1; 330| 2.02k| t_huff = t_huffman_noise_bal_3_0dB; 331| 2.02k| f_huff = f_huffman_env_bal_3_0dB; 332| 14.1k| } else { 333| 14.1k| delta = 0; 334| 14.1k| t_huff = t_huffman_noise_3_0dB; 335| 14.1k| f_huff = f_huffman_env_3_0dB; 336| 14.1k| } 337| | 338| 40.2k| for (noise = 0; noise < sbr->L_Q[ch]; noise++) ------------------ | Branch (338:21): [True: 24.0k, False: 16.2k] ------------------ 339| 24.0k| { 340| 24.0k| if(sbr->bs_df_noise[ch][noise] == 0) ------------------ | Branch (340:12): [True: 15.6k, False: 8.32k] ------------------ 341| 15.6k| { 342| 15.6k| if ((sbr->bs_coupling == 1) && (ch == 1)) ------------------ | Branch (342:17): [True: 4.43k, False: 11.2k] | Branch (342:44): [True: 2.19k, False: 2.24k] ------------------ 343| 2.19k| { 344| 2.19k| sbr->Q[ch][0][noise] = (faad_getbits(ld, 5 345| 2.19k| DEBUGVAR(1,276,"sbr_noise(): bs_data_noise")) << delta); 346| 13.5k| } else { 347| 13.5k| sbr->Q[ch][0][noise] = (faad_getbits(ld, 5 348| 13.5k| DEBUGVAR(1,277,"sbr_noise(): bs_data_noise")) << delta); 349| 13.5k| } 350| 28.9k| for (band = 1; band < sbr->N_Q; band++) ------------------ | Branch (350:28): [True: 13.2k, False: 15.6k] ------------------ 351| 13.2k| { 352| 13.2k| sbr->Q[ch][band][noise] = (sbr_huff_dec(ld, f_huff)); 353| 13.2k| } 354| 15.6k| } else { 355| 26.0k| for (band = 0; band < sbr->N_Q; band++) ------------------ | Branch (355:28): [True: 17.7k, False: 8.32k] ------------------ 356| 17.7k| { 357| 17.7k| sbr->Q[ch][band][noise] = (sbr_huff_dec(ld, t_huff)); 358| 17.7k| } 359| 8.32k| } 360| 24.0k| } 361| | 362| 16.2k| extract_noise_floor_data(sbr, ch); 363| 16.2k|} sbr_huff.c:sbr_huff_dec: 231| 199k|{ 232| 199k| uint8_t bit; 233| 199k| int16_t index = 0; 234| | 235| 649k| while (index >= 0) ------------------ | Branch (235:12): [True: 450k, False: 199k] ------------------ 236| 450k| { 237| 450k| bit = (uint8_t)faad_get1bit(ld); 238| 450k| index = t_huff[index][bit]; 239| 450k| } 240| | 241| 199k| return index + 64; 242| 199k|} qmfa_init: 44| 34.8k|{ 45| 34.8k| qmfa_info *qmfa = (qmfa_info*)faad_malloc(sizeof(qmfa_info)); 46| | 47| | /* x is implemented as double ringbuffer */ 48| 34.8k| qmfa->x = (real_t*)faad_malloc(2 * channels * 10 * sizeof(real_t)); 49| 34.8k| memset(qmfa->x, 0, 2 * channels * 10 * sizeof(real_t)); 50| | 51| | /* ringbuffer index */ 52| 34.8k| qmfa->x_index = 0; 53| | 54| 34.8k| qmfa->channels = channels; 55| | 56| 34.8k| return qmfa; 57| 34.8k|} qmfa_end: 60| 37.4k|{ 61| 37.4k| if (qmfa) ------------------ | Branch (61:9): [True: 34.8k, False: 2.61k] ------------------ 62| 34.8k| { 63| 34.8k| if (qmfa->x) faad_free(qmfa->x); ------------------ | Branch (63:13): [True: 34.8k, False: 0] ------------------ 64| 34.8k| faad_free(qmfa); 65| 34.8k| } 66| 37.4k|} sbr_qmf_analysis_32: 70| 41.8k|{ 71| 41.8k| ALIGN real_t u[64]; 72| 41.8k|#ifndef SBR_LOW_POWER 73| 41.8k| ALIGN real_t in_real[32], in_imag[32], out_real[32], out_imag[32]; 74| |#else 75| | ALIGN real_t y[32]; 76| |#endif 77| 41.8k| uint32_t in = 0; 78| 41.8k| uint8_t l; 79| | 80| | /* qmf subsample l */ 81| 1.35M| for (l = 0; l < sbr->numTimeSlotsRate; l++) ------------------ | Branch (81:17): [True: 1.31M, False: 41.8k] ------------------ 82| 1.31M| { 83| 1.31M| int16_t n; 84| | 85| | /* shift input buffer x */ 86| | /* input buffer is not shifted anymore, x is implemented as double ringbuffer */ 87| | //memmove(qmfa->x + 32, qmfa->x, (320-32)*sizeof(real_t)); 88| | 89| | /* add new samples to input buffer x */ 90| 43.3M| for (n = 32 - 1; n >= 0; n--) ------------------ | Branch (90:26): [True: 42.0M, False: 1.31M] ------------------ 91| 42.0M| { 92| 42.0M|#ifdef FIXED_POINT 93| 42.0M| qmfa->x[qmfa->x_index + n] = qmfa->x[qmfa->x_index + n + 320] = (input[in++]) >> 4; 94| |#else 95| | qmfa->x[qmfa->x_index + n] = qmfa->x[qmfa->x_index + n + 320] = input[in++]; 96| |#endif 97| 42.0M| } 98| | 99| | /* window and summation to create array u */ 100| 85.4M| for (n = 0; n < 64; n++) ------------------ | Branch (100:21): [True: 84.1M, False: 1.31M] ------------------ 101| 84.1M| { 102| 84.1M| u[n] = MUL_F(qmfa->x[qmfa->x_index + n], qmf_c[2*n]) + ------------------ | | 268| 84.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 103| 84.1M| MUL_F(qmfa->x[qmfa->x_index + n + 64], qmf_c[2*(n + 64)]) + ------------------ | | 268| 84.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 104| 84.1M| MUL_F(qmfa->x[qmfa->x_index + n + 128], qmf_c[2*(n + 128)]) + ------------------ | | 268| 84.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 105| 84.1M| MUL_F(qmfa->x[qmfa->x_index + n + 192], qmf_c[2*(n + 192)]) + ------------------ | | 268| 84.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 106| 84.1M| MUL_F(qmfa->x[qmfa->x_index + n + 256], qmf_c[2*(n + 256)]); ------------------ | | 268| 84.1M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 84.1M|#define FRAC_BITS 31 | | ------------------ ------------------ 107| 84.1M| } 108| | 109| | /* update ringbuffer index */ 110| 1.31M| qmfa->x_index -= 32; 111| 1.31M| if (qmfa->x_index < 0) ------------------ | Branch (111:7): [True: 151k, False: 1.16M] ------------------ 112| 151k| qmfa->x_index = (320-32); 113| | 114| | /* calculate 32 subband samples by introducing X */ 115| |#ifdef SBR_LOW_POWER 116| | y[0] = u[48]; 117| | for (n = 1; n < 16; n++) 118| | y[n] = u[n+48] + u[48-n]; 119| | for (n = 16; n < 32; n++) 120| | y[n] = -u[n-16] + u[48-n]; 121| | 122| | DCT3_32_unscaled(u, y); 123| | 124| | for (n = 0; n < 32; n++) 125| | { 126| | if (n < kx) 127| | { 128| |#ifdef FIXED_POINT 129| | QMF_RE(X[l + offset][n]) = u[n] /*<< 1*/; 130| |#else 131| | QMF_RE(X[l + offset][n]) = 2. * u[n]; 132| |#endif 133| | } else { 134| | QMF_RE(X[l + offset][n]) = 0; 135| | } 136| | } 137| |#else 138| | 139| | // Reordering of data moved from DCT_IV to here 140| 1.31M| in_imag[31] = u[1]; 141| 1.31M| in_real[0] = u[0]; 142| 40.7M| for (n = 1; n < 31; n++) ------------------ | Branch (142:21): [True: 39.4M, False: 1.31M] ------------------ 143| 39.4M| { 144| 39.4M| in_imag[31 - n] = u[n+1]; 145| 39.4M| in_real[n] = -u[64-n]; 146| 39.4M| } 147| 1.31M| in_imag[0] = u[32]; 148| 1.31M| in_real[31] = -u[33]; 149| | 150| | // dct4_kernel is DCT_IV without reordering which is done before and after FFT 151| 1.31M| dct4_kernel(in_real, in_imag, out_real, out_imag); 152| | 153| | // Reordering of data moved from DCT_IV to here 154| 22.3M| for (n = 0; n < 16; n++) { ------------------ | Branch (154:21): [True: 21.0M, False: 1.31M] ------------------ 155| 21.0M| if (2*n+1 < kx) { ------------------ | Branch (155:17): [True: 19.9M, False: 1.10M] ------------------ 156| 19.9M|#ifdef FIXED_POINT 157| 19.9M| QMF_RE(X[l + offset][2*n]) = out_real[n]; ------------------ | | 168| 19.9M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 19.9M|#define RE(A) (A)[0] | | ------------------ ------------------ 158| 19.9M| QMF_IM(X[l + offset][2*n]) = out_imag[n]; ------------------ | | 169| 19.9M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 19.9M|#define IM(A) (A)[1] | | ------------------ ------------------ 159| 19.9M| QMF_RE(X[l + offset][2*n+1]) = -out_imag[31-n]; ------------------ | | 168| 19.9M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 19.9M|#define RE(A) (A)[0] | | ------------------ ------------------ 160| 19.9M| QMF_IM(X[l + offset][2*n+1]) = -out_real[31-n]; ------------------ | | 169| 19.9M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 19.9M|#define IM(A) (A)[1] | | ------------------ ------------------ 161| |#else 162| | QMF_RE(X[l + offset][2*n]) = 2. * out_real[n]; 163| | QMF_IM(X[l + offset][2*n]) = 2. * out_imag[n]; 164| | QMF_RE(X[l + offset][2*n+1]) = -2. * out_imag[31-n]; 165| | QMF_IM(X[l + offset][2*n+1]) = -2. * out_real[31-n]; 166| |#endif 167| 19.9M| } else { 168| 1.10M| if (2*n < kx) { ------------------ | Branch (168:21): [True: 62.4k, False: 1.04M] ------------------ 169| 62.4k|#ifdef FIXED_POINT 170| 62.4k| QMF_RE(X[l + offset][2*n]) = out_real[n]; ------------------ | | 168| 62.4k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 62.4k|#define RE(A) (A)[0] | | ------------------ ------------------ 171| 62.4k| QMF_IM(X[l + offset][2*n]) = out_imag[n]; ------------------ | | 169| 62.4k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 62.4k|#define IM(A) (A)[1] | | ------------------ ------------------ 172| |#else 173| | QMF_RE(X[l + offset][2*n]) = 2. * out_real[n]; 174| | QMF_IM(X[l + offset][2*n]) = 2. * out_imag[n]; 175| |#endif 176| 62.4k| } 177| 1.04M| else { 178| 1.04M| QMF_RE(X[l + offset][2*n]) = 0; ------------------ | | 168| 1.04M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.04M|#define RE(A) (A)[0] | | ------------------ ------------------ 179| 1.04M| QMF_IM(X[l + offset][2*n]) = 0; ------------------ | | 169| 1.04M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.04M|#define IM(A) (A)[1] | | ------------------ ------------------ 180| 1.04M| } 181| 1.10M| QMF_RE(X[l + offset][2*n+1]) = 0; ------------------ | | 168| 1.10M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 1.10M|#define RE(A) (A)[0] | | ------------------ ------------------ 182| 1.10M| QMF_IM(X[l + offset][2*n+1]) = 0; ------------------ | | 169| 1.10M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 1.10M|#define IM(A) (A)[1] | | ------------------ ------------------ 183| 1.10M| } 184| 21.0M| } 185| 1.31M|#endif 186| 1.31M| } 187| 41.8k|} qmfs_init: 226| 37.4k|{ 227| 37.4k| qmfs_info *qmfs = (qmfs_info*)faad_malloc(sizeof(qmfs_info)); 228| | 229| | /* v is a double ringbuffer */ 230| 37.4k| qmfs->v = (real_t*)faad_malloc(2 * channels * 20 * sizeof(real_t)); 231| 37.4k| memset(qmfs->v, 0, 2 * channels * 20 * sizeof(real_t)); 232| | 233| 37.4k| qmfs->v_index = 0; 234| | 235| 37.4k| qmfs->channels = channels; 236| | 237| 37.4k| return qmfs; 238| 37.4k|} qmfs_end: 241| 37.4k|{ 242| 37.4k| if (qmfs) ------------------ | Branch (242:9): [True: 37.4k, False: 0] ------------------ 243| 37.4k| { 244| 37.4k| if (qmfs->v) faad_free(qmfs->v); ------------------ | Branch (244:13): [True: 37.4k, False: 0] ------------------ 245| 37.4k| faad_free(qmfs); 246| 37.4k| } 247| 37.4k|} sbr_qmf_synthesis_32: 392| 18.1k|{ 393| 18.1k| ALIGN real_t x1[32], x2[32]; 394| |#ifndef FIXED_POINT 395| | real_t scale = 1.f/64.f; 396| |#endif 397| 18.1k| int32_t n, k, out = 0; 398| 18.1k| uint8_t l; 399| | 400| | 401| | /* qmf subsample l */ 402| 588k| for (l = 0; l < sbr->numTimeSlotsRate; l++) ------------------ | Branch (402:17): [True: 569k, False: 18.1k] ------------------ 403| 569k| { 404| | /* shift buffer v */ 405| | /* buffer is not shifted, we are using a ringbuffer */ 406| | //memmove(qmfs->v + 64, qmfs->v, (640-64)*sizeof(real_t)); 407| | 408| | /* calculate 64 samples */ 409| | /* complex pre-twiddle */ 410| 18.8M| for (k = 0; k < 32; k++) ------------------ | Branch (410:21): [True: 18.2M, False: 569k] ------------------ 411| 18.2M| { 412| 18.2M| x1[k] = MUL_F(QMF_RE(X[l][k]), RE(qmf32_pre_twiddle[k])) - MUL_F(QMF_IM(X[l][k]), IM(qmf32_pre_twiddle[k])); ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ x1[k] = MUL_F(QMF_RE(X[l][k]), RE(qmf32_pre_twiddle[k])) - MUL_F(QMF_IM(X[l][k]), IM(qmf32_pre_twiddle[k])); ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 413| 18.2M| x2[k] = MUL_F(QMF_IM(X[l][k]), RE(qmf32_pre_twiddle[k])) + MUL_F(QMF_RE(X[l][k]), IM(qmf32_pre_twiddle[k])); ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ x2[k] = MUL_F(QMF_IM(X[l][k]), RE(qmf32_pre_twiddle[k])) + MUL_F(QMF_RE(X[l][k]), IM(qmf32_pre_twiddle[k])); ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 414| | 415| |#ifndef FIXED_POINT 416| | x1[k] *= scale; 417| | x2[k] *= scale; 418| |#else 419| 18.2M| x1[k] >>= 1; 420| 18.2M| x2[k] >>= 1; 421| 18.2M|#endif 422| 18.2M| } 423| | 424| | /* transform */ 425| 569k| DCT4_32(x1, x1); 426| 569k| DST4_32(x2, x2); 427| | 428| 18.8M| for (n = 0; n < 32; n++) ------------------ | Branch (428:21): [True: 18.2M, False: 569k] ------------------ 429| 18.2M| { 430| 18.2M| qmfs->v[qmfs->v_index + n] = qmfs->v[qmfs->v_index + 640 + n] = -x1[n] + x2[n]; 431| 18.2M| qmfs->v[qmfs->v_index + 63 - n] = qmfs->v[qmfs->v_index + 640 + 63 - n] = x1[n] + x2[n]; 432| 18.2M| } 433| | 434| | /* calculate 32 output samples and window */ 435| 18.8M| for (k = 0; k < 32; k++) ------------------ | Branch (435:21): [True: 18.2M, False: 569k] ------------------ 436| 18.2M| { 437| 18.2M| output[out++] = MUL_F(qmfs->v[qmfs->v_index + k], qmf_c[2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 438| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 96 + k], qmf_c[64 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 439| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 128 + k], qmf_c[128 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 440| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 224 + k], qmf_c[192 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 441| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 256 + k], qmf_c[256 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 442| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 352 + k], qmf_c[320 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 443| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 384 + k], qmf_c[384 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 444| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 480 + k], qmf_c[448 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 445| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 512 + k], qmf_c[512 + 2*k]) + ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 446| 18.2M| MUL_F(qmfs->v[qmfs->v_index + 608 + k], qmf_c[576 + 2*k]); ------------------ | | 268| 18.2M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 18.2M|#define FRAC_BITS 31 | | ------------------ ------------------ 447| 18.2M| } 448| | 449| | /* update ringbuffer index */ 450| 569k| qmfs->v_index -= 64; 451| 569k| if (qmfs->v_index < 0) ------------------ | Branch (451:13): [True: 64.3k, False: 505k] ------------------ 452| 64.3k| qmfs->v_index = (640 - 64); 453| 569k| } 454| 18.1k|} sbr_qmf_synthesis_64: 458| 27.4k|{ 459| |// ALIGN real_t x1[64], x2[64]; 460| 27.4k|#ifndef SBR_LOW_POWER 461| 27.4k| ALIGN real_t in_real1[32], in_imag1[32], out_real1[32], out_imag1[32]; 462| 27.4k| ALIGN real_t in_real2[32], in_imag2[32], out_real2[32], out_imag2[32]; 463| 27.4k|#endif 464| 27.4k| qmf_t * pX; ------------------ | | 167| 27.4k|#define qmf_t complex_t ------------------ 465| 27.4k| real_t * pring_buffer_1, * pring_buffer_3; 466| |// real_t * ptemp_1, * ptemp_2; 467| |#ifdef PREFER_POINTERS 468| | // These pointers are used if target platform has autoinc address generators 469| | real_t * pring_buffer_2, * pring_buffer_4; 470| | real_t * pring_buffer_5, * pring_buffer_6; 471| | real_t * pring_buffer_7, * pring_buffer_8; 472| | real_t * pring_buffer_9, * pring_buffer_10; 473| | const real_t * pqmf_c_1, * pqmf_c_2, * pqmf_c_3, * pqmf_c_4; 474| | const real_t * pqmf_c_5, * pqmf_c_6, * pqmf_c_7, * pqmf_c_8; 475| | const real_t * pqmf_c_9, * pqmf_c_10; 476| |#endif // #ifdef PREFER_POINTERS 477| |#ifndef FIXED_POINT 478| | real_t scale = 1.f/64.f; 479| |#endif 480| 27.4k| int32_t n, k, out = 0; 481| 27.4k| uint8_t l; 482| | 483| | 484| | /* qmf subsample l */ 485| 891k| for (l = 0; l < sbr->numTimeSlotsRate; l++) ------------------ | Branch (485:17): [True: 864k, False: 27.4k] ------------------ 486| 864k| { 487| | /* shift buffer v */ 488| | /* buffer is not shifted, we use double ringbuffer */ 489| | //memmove(qmfs->v + 128, qmfs->v, (1280-128)*sizeof(real_t)); 490| | 491| | /* calculate 128 samples */ 492| |#ifndef FIXED_POINT 493| | 494| | pX = X[l]; 495| | 496| | in_imag1[31] = scale*QMF_RE(pX[1]); 497| | in_real1[0] = scale*QMF_RE(pX[0]); 498| | in_imag2[31] = scale*QMF_IM(pX[63-1]); 499| | in_real2[0] = scale*QMF_IM(pX[63-0]); 500| | for (k = 1; k < 31; k++) 501| | { 502| | in_imag1[31 - k] = scale*QMF_RE(pX[2*k + 1]); 503| | in_real1[ k] = scale*QMF_RE(pX[2*k ]); 504| | in_imag2[31 - k] = scale*QMF_IM(pX[63 - (2*k + 1)]); 505| | in_real2[ k] = scale*QMF_IM(pX[63 - (2*k )]); 506| | } 507| | in_imag1[0] = scale*QMF_RE(pX[63]); 508| | in_real1[31] = scale*QMF_RE(pX[62]); 509| | in_imag2[0] = scale*QMF_IM(pX[63-63]); 510| | in_real2[31] = scale*QMF_IM(pX[63-62]); 511| | 512| |#else 513| | 514| 864k| pX = X[l]; 515| | 516| 864k| in_imag1[31] = QMF_RE(pX[1]) >> 1; ------------------ | | 168| 864k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 864k|#define RE(A) (A)[0] | | ------------------ ------------------ 517| 864k| in_real1[0] = QMF_RE(pX[0]) >> 1; ------------------ | | 168| 864k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 864k|#define RE(A) (A)[0] | | ------------------ ------------------ 518| 864k| in_imag2[31] = QMF_IM(pX[62]) >> 1; ------------------ | | 169| 864k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 864k|#define IM(A) (A)[1] | | ------------------ ------------------ 519| 864k| in_real2[0] = QMF_IM(pX[63]) >> 1; ------------------ | | 169| 864k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 864k|#define IM(A) (A)[1] | | ------------------ ------------------ 520| 26.7M| for (k = 1; k < 31; k++) ------------------ | Branch (520:21): [True: 25.9M, False: 864k] ------------------ 521| 25.9M| { 522| 25.9M| in_imag1[31 - k] = QMF_RE(pX[2*k + 1]) >> 1; ------------------ | | 168| 25.9M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 25.9M|#define RE(A) (A)[0] | | ------------------ ------------------ 523| 25.9M| in_real1[ k] = QMF_RE(pX[2*k ]) >> 1; ------------------ | | 168| 25.9M|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 25.9M|#define RE(A) (A)[0] | | ------------------ ------------------ 524| 25.9M| in_imag2[31 - k] = QMF_IM(pX[63 - (2*k + 1)]) >> 1; ------------------ | | 169| 25.9M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 25.9M|#define IM(A) (A)[1] | | ------------------ ------------------ 525| 25.9M| in_real2[ k] = QMF_IM(pX[63 - (2*k )]) >> 1; ------------------ | | 169| 25.9M|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 25.9M|#define IM(A) (A)[1] | | ------------------ ------------------ 526| 25.9M| } 527| 864k| in_imag1[0] = QMF_RE(pX[63]) >> 1; ------------------ | | 168| 864k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 864k|#define RE(A) (A)[0] | | ------------------ ------------------ 528| 864k| in_real1[31] = QMF_RE(pX[62]) >> 1; ------------------ | | 168| 864k|#define QMF_RE(A) RE(A) | | ------------------ | | | | 391| 864k|#define RE(A) (A)[0] | | ------------------ ------------------ 529| 864k| in_imag2[0] = QMF_IM(pX[0]) >> 1; ------------------ | | 169| 864k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 864k|#define IM(A) (A)[1] | | ------------------ ------------------ 530| 864k| in_real2[31] = QMF_IM(pX[1]) >> 1; ------------------ | | 169| 864k|#define QMF_IM(A) IM(A) | | ------------------ | | | | 392| 864k|#define IM(A) (A)[1] | | ------------------ ------------------ 531| | 532| 864k|#endif 533| | 534| | 535| | // dct4_kernel is DCT_IV without reordering which is done before and after FFT 536| 864k| dct4_kernel(in_real1, in_imag1, out_real1, out_imag1); 537| 864k| dct4_kernel(in_real2, in_imag2, out_real2, out_imag2); 538| | 539| | 540| 864k| pring_buffer_1 = qmfs->v + qmfs->v_index; 541| 864k| pring_buffer_3 = pring_buffer_1 + 1280; 542| |#ifdef PREFER_POINTERS 543| | pring_buffer_2 = pring_buffer_1 + 127; 544| | pring_buffer_4 = pring_buffer_1 + (1280 + 127); 545| |#endif // #ifdef PREFER_POINTERS 546| |// ptemp_1 = x1; 547| |// ptemp_2 = x2; 548| |#ifdef PREFER_POINTERS 549| | for (n = 0; n < 32; n ++) 550| | { 551| | //real_t x1 = *ptemp_1++; 552| | //real_t x2 = *ptemp_2++; 553| | // pring_buffer_3 and pring_buffer_4 are needed only for double ring buffer 554| | *pring_buffer_1++ = *pring_buffer_3++ = out_real2[n] - out_real1[n]; 555| | *pring_buffer_2-- = *pring_buffer_4-- = out_real2[n] + out_real1[n]; 556| | //x1 = *ptemp_1++; 557| | //x2 = *ptemp_2++; 558| | *pring_buffer_1++ = *pring_buffer_3++ = out_imag2[31-n] + out_imag1[31-n]; 559| | *pring_buffer_2-- = *pring_buffer_4-- = out_imag2[31-n] - out_imag1[31-n]; 560| | } 561| |#else // #ifdef PREFER_POINTERS 562| | 563| 28.5M| for (n = 0; n < 32; n++) ------------------ | Branch (563:21): [True: 27.6M, False: 864k] ------------------ 564| 27.6M| { 565| | // pring_buffer_3 and pring_buffer_4 are needed only for double ring buffer 566| 27.6M| pring_buffer_1[2*n] = pring_buffer_3[2*n] = out_real2[n] - out_real1[n]; 567| 27.6M| pring_buffer_1[127-2*n] = pring_buffer_3[127-2*n] = out_real2[n] + out_real1[n]; 568| 27.6M| pring_buffer_1[2*n+1] = pring_buffer_3[2*n+1] = out_imag2[31-n] + out_imag1[31-n]; 569| 27.6M| pring_buffer_1[127-(2*n+1)] = pring_buffer_3[127-(2*n+1)] = out_imag2[31-n] - out_imag1[31-n]; 570| 27.6M| } 571| | 572| 864k|#endif // #ifdef PREFER_POINTERS 573| | 574| 864k| pring_buffer_1 = qmfs->v + qmfs->v_index; 575| |#ifdef PREFER_POINTERS 576| | pring_buffer_2 = pring_buffer_1 + 192; 577| | pring_buffer_3 = pring_buffer_1 + 256; 578| | pring_buffer_4 = pring_buffer_1 + (256 + 192); 579| | pring_buffer_5 = pring_buffer_1 + 512; 580| | pring_buffer_6 = pring_buffer_1 + (512 + 192); 581| | pring_buffer_7 = pring_buffer_1 + 768; 582| | pring_buffer_8 = pring_buffer_1 + (768 + 192); 583| | pring_buffer_9 = pring_buffer_1 + 1024; 584| | pring_buffer_10 = pring_buffer_1 + (1024 + 192); 585| | pqmf_c_1 = qmf_c; 586| | pqmf_c_2 = qmf_c + 64; 587| | pqmf_c_3 = qmf_c + 128; 588| | pqmf_c_4 = qmf_c + 192; 589| | pqmf_c_5 = qmf_c + 256; 590| | pqmf_c_6 = qmf_c + 320; 591| | pqmf_c_7 = qmf_c + 384; 592| | pqmf_c_8 = qmf_c + 448; 593| | pqmf_c_9 = qmf_c + 512; 594| | pqmf_c_10 = qmf_c + 576; 595| |#endif // #ifdef PREFER_POINTERS 596| | 597| | /* calculate 64 output samples and window */ 598| 56.1M| for (k = 0; k < 64; k++) ------------------ | Branch (598:21): [True: 55.3M, False: 864k] ------------------ 599| 55.3M| { 600| |#ifdef PREFER_POINTERS 601| | output[out++] = 602| | MUL_F(*pring_buffer_1++, *pqmf_c_1++) + 603| | MUL_F(*pring_buffer_2++, *pqmf_c_2++) + 604| | MUL_F(*pring_buffer_3++, *pqmf_c_3++) + 605| | MUL_F(*pring_buffer_4++, *pqmf_c_4++) + 606| | MUL_F(*pring_buffer_5++, *pqmf_c_5++) + 607| | MUL_F(*pring_buffer_6++, *pqmf_c_6++) + 608| | MUL_F(*pring_buffer_7++, *pqmf_c_7++) + 609| | MUL_F(*pring_buffer_8++, *pqmf_c_8++) + 610| | MUL_F(*pring_buffer_9++, *pqmf_c_9++) + 611| | MUL_F(*pring_buffer_10++, *pqmf_c_10++); 612| |#else // #ifdef PREFER_POINTERS 613| 55.3M| output[out++] = 614| 55.3M| MUL_F(pring_buffer_1[k+0], qmf_c[k+0]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 615| 55.3M| MUL_F(pring_buffer_1[k+192], qmf_c[k+64]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 616| 55.3M| MUL_F(pring_buffer_1[k+256], qmf_c[k+128]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 617| 55.3M| MUL_F(pring_buffer_1[k+(256+192)], qmf_c[k+192]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 618| 55.3M| MUL_F(pring_buffer_1[k+512], qmf_c[k+256]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 619| 55.3M| MUL_F(pring_buffer_1[k+(512+192)], qmf_c[k+320]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 620| 55.3M| MUL_F(pring_buffer_1[k+768], qmf_c[k+384]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 621| 55.3M| MUL_F(pring_buffer_1[k+(768+192)], qmf_c[k+448]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 622| 55.3M| MUL_F(pring_buffer_1[k+1024], qmf_c[k+512]) + ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 623| 55.3M| MUL_F(pring_buffer_1[k+(1024+192)], qmf_c[k+576]); ------------------ | | 268| 55.3M| #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ | | #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1u << (FRAC_BITS-1))) >> FRAC_BITS) | | ------------------ | | | | 50| 55.3M|#define FRAC_BITS 31 | | ------------------ ------------------ 624| 55.3M|#endif // #ifdef PREFER_POINTERS 625| 55.3M| } 626| | 627| | /* update ringbuffer index */ 628| 864k| qmfs->v_index -= 128; 629| 864k| if (qmfs->v_index < 0) ------------------ | Branch (629:13): [True: 100k, False: 764k] ------------------ 630| 100k| qmfs->v_index = (1280 - 128); 631| 864k| } 632| 27.4k|} sbr_extension_data: 140| 12.8k|{ 141| 12.8k| uint8_t result = 0; 142| 12.8k| uint16_t num_align_bits = 0; 143| 12.8k| uint16_t num_sbr_bits1 = (uint16_t)faad_get_processed_bits(ld); 144| 12.8k| uint16_t num_sbr_bits2; 145| | 146| 12.8k| uint8_t saved_start_freq, saved_samplerate_mode; 147| 12.8k| uint8_t saved_stop_freq, saved_freq_scale; 148| 12.8k| uint8_t saved_alter_scale, saved_xover_band; 149| | 150| 12.8k|#if (defined(PS_DEC) || defined(DRM_PS)) 151| 12.8k| if (psResetFlag) ------------------ | Branch (151:9): [True: 3.94k, False: 8.95k] ------------------ 152| 3.94k| sbr->psResetFlag = psResetFlag; 153| 12.8k|#endif 154| | 155| 12.8k|#ifdef DRM 156| 12.8k| if (!sbr->Is_DRM_SBR) ------------------ | Branch (156:9): [True: 12.7k, False: 114] ------------------ 157| 12.7k|#endif 158| 12.7k| { 159| 12.7k| uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 160| 12.7k| DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type")); 161| | 162| 12.7k| if (bs_extension_type == EXT_SBR_DATA_CRC) ------------------ | | 44| 12.7k|#define EXT_SBR_DATA_CRC 14 ------------------ | Branch (162:13): [True: 9.09k, False: 3.68k] ------------------ 163| 9.09k| { 164| 9.09k| sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 165| 9.09k| DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); 166| 9.09k| } 167| 12.7k| } 168| | 169| | /* save old header values, in case the new ones are corrupted */ 170| 12.8k| saved_start_freq = sbr->bs_start_freq; 171| 12.8k| saved_samplerate_mode = sbr->bs_samplerate_mode; 172| 12.8k| saved_stop_freq = sbr->bs_stop_freq; 173| 12.8k| saved_freq_scale = sbr->bs_freq_scale; 174| 12.8k| saved_alter_scale = sbr->bs_alter_scale; 175| 12.8k| saved_xover_band = sbr->bs_xover_band; 176| | 177| 12.8k| sbr->bs_header_flag = faad_get1bit(ld 178| 12.8k| DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); 179| | 180| 12.8k| if (sbr->bs_header_flag) ------------------ | Branch (180:9): [True: 12.7k, False: 181] ------------------ 181| 12.7k| sbr_header(ld, sbr); 182| | 183| | /* Reset? */ 184| 12.8k| sbr_reset(sbr); 185| | 186| | /* first frame should have a header */ 187| | //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0)) 188| 12.8k| if (sbr->header_count != 0) ------------------ | Branch (188:9): [True: 12.7k, False: 154] ------------------ 189| 12.7k| { 190| 12.7k| if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) ------------------ | Branch (190:13): [True: 12.6k, False: 115] | Branch (190:28): [True: 90, False: 25] | Branch (190:51): [True: 0, False: 90] ------------------ 191| 12.6k| { 192| 12.6k| uint8_t rt = calc_sbr_tables(sbr, sbr->bs_start_freq, sbr->bs_stop_freq, 193| 12.6k| sbr->bs_samplerate_mode, sbr->bs_freq_scale, 194| 12.6k| sbr->bs_alter_scale, sbr->bs_xover_band); 195| | 196| | /* if an error occured with the new header values revert to the old ones */ 197| 12.6k| if (rt > 0) ------------------ | Branch (197:17): [True: 3.69k, False: 8.93k] ------------------ 198| 3.69k| { 199| 3.69k| result += calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq, 200| 3.69k| saved_samplerate_mode, saved_freq_scale, 201| 3.69k| saved_alter_scale, saved_xover_band); 202| 3.69k| } 203| 12.6k| } 204| | 205| 12.7k| if (result == 0) ------------------ | Branch (205:13): [True: 12.1k, False: 552] ------------------ 206| 12.1k| { 207| 12.1k| result = sbr_data(ld, sbr); 208| | 209| | /* sbr_data() returning an error means that there was an error in 210| | envelope_time_border_vector(). 211| | In this case the old time border vector is saved and all the previous 212| | data normally read after sbr_grid() is saved. 213| | */ 214| | /* to be on the safe side, calculate old sbr tables in case of error */ 215| 12.1k| if ((result > 0) && ------------------ | Branch (215:17): [True: 4.85k, False: 7.33k] ------------------ 216| 4.85k| (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))) ------------------ | Branch (216:18): [True: 4.82k, False: 29] | Branch (216:33): [True: 17, False: 12] | Branch (216:56): [True: 0, False: 17] ------------------ 217| 4.82k| { 218| 4.82k| result += calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq, 219| 4.82k| saved_samplerate_mode, saved_freq_scale, 220| 4.82k| saved_alter_scale, saved_xover_band); 221| 4.82k| } 222| | 223| | /* we should be able to safely set result to 0 now, */ 224| | /* but practise indicates this doesn't work well */ 225| 12.1k| } 226| 12.7k| } else { 227| 154| result = 1; 228| 154| } 229| | 230| 12.8k| num_sbr_bits2 = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits1; 231| | 232| | /* check if we read more bits then were available for sbr */ 233| 12.8k| if (8*cnt < num_sbr_bits2) ------------------ | Branch (233:9): [True: 7.00k, False: 5.89k] ------------------ 234| 7.00k| { 235| 7.00k| faad_resetbits(ld, num_sbr_bits1 + 8u * cnt); 236| 7.00k| num_sbr_bits2 = 8*cnt; 237| | 238| 7.00k|#ifdef PS_DEC 239| | /* turn off PS for the unfortunate case that we randomly read some 240| | * PS data that looks correct */ 241| 7.00k| sbr->ps_used = 0; 242| 7.00k|#endif 243| | 244| | /* Make sure it doesn't decode SBR in this frame, or we'll get glitches */ 245| 7.00k| return 1; 246| 7.00k| } 247| | 248| 5.89k|#ifdef DRM 249| 5.89k| if (!sbr->Is_DRM_SBR) ------------------ | Branch (249:9): [True: 5.77k, False: 114] ------------------ 250| 5.77k|#endif 251| 5.77k| { 252| | /* -4 does not apply, bs_extension_type is re-read in this function */ 253| 5.77k| num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits2; 254| | 255| 72.3k| while (num_align_bits > 7) ------------------ | Branch (255:16): [True: 66.5k, False: 5.77k] ------------------ 256| 66.5k| { 257| 66.5k| faad_getbits(ld, 8 258| 66.5k| DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits")); 259| 66.5k| num_align_bits -= 8; 260| 66.5k| } 261| 5.77k| faad_getbits(ld, num_align_bits 262| 5.77k| DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits")); 263| 5.77k| } 264| | 265| 5.89k| return result; 266| 12.8k|} sbr_syntax.c:sbr_reset: 69| 12.8k|{ 70| |#if 0 71| | printf("%d\n", sbr->bs_start_freq_prev); 72| | printf("%d\n", sbr->bs_stop_freq_prev); 73| | printf("%d\n", sbr->bs_freq_scale_prev); 74| | printf("%d\n", sbr->bs_alter_scale_prev); 75| | printf("%d\n", sbr->bs_xover_band_prev); 76| | printf("%d\n\n", sbr->bs_noise_bands_prev); 77| |#endif 78| | 79| | /* if these are different from the previous frame: Reset = 1 */ 80| 12.8k| if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) || ------------------ | Branch (80:9): [True: 12.7k, False: 175] ------------------ 81| 175| (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) || ------------------ | Branch (81:9): [True: 23, False: 152] ------------------ 82| 152| (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) || ------------------ | Branch (82:9): [True: 8, False: 144] ------------------ 83| 144| (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) || ------------------ | Branch (83:9): [True: 2, False: 142] ------------------ 84| 142| (sbr->bs_xover_band != sbr->bs_xover_band_prev) || ------------------ | Branch (84:9): [True: 24, False: 118] ------------------ 85| 118| (sbr->bs_noise_bands != sbr->bs_noise_bands_prev)) ------------------ | Branch (85:9): [True: 3, False: 115] ------------------ 86| 12.7k| { 87| 12.7k| sbr->Reset = 1; 88| 12.7k| } else { 89| 115| sbr->Reset = 0; 90| 115| } 91| | 92| 12.8k| sbr->bs_start_freq_prev = sbr->bs_start_freq; 93| 12.8k| sbr->bs_stop_freq_prev = sbr->bs_stop_freq; 94| 12.8k| sbr->bs_freq_scale_prev = sbr->bs_freq_scale; 95| 12.8k| sbr->bs_alter_scale_prev = sbr->bs_alter_scale; 96| 12.8k| sbr->bs_xover_band_prev = sbr->bs_xover_band; 97| 12.8k| sbr->bs_noise_bands_prev = sbr->bs_noise_bands; 98| 12.8k|} sbr_syntax.c:calc_sbr_tables: 103| 21.1k|{ 104| 21.1k| uint8_t result = 0; 105| 21.1k| uint8_t k2; 106| | 107| | /* calculate the Master Frequency Table */ 108| 21.1k| sbr->k0 = qmf_start_channel(start_freq, samplerate_mode, sbr->sample_rate); 109| 21.1k| k2 = qmf_stop_channel(stop_freq, sbr->sample_rate, sbr->k0); 110| | 111| | /* check k0 and k2 */ 112| 21.1k| if (sbr->sample_rate >= 48000) ------------------ | Branch (112:9): [True: 11.1k, False: 9.95k] ------------------ 113| 11.1k| { 114| 11.1k| if ((k2 - sbr->k0) > 32) ------------------ | Branch (114:13): [True: 514, False: 10.6k] ------------------ 115| 514| result += 1; 116| 11.1k| } else if (sbr->sample_rate <= 32000) { ------------------ | Branch (116:16): [True: 8.29k, False: 1.66k] ------------------ 117| 8.29k| if ((k2 - sbr->k0) > 48) ------------------ | Branch (117:13): [True: 61, False: 8.23k] ------------------ 118| 61| result += 1; 119| 8.29k| } else { /* (sbr->sample_rate == 44100) */ 120| 1.66k| if ((k2 - sbr->k0) > 45) ------------------ | Branch (120:13): [True: 49, False: 1.61k] ------------------ 121| 49| result += 1; 122| 1.66k| } 123| | 124| 21.1k| if (freq_scale == 0) ------------------ | Branch (124:9): [True: 1.73k, False: 19.4k] ------------------ 125| 1.73k| { 126| 1.73k| result += master_frequency_table_fs0(sbr, sbr->k0, k2, alter_scale); 127| 19.4k| } else { 128| 19.4k| result += master_frequency_table(sbr, sbr->k0, k2, freq_scale, alter_scale); 129| 19.4k| } 130| 21.1k| result += derived_frequency_table(sbr, xover_band, k2); 131| | 132| 21.1k| result = (result > 0) ? 1 : 0; ------------------ | Branch (132:14): [True: 6.55k, False: 14.6k] ------------------ 133| | 134| 21.1k| return result; 135| 21.1k|} sbr_syntax.c:sbr_header: 270| 12.7k|{ 271| 12.7k| uint8_t bs_header_extra_1, bs_header_extra_2; 272| | 273| 12.7k| sbr->header_count++; 274| | 275| 12.7k| sbr->bs_amp_res = faad_get1bit(ld 276| 12.7k| DEBUGVAR(1,203,"sbr_header(): bs_amp_res")); 277| | 278| | /* bs_start_freq and bs_stop_freq must define a fequency band that does 279| | not exceed 48 channels */ 280| 12.7k| sbr->bs_start_freq = (uint8_t)faad_getbits(ld, 4 281| 12.7k| DEBUGVAR(1,204,"sbr_header(): bs_start_freq")); 282| 12.7k| sbr->bs_stop_freq = (uint8_t)faad_getbits(ld, 4 283| 12.7k| DEBUGVAR(1,205,"sbr_header(): bs_stop_freq")); 284| 12.7k| sbr->bs_xover_band = (uint8_t)faad_getbits(ld, 3 285| 12.7k| DEBUGVAR(1,206,"sbr_header(): bs_xover_band")); 286| 12.7k| faad_getbits(ld, 2 287| 12.7k| DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr")); 288| 12.7k| bs_header_extra_1 = (uint8_t)faad_get1bit(ld 289| 12.7k| DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1")); 290| 12.7k| bs_header_extra_2 = (uint8_t)faad_get1bit(ld 291| 12.7k| DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2")); 292| | 293| 12.7k| if (bs_header_extra_1) ------------------ | Branch (293:9): [True: 5.63k, False: 7.08k] ------------------ 294| 5.63k| { 295| 5.63k| sbr->bs_freq_scale = (uint8_t)faad_getbits(ld, 2 296| 5.63k| DEBUGVAR(1,211,"sbr_header(): bs_freq_scale")); 297| 5.63k| sbr->bs_alter_scale = (uint8_t)faad_get1bit(ld 298| 5.63k| DEBUGVAR(1,212,"sbr_header(): bs_alter_scale")); 299| 5.63k| sbr->bs_noise_bands = (uint8_t)faad_getbits(ld, 2 300| 5.63k| DEBUGVAR(1,213,"sbr_header(): bs_noise_bands")); 301| 7.08k| } else { 302| | /* Default values */ 303| 7.08k| sbr->bs_freq_scale = 2; 304| 7.08k| sbr->bs_alter_scale = 1; 305| 7.08k| sbr->bs_noise_bands = 2; 306| 7.08k| } 307| | 308| 12.7k| if (bs_header_extra_2) ------------------ | Branch (308:9): [True: 5.99k, False: 6.72k] ------------------ 309| 5.99k| { 310| 5.99k| sbr->bs_limiter_bands = (uint8_t)faad_getbits(ld, 2 311| 5.99k| DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands")); 312| 5.99k| sbr->bs_limiter_gains = (uint8_t)faad_getbits(ld, 2 313| 5.99k| DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains")); 314| 5.99k| sbr->bs_interpol_freq = (uint8_t)faad_get1bit(ld 315| 5.99k| DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq")); 316| 5.99k| sbr->bs_smoothing_mode = (uint8_t)faad_get1bit(ld 317| 5.99k| DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode")); 318| 6.72k| } else { 319| | /* Default values */ 320| 6.72k| sbr->bs_limiter_bands = 2; 321| 6.72k| sbr->bs_limiter_gains = 2; 322| 6.72k| sbr->bs_interpol_freq = 1; 323| 6.72k| sbr->bs_smoothing_mode = 1; 324| 6.72k| } 325| | 326| |#if 0 327| | /* print the header to screen */ 328| | printf("bs_amp_res: %d\n", sbr->bs_amp_res); 329| | printf("bs_start_freq: %d\n", sbr->bs_start_freq); 330| | printf("bs_stop_freq: %d\n", sbr->bs_stop_freq); 331| | printf("bs_xover_band: %d\n", sbr->bs_xover_band); 332| | if (bs_header_extra_1) 333| | { 334| | printf("bs_freq_scale: %d\n", sbr->bs_freq_scale); 335| | printf("bs_alter_scale: %d\n", sbr->bs_alter_scale); 336| | printf("bs_noise_bands: %d\n", sbr->bs_noise_bands); 337| | } 338| | if (bs_header_extra_2) 339| | { 340| | printf("bs_limiter_bands: %d\n", sbr->bs_limiter_bands); 341| | printf("bs_limiter_gains: %d\n", sbr->bs_limiter_gains); 342| | printf("bs_interpol_freq: %d\n", sbr->bs_interpol_freq); 343| | printf("bs_smoothing_mode: %d\n", sbr->bs_smoothing_mode); 344| | } 345| | printf("\n"); 346| |#endif 347| 12.7k|} sbr_syntax.c:sbr_data: 351| 12.1k|{ 352| 12.1k| uint8_t result; 353| |#if 0 354| | sbr->bs_samplerate_mode = faad_get1bit(ld 355| | DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode")); 356| |#endif 357| | 358| 12.1k| sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1; ------------------ | Branch (358:17): [True: 12.1k, False: 0] ------------------ 359| | 360| 12.1k| switch (sbr->id_aac) ------------------ | Branch (360:13): [True: 12.1k, False: 1] ------------------ 361| 12.1k| { 362| 7.57k| case ID_SCE: ------------------ | | 86| 7.57k|#define ID_SCE 0x0 ------------------ | Branch (362:5): [True: 7.57k, False: 4.62k] ------------------ 363| 7.57k| if ((result = sbr_single_channel_element(ld, sbr)) > 0) ------------------ | Branch (363:7): [True: 4.32k, False: 3.24k] ------------------ 364| 4.32k| return result; 365| 3.24k| break; 366| 4.62k| case ID_CPE: ------------------ | | 87| 4.62k|#define ID_CPE 0x1 ------------------ | Branch (366:5): [True: 4.62k, False: 7.57k] ------------------ 367| 4.62k| if ((result = sbr_channel_pair_element(ld, sbr)) > 0) ------------------ | Branch (367:7): [True: 529, False: 4.09k] ------------------ 368| 529| return result; 369| 4.09k| break; 370| 12.1k| } 371| | 372| 7.33k| return 0; 373| 12.1k|} sbr_syntax.c:sbr_single_channel_element: 377| 7.57k|{ 378| 7.57k| uint8_t result; 379| | 380| 7.57k| if (faad_get1bit(ld ------------------ | Branch (380:9): [True: 1.61k, False: 5.95k] ------------------ 381| 7.57k| DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra"))) 382| 1.61k| { 383| 1.61k| faad_getbits(ld, 4 384| 1.61k| DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data")); 385| 1.61k| } 386| | 387| 7.57k|#ifdef DRM 388| | /* bs_coupling, from sbr_channel_pair_base_element(bs_amp_res) */ 389| 7.57k| if (sbr->Is_DRM_SBR) ------------------ | Branch (389:9): [True: 104, False: 7.46k] ------------------ 390| 104| { 391| 104| faad_get1bit(ld); 392| 104| } 393| 7.57k|#endif 394| | 395| 7.57k| if ((result = sbr_grid(ld, sbr, 0)) > 0) ------------------ | Branch (395:9): [True: 319, False: 7.25k] ------------------ 396| 319| return result; 397| | 398| 7.25k| sbr_dtdf(ld, sbr, 0); 399| 7.25k| invf_mode(ld, sbr, 0); 400| 7.25k| sbr_envelope(ld, sbr, 0); 401| 7.25k| sbr_noise(ld, sbr, 0); 402| | 403| |#ifndef FIXED_POINT 404| | envelope_noise_dequantisation(sbr, 0); 405| |#endif 406| | 407| 7.25k| memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); 408| | 409| 7.25k| sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld 410| 7.25k| DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); 411| 7.25k| if (sbr->bs_add_harmonic_flag[0]) ------------------ | Branch (411:9): [True: 2.67k, False: 4.57k] ------------------ 412| 2.67k| sinusoidal_coding(ld, sbr, 0); 413| | 414| 7.25k| sbr->bs_extended_data = faad_get1bit(ld 415| 7.25k| DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); 416| | 417| 7.25k| if (sbr->bs_extended_data) ------------------ | Branch (417:9): [True: 5.10k, False: 2.14k] ------------------ 418| 5.10k| { 419| 5.10k| uint16_t nr_bits_left; 420| 5.10k|#if (defined(PS_DEC) || defined(DRM_PS)) 421| 5.10k| uint8_t ps_ext_read = 0; 422| 5.10k|#endif 423| 5.10k| uint16_t cnt = (uint16_t)faad_getbits(ld, 4 424| 5.10k| DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size")); 425| 5.10k| if (cnt == 15) ------------------ | Branch (425:13): [True: 811, False: 4.29k] ------------------ 426| 811| { 427| 811| cnt += (uint16_t)faad_getbits(ld, 8 428| 811| DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count")); 429| 811| } 430| | 431| 5.10k| nr_bits_left = 8 * cnt; 432| 11.1k| while (nr_bits_left > 7) ------------------ | Branch (432:16): [True: 10.0k, False: 1.09k] ------------------ 433| 10.0k| { 434| 10.0k| uint16_t tmp_nr_bits = 0; 435| | 436| 10.0k| sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 437| 10.0k| DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); 438| 10.0k| tmp_nr_bits += 2; 439| | 440| | /* allow only 1 PS extension element per extension data */ 441| 10.0k|#if (defined(PS_DEC) || defined(DRM_PS)) 442| 10.0k|#if (defined(PS_DEC) && defined(DRM_PS)) 443| 10.0k| if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO) ------------------ | | 40| 20.0k|#define EXTENSION_ID_PS 2 ------------------ if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO) ------------------ | | 40| 5.54k|#define DRM_PARAMETRIC_STEREO 0 ------------------ | Branch (443:17): [True: 4.47k, False: 5.54k] | Branch (443:60): [True: 2.20k, False: 3.34k] ------------------ 444| |#else 445| |#ifdef PS_DEC 446| | if (sbr->bs_extension_id == EXTENSION_ID_PS) 447| |#else 448| |#ifdef DRM_PS 449| | if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO) 450| |#endif 451| |#endif 452| |#endif 453| 6.67k| { 454| 6.67k| if (ps_ext_read == 0) ------------------ | Branch (454:21): [True: 4.93k, False: 1.73k] ------------------ 455| 4.93k| { 456| 4.93k| ps_ext_read = 1; 457| 4.93k| } else { 458| | /* to be safe make it 3, will switch to "default" 459| | * in sbr_extension() */ 460| 1.73k|#ifdef DRM 461| 1.73k| return 1; 462| |#else 463| | sbr->bs_extension_id = 3; 464| |#endif 465| 1.73k| } 466| 6.67k| } 467| 8.28k|#endif 468| | 469| 8.28k| tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); 470| | 471| | /* check if the data read is bigger than the number of available bits */ 472| 8.28k| if (tmp_nr_bits > nr_bits_left) ------------------ | Branch (472:17): [True: 2.27k, False: 6.01k] ------------------ 473| 2.27k| return 1; 474| | 475| 6.01k| nr_bits_left -= tmp_nr_bits; 476| 6.01k| } 477| | 478| | /* Corrigendum */ 479| 1.09k| if (nr_bits_left > 0) ------------------ | Branch (479:13): [True: 926, False: 173] ------------------ 480| 926| { 481| 926| faad_getbits(ld, nr_bits_left 482| 926| DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left")); 483| 926| } 484| 1.09k| } 485| | 486| 3.24k| return 0; 487| 7.25k|} sbr_syntax.c:sbr_grid: 660| 14.6k|{ 661| 14.6k| uint8_t i, j, env, rel, result; 662| 14.6k| uint8_t bs_abs_bord, bs_abs_bord_1; 663| 14.6k| uint8_t bs_num_env = 0; 664| 14.6k| uint8_t saved_L_E = sbr->L_E[ch]; 665| 14.6k| uint8_t saved_L_Q = sbr->L_Q[ch]; 666| 14.6k| uint8_t saved_frame_class = sbr->bs_frame_class[ch]; 667| | 668| 14.6k| sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2 669| 14.6k| DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); 670| | 671| 14.6k| switch (sbr->bs_frame_class[ch]) ------------------ | Branch (671:13): [True: 14.6k, False: 0] ------------------ 672| 14.6k| { 673| 5.51k| case FIXFIX: ------------------ | | 46| 5.51k|#define FIXFIX 0 ------------------ | Branch (673:5): [True: 5.51k, False: 9.17k] ------------------ 674| 5.51k| i = (uint8_t)faad_getbits(ld, 2 675| 5.51k| DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw")); 676| | 677| 5.51k| bs_num_env = min(1u << i, 5u); ------------------ | | 60| 5.51k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 5.30k, False: 204] | | ------------------ ------------------ 678| | 679| 5.51k| i = (uint8_t)faad_get1bit(ld 680| 5.51k| DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag")); 681| 12.4k| for (env = 0; env < bs_num_env; env++) ------------------ | Branch (681:23): [True: 6.95k, False: 5.51k] ------------------ 682| 6.95k| sbr->f[ch][env] = i; 683| | 684| 5.51k| sbr->abs_bord_lead[ch] = 0; 685| 5.51k| sbr->abs_bord_trail[ch] = sbr->numTimeSlots; 686| 5.51k| sbr->n_rel_lead[ch] = bs_num_env - 1; 687| 5.51k| sbr->n_rel_trail[ch] = 0; 688| 5.51k| break; 689| | 690| 3.31k| case FIXVAR: ------------------ | | 47| 3.31k|#define FIXVAR 1 ------------------ | Branch (690:5): [True: 3.31k, False: 11.3k] ------------------ 691| 3.31k| bs_abs_bord = (uint8_t)faad_getbits(ld, 2 692| 3.31k| DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots; 693| 3.31k| bs_num_env = (uint8_t)faad_getbits(ld, 2 694| 3.31k| DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1; 695| | 696| 6.14k| for (rel = 0; rel < bs_num_env-1; rel++) ------------------ | Branch (696:23): [True: 2.82k, False: 3.31k] ------------------ 697| 2.82k| { 698| 2.82k| sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 699| 2.82k| DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2; 700| 2.82k| } 701| 3.31k| j = bs_num_env; 702| 3.31k| i = sbr_log2(j + 1); 703| 3.31k| sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i 704| 3.31k| DEBUGVAR(1,254,"sbr_grid(): bs_pointer")); 705| 3.31k| sbr->bs_pointer[ch] = min(sbr->bs_pointer[ch], j); ------------------ | | 60| 3.31k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 1.56k, False: 1.75k] | | ------------------ ------------------ 706| | 707| 9.46k| for (env = 0; env < bs_num_env; env++) ------------------ | Branch (707:23): [True: 6.14k, False: 3.31k] ------------------ 708| 6.14k| { 709| 6.14k| sbr->f[ch][bs_num_env - env - 1] = (uint8_t)faad_get1bit(ld 710| 6.14k| DEBUGVAR(1,255,"sbr_grid(): bs_freq_res")); 711| 6.14k| } 712| | 713| 3.31k| sbr->abs_bord_lead[ch] = 0; 714| 3.31k| sbr->abs_bord_trail[ch] = bs_abs_bord; 715| 3.31k| sbr->n_rel_lead[ch] = 0; 716| 3.31k| sbr->n_rel_trail[ch] = bs_num_env - 1; 717| 3.31k| break; 718| | 719| 3.29k| case VARFIX: ------------------ | | 48| 3.29k|#define VARFIX 2 ------------------ | Branch (719:5): [True: 3.29k, False: 11.3k] ------------------ 720| 3.29k| bs_abs_bord = (uint8_t)faad_getbits(ld, 2 721| 3.29k| DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord")); 722| 3.29k| bs_num_env = (uint8_t)faad_getbits(ld, 2 723| 3.29k| DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1; 724| | 725| 8.16k| for (rel = 0; rel < bs_num_env-1; rel++) ------------------ | Branch (725:23): [True: 4.86k, False: 3.29k] ------------------ 726| 4.86k| { 727| 4.86k| sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 728| 4.86k| DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2; 729| 4.86k| } 730| 3.29k| j = bs_num_env; 731| 3.29k| i = sbr_log2(j + 1); 732| 3.29k| sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i 733| 3.29k| DEBUGVAR(1,259,"sbr_grid(): bs_pointer")); 734| 3.29k| sbr->bs_pointer[ch] = min(sbr->bs_pointer[ch], j); ------------------ | | 60| 3.29k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 2.58k, False: 716] | | ------------------ ------------------ 735| | 736| 11.4k| for (env = 0; env < bs_num_env; env++) ------------------ | Branch (736:23): [True: 8.16k, False: 3.29k] ------------------ 737| 8.16k| { 738| 8.16k| sbr->f[ch][env] = (uint8_t)faad_get1bit(ld 739| 8.16k| DEBUGVAR(1,260,"sbr_grid(): bs_freq_res")); 740| 8.16k| } 741| | 742| 3.29k| sbr->abs_bord_lead[ch] = bs_abs_bord; 743| 3.29k| sbr->abs_bord_trail[ch] = sbr->numTimeSlots; 744| 3.29k| sbr->n_rel_lead[ch] = bs_num_env - 1; 745| 3.29k| sbr->n_rel_trail[ch] = 0; 746| 3.29k| break; 747| | 748| 2.55k| case VARVAR: ------------------ | | 49| 2.55k|#define VARVAR 3 ------------------ | Branch (748:5): [True: 2.55k, False: 12.1k] ------------------ 749| 2.55k| bs_abs_bord = (uint8_t)faad_getbits(ld, 2 750| 2.55k| DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0")); 751| 2.55k| bs_abs_bord_1 = (uint8_t)faad_getbits(ld, 2 752| 2.55k| DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots; 753| 2.55k| sbr->bs_num_rel_0[ch] = (uint8_t)faad_getbits(ld, 2 754| 2.55k| DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0")); 755| 2.55k| sbr->bs_num_rel_1[ch] = (uint8_t)faad_getbits(ld, 2 756| 2.55k| DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1")); 757| | 758| 2.55k| bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1); ------------------ | | 60| 2.55k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 1.12k, False: 1.43k] | | ------------------ ------------------ 759| | 760| 7.48k| for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++) ------------------ | Branch (760:23): [True: 4.93k, False: 2.55k] ------------------ 761| 4.93k| { 762| 4.93k| sbr->bs_rel_bord_0[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 763| 4.93k| DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2; 764| 4.93k| } 765| 7.51k| for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++) ------------------ | Branch (765:22): [True: 4.95k, False: 2.55k] ------------------ 766| 4.95k| { 767| 4.95k| sbr->bs_rel_bord_1[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 768| 4.95k| DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2; 769| 4.95k| } 770| 2.55k| j = sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1; 771| 2.55k| i = sbr_log2(j + 1); 772| 2.55k| sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i 773| 2.55k| DEBUGVAR(1,267,"sbr_grid(): bs_pointer")); 774| 2.55k| sbr->bs_pointer[ch] = min(sbr->bs_pointer[ch], j); ------------------ | | 60| 2.55k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 2.28k, False: 274] | | ------------------ ------------------ 775| | 776| 13.1k| for (env = 0; env < bs_num_env; env++) ------------------ | Branch (776:23): [True: 10.6k, False: 2.55k] ------------------ 777| 10.6k| { 778| 10.6k| sbr->f[ch][env] = (uint8_t)faad_get1bit(ld 779| 10.6k| DEBUGVAR(1,268,"sbr_grid(): bs_freq_res")); 780| 10.6k| } 781| | 782| 2.55k| sbr->abs_bord_lead[ch] = bs_abs_bord; 783| 2.55k| sbr->abs_bord_trail[ch] = bs_abs_bord_1; 784| 2.55k| sbr->n_rel_lead[ch] = sbr->bs_num_rel_0[ch]; 785| 2.55k| sbr->n_rel_trail[ch] = sbr->bs_num_rel_1[ch]; 786| 2.55k| break; 787| 14.6k| } 788| | 789| 14.6k| if (sbr->bs_frame_class[ch] == VARVAR) ------------------ | | 49| 14.6k|#define VARVAR 3 ------------------ | Branch (789:9): [True: 2.55k, False: 12.1k] ------------------ 790| 2.55k| sbr->L_E[ch] = min(bs_num_env, 5); ------------------ | | 60| 2.55k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 1.08k, False: 1.47k] | | ------------------ ------------------ 791| 12.1k| else 792| 12.1k| sbr->L_E[ch] = min(bs_num_env, 4); ------------------ | | 60| 12.1k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 11.0k, False: 1.06k] | | ------------------ ------------------ 793| | 794| 14.6k| if (sbr->L_E[ch] <= 0) ------------------ | Branch (794:9): [True: 0, False: 14.6k] ------------------ 795| 0| return 1; 796| | 797| 14.6k| if (sbr->L_E[ch] > 1) ------------------ | Branch (797:9): [True: 6.75k, False: 7.93k] ------------------ 798| 6.75k| sbr->L_Q[ch] = 2; 799| 7.93k| else 800| 7.93k| sbr->L_Q[ch] = 1; 801| | 802| | /* TODO: this code can probably be integrated into the code above! */ 803| 14.6k| if ((result = envelope_time_border_vector(sbr, ch)) > 0) ------------------ | Branch (803:9): [True: 462, False: 14.2k] ------------------ 804| 462| { 805| 462| sbr->bs_frame_class[ch] = saved_frame_class; 806| 462| sbr->L_E[ch] = saved_L_E; 807| 462| sbr->L_Q[ch] = saved_L_Q; 808| 462| return result; 809| 462| } 810| 14.2k| noise_floor_time_border_vector(sbr, ch); 811| | 812| |#if 0 813| | for (env = 0; env < bs_num_env; env++) 814| | { 815| | printf("freq_res[ch:%d][env:%d]: %d\n", ch, env, sbr->f[ch][env]); 816| | } 817| |#endif 818| | 819| 14.2k| return 0; 820| 14.6k|} sbr_syntax.c:sbr_log2: 649| 9.17k|{ 650| 9.17k| uint8_t log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 }; 651| 9.17k| if (val < 10 && val >= 0) ------------------ | Branch (651:9): [True: 9.17k, False: 0] | Branch (651:21): [True: 9.17k, False: 0] ------------------ 652| 9.17k| return log2tab[val]; 653| 0| else 654| 0| return 0; 655| 9.17k|} sbr_syntax.c:sbr_dtdf: 824| 16.2k|{ 825| 16.2k| uint8_t i; 826| | 827| 51.4k| for (i = 0; i < sbr->L_E[ch]; i++) ------------------ | Branch (827:17): [True: 35.2k, False: 16.2k] ------------------ 828| 35.2k| { 829| 35.2k| sbr->bs_df_env[ch][i] = faad_get1bit(ld 830| 35.2k| DEBUGVAR(1,269,"sbr_dtdf(): bs_df_env")); 831| 35.2k| } 832| | 833| 40.2k| for (i = 0; i < sbr->L_Q[ch]; i++) ------------------ | Branch (833:17): [True: 24.0k, False: 16.2k] ------------------ 834| 24.0k| { 835| 24.0k| sbr->bs_df_noise[ch][i] = faad_get1bit(ld 836| 24.0k| DEBUGVAR(1,270,"sbr_dtdf(): bs_df_noise")); 837| 24.0k| } 838| 16.2k|} sbr_syntax.c:invf_mode: 842| 14.1k|{ 843| 14.1k| uint8_t n; 844| | 845| 40.0k| for (n = 0; n < sbr->N_Q; n++) ------------------ | Branch (845:17): [True: 25.9k, False: 14.1k] ------------------ 846| 25.9k| { 847| 25.9k| sbr->bs_invf_mode[ch][n] = (uint8_t)faad_getbits(ld, 2 848| 25.9k| DEBUGVAR(1,271,"invf_mode(): bs_invf_mode")); 849| 25.9k| } 850| 14.1k|} sbr_syntax.c:sinusoidal_coding: 910| 6.32k|{ 911| 6.32k| uint8_t n; 912| | 913| 62.9k| for (n = 0; n < sbr->N_high; n++) ------------------ | Branch (913:17): [True: 56.6k, False: 6.32k] ------------------ 914| 56.6k| { 915| 56.6k| sbr->bs_add_harmonic[ch][n] = faad_get1bit(ld 916| 56.6k| DEBUGVAR(1,278,"sinusoidal_coding(): bs_add_harmonic")); 917| 56.6k| } 918| 6.32k|} sbr_syntax.c:sbr_extension: 854| 322k|{ 855| 322k|#ifdef PS_DEC 856| 322k| uint8_t header; 857| 322k| uint16_t ret; 858| 322k|#endif 859| 322k| (void)num_bits_left; /* TODO: remove or actually use parameter. */ 860| | 861| 322k| switch (bs_extension_id) 862| 322k| { 863| 0|#ifdef PS_DEC 864| 27.2k| case EXTENSION_ID_PS: ------------------ | | 40| 27.2k|#define EXTENSION_ID_PS 2 ------------------ | Branch (864:5): [True: 27.2k, False: 295k] ------------------ 865| 27.2k| if (!sbr->ps) ------------------ | Branch (865:13): [True: 5.31k, False: 21.9k] ------------------ 866| 5.31k| { 867| 5.31k| sbr->ps = ps_init(get_sr_index(sbr->sample_rate), sbr->numTimeSlotsRate); 868| 5.31k| } 869| 27.2k| if (sbr->psResetFlag) ------------------ | Branch (869:13): [True: 6.25k, False: 21.0k] ------------------ 870| 6.25k| { 871| 6.25k| sbr->ps->header_read = 0; 872| 6.25k| } 873| 27.2k| ret = ps_data(sbr->ps, ld, &header); 874| | 875| | /* enable PS if and only if: a header has been decoded */ 876| 27.2k| if (sbr->ps_used == 0 && header == 1) ------------------ | Branch (876:13): [True: 10.3k, False: 16.9k] | Branch (876:34): [True: 4.83k, False: 5.46k] ------------------ 877| 4.83k| { 878| 4.83k| sbr->ps_used = 1; 879| 4.83k| } 880| | 881| 27.2k| if (header == 1) ------------------ | Branch (881:13): [True: 14.0k, False: 13.2k] ------------------ 882| 14.0k| { 883| 14.0k| sbr->psResetFlag = 0; 884| 14.0k| } 885| | 886| 27.2k| return ret; 887| 0|#endif 888| 0|#ifdef DRM_PS 889| 250k| case DRM_PARAMETRIC_STEREO: ------------------ | | 40| 250k|#define DRM_PARAMETRIC_STEREO 0 ------------------ | Branch (889:5): [True: 250k, False: 72.3k] ------------------ 890| | /* If not expected then only decode but do not expose. */ 891| 250k| if (sbr->Is_DRM_SBR) ------------------ | Branch (891:13): [True: 63, False: 250k] ------------------ 892| 63| { 893| 63| sbr->ps_used = 1; 894| 63| } 895| 250k| if (!sbr->drm_ps) ------------------ | Branch (895:13): [True: 2.23k, False: 248k] ------------------ 896| 2.23k| { 897| 2.23k| sbr->drm_ps = drm_ps_init(); 898| 2.23k| } 899| 250k| return drm_ps_data(sbr->drm_ps, ld); 900| 0|#endif 901| 45.0k| default: ------------------ | Branch (901:5): [True: 45.0k, False: 277k] ------------------ 902| 45.0k| sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6 903| 45.0k| DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); 904| 45.0k| return 6; 905| 322k| } 906| 322k|} sbr_syntax.c:sbr_channel_pair_element: 491| 4.62k|{ 492| 4.62k| uint8_t n, result; 493| | 494| 4.62k| if (faad_get1bit(ld ------------------ | Branch (494:9): [True: 2.43k, False: 2.18k] ------------------ 495| 4.62k| DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra"))) 496| 2.43k| { 497| 2.43k| faad_getbits(ld, 4 498| 2.43k| DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); 499| 2.43k| faad_getbits(ld, 4 500| 2.43k| DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); 501| 2.43k| } 502| | 503| 4.62k| sbr->bs_coupling = faad_get1bit(ld 504| 4.62k| DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling")); 505| | 506| 4.62k| if (sbr->bs_coupling) ------------------ | Branch (506:9): [True: 2.08k, False: 2.53k] ------------------ 507| 2.08k| { 508| 2.08k| if ((result = sbr_grid(ld, sbr, 0)) > 0) ------------------ | Branch (508:13): [True: 63, False: 2.02k] ------------------ 509| 63| return result; 510| | 511| | /* need to copy some data from left to right */ 512| 2.02k| sbr->bs_frame_class[1] = sbr->bs_frame_class[0]; 513| 2.02k| sbr->L_E[1] = sbr->L_E[0]; 514| 2.02k| sbr->L_Q[1] = sbr->L_Q[0]; 515| 2.02k| sbr->bs_pointer[1] = sbr->bs_pointer[0]; 516| | 517| 9.73k| for (n = 0; n <= sbr->L_E[0]; n++) ------------------ | Branch (517:21): [True: 7.71k, False: 2.02k] ------------------ 518| 7.71k| { 519| 7.71k| sbr->t_E[1][n] = sbr->t_E[0][n]; 520| 7.71k| sbr->f[1][n] = sbr->f[0][n]; 521| 7.71k| } 522| 7.60k| for (n = 0; n <= sbr->L_Q[0]; n++) ------------------ | Branch (522:21): [True: 5.58k, False: 2.02k] ------------------ 523| 5.58k| sbr->t_Q[1][n] = sbr->t_Q[0][n]; 524| | 525| 2.02k| sbr_dtdf(ld, sbr, 0); 526| 2.02k| sbr_dtdf(ld, sbr, 1); 527| 2.02k| invf_mode(ld, sbr, 0); 528| | 529| | /* more copying */ 530| 6.58k| for (n = 0; n < sbr->N_Q; n++) ------------------ | Branch (530:21): [True: 4.56k, False: 2.02k] ------------------ 531| 4.56k| sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n]; 532| | 533| 2.02k| sbr_envelope(ld, sbr, 0); 534| 2.02k| sbr_noise(ld, sbr, 0); 535| 2.02k| sbr_envelope(ld, sbr, 1); 536| 2.02k| sbr_noise(ld, sbr, 1); 537| | 538| 2.02k| memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); 539| 2.02k| memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); 540| | 541| 2.02k| sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld 542| 2.02k| DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); 543| 2.02k| if (sbr->bs_add_harmonic_flag[0]) ------------------ | Branch (543:13): [True: 470, False: 1.55k] ------------------ 544| 470| sinusoidal_coding(ld, sbr, 0); 545| | 546| 2.02k| sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld 547| 2.02k| DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); 548| 2.02k| if (sbr->bs_add_harmonic_flag[1]) ------------------ | Branch (548:13): [True: 544, False: 1.47k] ------------------ 549| 544| sinusoidal_coding(ld, sbr, 1); 550| 2.53k| } else { 551| 2.53k| uint8_t saved_t_E[6] = {0}, saved_t_Q[3] = {0}; 552| 2.53k| uint8_t saved_L_E = sbr->L_E[0]; 553| 2.53k| uint8_t saved_L_Q = sbr->L_Q[0]; 554| 2.53k| uint8_t saved_frame_class = sbr->bs_frame_class[0]; 555| | 556| 2.94k| for (n = 0; n < saved_L_E; n++) ------------------ | Branch (556:21): [True: 406, False: 2.53k] ------------------ 557| 406| saved_t_E[n] = sbr->t_E[0][n]; 558| 2.76k| for (n = 0; n < saved_L_Q; n++) ------------------ | Branch (558:21): [True: 227, False: 2.53k] ------------------ 559| 227| saved_t_Q[n] = sbr->t_Q[0][n]; 560| | 561| 2.53k| if ((result = sbr_grid(ld, sbr, 0)) > 0) ------------------ | Branch (561:13): [True: 42, False: 2.49k] ------------------ 562| 42| return result; 563| 2.49k| if ((result = sbr_grid(ld, sbr, 1)) > 0) ------------------ | Branch (563:13): [True: 38, False: 2.45k] ------------------ 564| 38| { 565| | /* restore first channel data as well */ 566| 38| sbr->bs_frame_class[0] = saved_frame_class; 567| 38| sbr->L_E[0] = saved_L_E; 568| 38| sbr->L_Q[0] = saved_L_Q; 569| 266| for (n = 0; n < 6; n++) ------------------ | Branch (569:25): [True: 228, False: 38] ------------------ 570| 228| sbr->t_E[0][n] = saved_t_E[n]; 571| 152| for (n = 0; n < 3; n++) ------------------ | Branch (571:25): [True: 114, False: 38] ------------------ 572| 114| sbr->t_Q[0][n] = saved_t_Q[n]; 573| | 574| 38| return result; 575| 38| } 576| 2.45k| sbr_dtdf(ld, sbr, 0); 577| 2.45k| sbr_dtdf(ld, sbr, 1); 578| 2.45k| invf_mode(ld, sbr, 0); 579| 2.45k| invf_mode(ld, sbr, 1); 580| 2.45k| sbr_envelope(ld, sbr, 0); 581| 2.45k| sbr_envelope(ld, sbr, 1); 582| 2.45k| sbr_noise(ld, sbr, 0); 583| 2.45k| sbr_noise(ld, sbr, 1); 584| | 585| 2.45k| memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); 586| 2.45k| memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); 587| | 588| 2.45k| sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld 589| 2.45k| DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); 590| 2.45k| if (sbr->bs_add_harmonic_flag[0]) ------------------ | Branch (590:13): [True: 1.40k, False: 1.05k] ------------------ 591| 1.40k| sinusoidal_coding(ld, sbr, 0); 592| | 593| 2.45k| sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld 594| 2.45k| DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); 595| 2.45k| if (sbr->bs_add_harmonic_flag[1]) ------------------ | Branch (595:13): [True: 1.23k, False: 1.22k] ------------------ 596| 1.23k| sinusoidal_coding(ld, sbr, 1); 597| 2.45k| } 598| |#ifndef FIXED_POINT 599| | envelope_noise_dequantisation(sbr, 0); 600| | envelope_noise_dequantisation(sbr, 1); 601| | 602| | if (sbr->bs_coupling) 603| | unmap_envelope_noise(sbr); 604| |#endif 605| | 606| 4.47k| sbr->bs_extended_data = faad_get1bit(ld 607| 4.47k| DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); 608| 4.47k| if (sbr->bs_extended_data) ------------------ | Branch (608:9): [True: 1.96k, False: 2.50k] ------------------ 609| 1.96k| { 610| 1.96k| uint16_t nr_bits_left; 611| 1.96k| uint16_t cnt = (uint16_t)faad_getbits(ld, 4 612| 1.96k| DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size")); 613| 1.96k| if (cnt == 15) ------------------ | Branch (613:13): [True: 1.25k, False: 718] ------------------ 614| 1.25k| { 615| 1.25k| cnt += (uint16_t)faad_getbits(ld, 8 616| 1.25k| DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count")); 617| 1.25k| } 618| | 619| 1.96k| nr_bits_left = 8 * cnt; 620| 316k| while (nr_bits_left > 7) ------------------ | Branch (620:16): [True: 314k, False: 1.58k] ------------------ 621| 314k| { 622| 314k| uint16_t tmp_nr_bits = 0; 623| | 624| 314k| sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 625| 314k| DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); 626| 314k| tmp_nr_bits += 2; 627| 314k| tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); 628| | 629| | /* check if the data read is bigger than the number of available bits */ 630| 314k| if (tmp_nr_bits > nr_bits_left) ------------------ | Branch (630:17): [True: 386, False: 314k] ------------------ 631| 386| return 1; 632| | 633| 314k| nr_bits_left -= tmp_nr_bits; 634| 314k| } 635| | 636| | /* Corrigendum */ 637| 1.58k| if (nr_bits_left > 0) ------------------ | Branch (637:13): [True: 1.22k, False: 356] ------------------ 638| 1.22k| { 639| 1.22k| faad_getbits(ld, nr_bits_left 640| 1.22k| DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left")); 641| 1.22k| } 642| 1.58k| } 643| | 644| 4.09k| return 0; 645| 4.47k|} envelope_time_border_vector: 55| 14.6k|{ 56| 14.6k| uint8_t l, border, temp, trail; 57| 14.6k| uint8_t t_E_temp[6] = {0}; 58| | 59| 14.6k| trail = sbr->abs_bord_trail[ch]; 60| 14.6k| t_E_temp[0] = sbr->rate * sbr->abs_bord_lead[ch]; 61| 14.6k| t_E_temp[sbr->L_E[ch]] = sbr->rate * trail; 62| | 63| 14.6k| switch (sbr->bs_frame_class[ch]) ------------------ | Branch (63:13): [True: 14.6k, False: 0] ------------------ 64| 14.6k| { 65| 5.51k| case FIXFIX: ------------------ | | 46| 5.51k|#define FIXFIX 0 ------------------ | Branch (65:5): [True: 5.51k, False: 9.17k] ------------------ 66| 5.51k| switch (sbr->L_E[ch]) 67| 5.51k| { 68| 262| case 4: ------------------ | Branch (68:9): [True: 262, False: 5.25k] ------------------ 69| 262| temp = (sbr->numTimeSlots / 4); 70| 262| t_E_temp[3] = sbr->rate * 3 * temp; 71| 262| t_E_temp[2] = sbr->rate * 2 * temp; 72| 262| t_E_temp[1] = sbr->rate * temp; 73| 262| break; 74| 455| case 2: ------------------ | Branch (74:9): [True: 455, False: 5.05k] ------------------ 75| 455| t_E_temp[1] = sbr->rate * (sbr->numTimeSlots / 2); 76| 455| break; 77| 4.79k| default: ------------------ | Branch (77:9): [True: 4.79k, False: 717] ------------------ 78| 4.79k| break; 79| 5.51k| } 80| 5.51k| break; 81| | 82| 5.51k| case FIXVAR: ------------------ | | 47| 3.31k|#define FIXVAR 1 ------------------ | Branch (82:5): [True: 3.31k, False: 11.3k] ------------------ 83| 3.31k| if (sbr->L_E[ch] > 1) ------------------ | Branch (83:13): [True: 1.31k, False: 2.00k] ------------------ 84| 1.31k| { 85| 1.31k| int8_t i = sbr->L_E[ch]; 86| 1.31k| border = sbr->abs_bord_trail[ch]; 87| | 88| 3.94k| for (l = 0; l < (sbr->L_E[ch] - 1); l++) ------------------ | Branch (88:25): [True: 2.82k, False: 1.12k] ------------------ 89| 2.82k| { 90| 2.82k| if (border < sbr->bs_rel_bord[ch][l]) ------------------ | Branch (90:21): [True: 189, False: 2.63k] ------------------ 91| 189| return 1; 92| | 93| 2.63k| border -= sbr->bs_rel_bord[ch][l]; 94| 2.63k| t_E_temp[--i] = sbr->rate * border; 95| 2.63k| } 96| 1.31k| } 97| 3.13k| break; 98| | 99| 3.29k| case VARFIX: ------------------ | | 48| 3.29k|#define VARFIX 2 ------------------ | Branch (99:5): [True: 3.29k, False: 11.3k] ------------------ 100| 3.29k| if (sbr->L_E[ch] > 1) ------------------ | Branch (100:13): [True: 2.28k, False: 1.01k] ------------------ 101| 2.28k| { 102| 2.28k| int8_t i = 1; 103| 2.28k| border = sbr->abs_bord_lead[ch]; 104| | 105| 7.01k| for (l = 0; l < (sbr->L_E[ch] - 1); l++) ------------------ | Branch (105:25): [True: 4.85k, False: 2.15k] ------------------ 106| 4.85k| { 107| 4.85k| border += sbr->bs_rel_bord[ch][l]; 108| | 109| 4.85k| if (border > trail) ------------------ | Branch (109:21): [True: 129, False: 4.73k] ------------------ 110| 129| return 1; 111| | 112| 4.73k| t_E_temp[i++] = sbr->rate * border; 113| 4.73k| } 114| 2.28k| } 115| 3.16k| break; 116| | 117| 3.16k| case VARVAR: ------------------ | | 49| 2.55k|#define VARVAR 3 ------------------ | Branch (117:5): [True: 2.55k, False: 12.1k] ------------------ 118| 2.55k| if (sbr->bs_num_rel_0[ch]) ------------------ | Branch (118:13): [True: 2.04k, False: 511] ------------------ 119| 2.04k| { 120| 2.04k| int8_t i = 1; 121| 2.04k| border = sbr->abs_bord_lead[ch]; 122| | 123| 6.88k| for (l = 0; l < sbr->bs_num_rel_0[ch]; l++) ------------------ | Branch (123:25): [True: 4.93k, False: 1.95k] ------------------ 124| 4.93k| { 125| 4.93k| border += sbr->bs_rel_bord_0[ch][l]; 126| | 127| 4.93k| if (border > trail) ------------------ | Branch (127:21): [True: 87, False: 4.84k] ------------------ 128| 87| return 1; 129| | 130| 4.84k| t_E_temp[i++] = sbr->rate * border; 131| 4.84k| } 132| 2.04k| } 133| | 134| 2.46k| if (sbr->bs_num_rel_1[ch]) ------------------ | Branch (134:13): [True: 2.03k, False: 432] ------------------ 135| 2.03k| { 136| 2.03k| int8_t i = sbr->L_E[ch]; 137| 2.03k| border = sbr->abs_bord_trail[ch]; 138| | 139| 6.79k| for (l = 0; l < sbr->bs_num_rel_1[ch]; l++) ------------------ | Branch (139:25): [True: 4.81k, False: 1.98k] ------------------ 140| 4.81k| { 141| 4.81k| if (border < sbr->bs_rel_bord_1[ch][l]) ------------------ | Branch (141:21): [True: 57, False: 4.75k] ------------------ 142| 57| return 1; 143| | 144| 4.75k| border -= sbr->bs_rel_bord_1[ch][l]; 145| 4.75k| t_E_temp[--i] = sbr->rate * border; 146| 4.75k| } 147| 2.03k| } 148| 2.41k| break; 149| 14.6k| } 150| | 151| | /* no error occured, we can safely use this t_E vector */ 152| 99.5k| for (l = 0; l < 6; l++) ------------------ | Branch (152:17): [True: 85.3k, False: 14.2k] ------------------ 153| 85.3k| { 154| 85.3k| sbr->t_E[ch][l] = t_E_temp[l]; 155| 85.3k| } 156| | 157| 14.2k| return 0; 158| 14.6k|} noise_floor_time_border_vector: 161| 14.2k|{ 162| 14.2k| sbr->t_Q[ch][0] = sbr->t_E[ch][0]; 163| | 164| 14.2k| if (sbr->L_E[ch] == 1) ------------------ | Branch (164:9): [True: 7.93k, False: 6.29k] ------------------ 165| 7.93k| { 166| 7.93k| sbr->t_Q[ch][1] = sbr->t_E[ch][1]; 167| 7.93k| sbr->t_Q[ch][2] = 0; 168| 7.93k| } else { 169| 6.29k| uint8_t index = middleBorder(sbr, ch); 170| 6.29k| sbr->t_Q[ch][1] = sbr->t_E[ch][index]; 171| 6.29k| sbr->t_Q[ch][2] = sbr->t_E[ch][sbr->L_E[ch]]; 172| 6.29k| } 173| 14.2k|} sbr_tf_grid.c:middleBorder: 233| 6.29k|{ 234| 6.29k| int8_t retval = 0; 235| | 236| 6.29k| switch (sbr->bs_frame_class[ch]) ------------------ | Branch (236:13): [True: 6.29k, False: 0] ------------------ 237| 6.29k| { 238| 717| case FIXFIX: ------------------ | | 46| 717|#define FIXFIX 0 ------------------ | Branch (238:5): [True: 717, False: 5.57k] ------------------ 239| 717| retval = sbr->L_E[ch]/2; 240| 717| break; 241| 2.15k| case VARFIX: ------------------ | | 48| 2.15k|#define VARFIX 2 ------------------ | Branch (241:5): [True: 2.15k, False: 4.13k] ------------------ 242| 2.15k| if (sbr->bs_pointer[ch] == 0) ------------------ | Branch (242:13): [True: 306, False: 1.84k] ------------------ 243| 306| retval = 1; 244| 1.84k| else if (sbr->bs_pointer[ch] == 1) ------------------ | Branch (244:18): [True: 1.53k, False: 309] ------------------ 245| 1.53k| retval = sbr->L_E[ch] - 1; 246| 309| else 247| 309| retval = sbr->bs_pointer[ch] - 1; 248| 2.15k| break; 249| 1.12k| case FIXVAR: ------------------ | | 47| 1.12k|#define FIXVAR 1 ------------------ | Branch (249:5): [True: 1.12k, False: 5.16k] ------------------ 250| 3.42k| case VARVAR: ------------------ | | 49| 3.42k|#define VARVAR 3 ------------------ | Branch (250:5): [True: 2.30k, False: 3.98k] ------------------ 251| 3.42k| if (sbr->bs_pointer[ch] > 1) ------------------ | Branch (251:13): [True: 1.39k, False: 2.02k] ------------------ 252| 1.39k| retval = sbr->L_E[ch] + 1 - sbr->bs_pointer[ch]; 253| 2.02k| else 254| 2.02k| retval = sbr->L_E[ch] - 1; 255| 3.42k| break; 256| 6.29k| } 257| | 258| 6.29k| return (retval > 0) ? retval : 0; ------------------ | Branch (258:12): [True: 5.77k, False: 516] ------------------ 259| 6.29k|} window_grouping_info: 303| 41.4k|{ 304| 41.4k| uint8_t i, g; 305| | 306| 41.4k| uint8_t sf_index = hDecoder->sf_index; 307| | 308| 41.4k| if (sf_index >= 12) ------------------ | Branch (308:9): [True: 0, False: 41.4k] ------------------ 309| 0| return 32; 310| | 311| 41.4k| switch (ics->window_sequence) { 312| 25.7k| case ONLY_LONG_SEQUENCE: ------------------ | | 96| 25.7k|#define ONLY_LONG_SEQUENCE 0x0 ------------------ | Branch (312:5): [True: 25.7k, False: 15.7k] ------------------ 313| 29.5k| case LONG_START_SEQUENCE: ------------------ | | 97| 29.5k|#define LONG_START_SEQUENCE 0x1 ------------------ | Branch (313:5): [True: 3.89k, False: 37.5k] ------------------ 314| 30.0k| case LONG_STOP_SEQUENCE: ------------------ | | 99| 30.0k|#define LONG_STOP_SEQUENCE 0x3 ------------------ | Branch (314:5): [True: 473, False: 40.9k] ------------------ 315| 30.0k| ics->num_windows = 1; 316| 30.0k| ics->num_window_groups = 1; 317| 30.0k| ics->window_group_length[ics->num_window_groups-1] = 1; 318| |#ifdef LD_DEC 319| | if (hDecoder->object_type == LD) 320| | { 321| | if (hDecoder->frameLength == 512) 322| | ics->num_swb = num_swb_512_window[sf_index]; 323| | else /* if (hDecoder->frameLength == 480) */ 324| | ics->num_swb = num_swb_480_window[sf_index]; 325| | } else { 326| |#endif 327| 30.0k| if (hDecoder->frameLength == 1024) ------------------ | Branch (327:17): [True: 19.6k, False: 10.3k] ------------------ 328| 19.6k| ics->num_swb = num_swb_1024_window[sf_index]; 329| 10.3k| else /* if (hDecoder->frameLength == 960) */ 330| 10.3k| ics->num_swb = num_swb_960_window[sf_index]; 331| |#ifdef LD_DEC 332| | } 333| |#endif 334| | 335| 30.0k| if (ics->max_sfb > ics->num_swb) ------------------ | Branch (335:13): [True: 35, False: 30.0k] ------------------ 336| 35| { 337| 35| return 32; 338| 35| } 339| | 340| | /* preparation of sect_sfb_offset for long blocks */ 341| | /* also copy the last value! */ 342| |#ifdef LD_DEC 343| | if (hDecoder->object_type == LD) 344| | { 345| | if (hDecoder->frameLength == 512) 346| | { 347| | for (i = 0; i < ics->num_swb; i++) 348| | { 349| | ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i]; 350| | ics->swb_offset[i] = swb_offset_512_window[sf_index][i]; 351| | } 352| | } else /* if (hDecoder->frameLength == 480) */ { 353| | for (i = 0; i < ics->num_swb; i++) 354| | { 355| | ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i]; 356| | ics->swb_offset[i] = swb_offset_480_window[sf_index][i]; 357| | } 358| | } 359| | ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength; 360| | ics->swb_offset[ics->num_swb] = hDecoder->frameLength; 361| | ics->swb_offset_max = hDecoder->frameLength; 362| | } else { 363| |#endif 364| 1.33M| for (i = 0; i < ics->num_swb; i++) ------------------ | Branch (364:25): [True: 1.30M, False: 30.0k] ------------------ 365| 1.30M| { 366| 1.30M| ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i]; 367| 1.30M| ics->swb_offset[i] = swb_offset_1024_window[sf_index][i]; 368| 1.30M| } 369| 30.0k| ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength; 370| 30.0k| ics->swb_offset[ics->num_swb] = hDecoder->frameLength; 371| 30.0k| ics->swb_offset_max = hDecoder->frameLength; 372| |#ifdef LD_DEC 373| | } 374| |#endif 375| 30.0k| return 0; 376| 11.3k| case EIGHT_SHORT_SEQUENCE: ------------------ | | 98| 11.3k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (376:5): [True: 11.3k, False: 30.0k] ------------------ 377| 11.3k| ics->num_windows = 8; 378| 11.3k| ics->num_window_groups = 1; 379| 11.3k| ics->window_group_length[ics->num_window_groups-1] = 1; 380| 11.3k| ics->num_swb = num_swb_128_window[sf_index]; 381| | 382| 11.3k| if (ics->max_sfb > ics->num_swb) ------------------ | Branch (382:13): [True: 2, False: 11.3k] ------------------ 383| 2| { 384| 2| return 32; 385| 2| } 386| | 387| 169k| for (i = 0; i < ics->num_swb; i++) ------------------ | Branch (387:21): [True: 157k, False: 11.3k] ------------------ 388| 157k| ics->swb_offset[i] = swb_offset_128_window[sf_index][i]; 389| 11.3k| ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8; 390| 11.3k| ics->swb_offset_max = hDecoder->frameLength/8; 391| | 392| 91.0k| for (i = 0; i < ics->num_windows-1; i++) { ------------------ | Branch (392:21): [True: 79.6k, False: 11.3k] ------------------ 393| 79.6k| if (bit_set(ics->scale_factor_grouping, 6-i) == 0) ------------------ | | 287| 79.6k|#define bit_set(A, B) ((A) & (1<<(B))) ------------------ | Branch (393:17): [True: 66.0k, False: 13.6k] ------------------ 394| 66.0k| { 395| 66.0k| ics->num_window_groups += 1; 396| 66.0k| ics->window_group_length[ics->num_window_groups-1] = 1; 397| 66.0k| } else { 398| 13.6k| ics->window_group_length[ics->num_window_groups-1] += 1; 399| 13.6k| } 400| 79.6k| } 401| | 402| | /* preparation of sect_sfb_offset for short blocks */ 403| 88.8k| for (g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (403:21): [True: 77.4k, False: 11.3k] ------------------ 404| 77.4k| { 405| 77.4k| uint16_t width; 406| 77.4k| uint8_t sect_sfb = 0; 407| 77.4k| uint16_t offset = 0; 408| | 409| 1.15M| for (i = 0; i < ics->num_swb; i++) ------------------ | Branch (409:25): [True: 1.07M, False: 77.4k] ------------------ 410| 1.07M| { 411| 1.07M| if (i+1 == ics->num_swb) ------------------ | Branch (411:21): [True: 77.4k, False: 996k] ------------------ 412| 77.4k| { 413| 77.4k| width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i]; 414| 996k| } else { 415| 996k| width = swb_offset_128_window[sf_index][i+1] - 416| 996k| swb_offset_128_window[sf_index][i]; 417| 996k| } 418| 1.07M| width *= ics->window_group_length[g]; 419| 1.07M| ics->sect_sfb_offset[g][sect_sfb++] = offset; 420| 1.07M| offset += width; 421| 1.07M| } 422| 77.4k| ics->sect_sfb_offset[g][sect_sfb] = offset; 423| 77.4k| } 424| 11.3k| return 0; 425| 0| default: ------------------ | Branch (425:5): [True: 0, False: 41.4k] ------------------ 426| 0| return 32; 427| 41.4k| } 428| 41.4k|} reconstruct_single_channel: 919| 27.6k|{ 920| 27.6k| uint8_t retval; 921| 27.6k| uint8_t output_channels; 922| 27.6k| ALIGN real_t spec_coef[1024]; 923| | 924| |#ifdef PROFILE 925| | int64_t count = faad_get_ts(); 926| |#endif 927| | 928| | 929| | /* always allocate 2 channels, PS can always "suddenly" turn up */ 930| 27.6k|#if ( (defined(DRM) && defined(DRM_PS)) ) 931| 27.6k| output_channels = 2; 932| |#elif defined(PS_DEC) 933| | if (hDecoder->ps_used[hDecoder->fr_ch_ele]) 934| | output_channels = 2; 935| | else 936| | output_channels = 1; 937| |#else 938| | output_channels = 1; 939| |#endif 940| | 941| 27.6k| if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0) ------------------ | Branch (941:9): [True: 22.3k, False: 5.25k] ------------------ 942| 22.3k| { 943| | /* element_output_channels not set yet */ 944| 22.3k| hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels; 945| 22.3k| } else if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] != output_channels) { ------------------ | Branch (945:16): [True: 0, False: 5.25k] ------------------ 946| | /* element inconsistency */ 947| | 948| | /* this only happens if PS is actually found but not in the first frame 949| | * this means that there is only 1 bitstream element! 950| | */ 951| | 952| | /* The simplest way to fix the accounting, 953| | * is to reallocate this and all the following channels. 954| | */ 955| 0| memset(&hDecoder->element_alloced[hDecoder->fr_ch_ele], 0, 956| 0| sizeof(uint8_t) * (MAX_SYNTAX_ELEMENTS - hDecoder->fr_ch_ele)); ------------------ | | 44| 0|#define MAX_SYNTAX_ELEMENTS 48 ------------------ 957| | 958| 0| hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels; 959| | 960| | //return 21; 961| 0| } 962| | 963| 27.6k| if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0) ------------------ | Branch (963:9): [True: 22.3k, False: 5.25k] ------------------ 964| 22.3k| { 965| 22.3k| retval = allocate_single_channel(hDecoder, sce->channel, output_channels); 966| 22.3k| if (retval > 0) ------------------ | Branch (966:13): [True: 0, False: 22.3k] ------------------ 967| 0| return retval; 968| | 969| 22.3k| hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1; 970| 22.3k| } 971| | 972| | /* sanity check, CVE-2018-20199, CVE-2018-20360 */ 973| 27.6k| if(!hDecoder->time_out[sce->channel]) ------------------ | Branch (973:8): [True: 0, False: 27.6k] ------------------ 974| 0| return 15; 975| 27.6k| if(output_channels > 1 && !hDecoder->time_out[sce->channel+1]) ------------------ | Branch (975:8): [True: 27.6k, False: 0] | Branch (975:31): [True: 0, False: 27.6k] ------------------ 976| 0| return 15; 977| 27.6k| if(!hDecoder->fb_intermed[sce->channel]) ------------------ | Branch (977:8): [True: 0, False: 27.6k] ------------------ 978| 0| return 15; 979| | 980| | /* dequantisation and scaling */ 981| 27.6k| retval = quant_to_spec(hDecoder, ics, spec_data, spec_coef, hDecoder->frameLength); 982| 27.6k| if (retval > 0) ------------------ | Branch (982:9): [True: 9, False: 27.6k] ------------------ 983| 9| return retval; 984| | 985| |#ifdef PROFILE 986| | count = faad_get_ts() - count; 987| | hDecoder->requant_cycles += count; 988| |#endif 989| | 990| | 991| | /* pns decoding */ 992| 27.6k| pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type, 993| 27.6k| &(hDecoder->__r1), &(hDecoder->__r2)); 994| | 995| |#ifdef MAIN_DEC 996| | /* MAIN object type prediction */ 997| | if (hDecoder->object_type == MAIN) 998| | { 999| | if (!hDecoder->pred_stat[sce->channel]) 1000| | return 33; 1001| | 1002| | /* intra channel prediction */ 1003| | ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength, 1004| | hDecoder->sf_index); 1005| | 1006| | /* In addition, for scalefactor bands coded by perceptual 1007| | noise substitution the predictors belonging to the 1008| | corresponding spectral coefficients are reset. 1009| | */ 1010| | pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]); 1011| | } 1012| |#endif 1013| | 1014| |#ifdef LTP_DEC 1015| | if (is_ltp_ot(hDecoder->object_type)) 1016| | { 1017| |#ifdef LD_DEC 1018| | if (hDecoder->object_type == LD) 1019| | { 1020| | if (ics->ltp.data_present) 1021| | { 1022| | if (ics->ltp.lag_update) 1023| | hDecoder->ltp_lag[sce->channel] = ics->ltp.lag; 1024| | } 1025| | ics->ltp.lag = hDecoder->ltp_lag[sce->channel]; 1026| | } 1027| |#endif 1028| | 1029| | /* long term prediction */ 1030| | lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb, 1031| | ics->window_shape, hDecoder->window_shape_prev[sce->channel], 1032| | hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength); 1033| | } 1034| |#endif 1035| | 1036| | /* tns decoding */ 1037| 27.6k| tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type, 1038| 27.6k| spec_coef, hDecoder->frameLength); 1039| | 1040| | /* drc decoding */ 1041| 27.6k|#ifdef APPLY_DRC 1042| 27.6k| if (hDecoder->drc->present) ------------------ | Branch (1042:9): [True: 0, False: 27.6k] ------------------ 1043| 0| { 1044| 0| if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present) ------------------ | Branch (1044:13): [True: 0, False: 0] | Branch (1044:59): [True: 0, False: 0] ------------------ 1045| 0| drc_decode(hDecoder->drc, spec_coef); 1046| 0| } 1047| 27.6k|#endif 1048| | /* filter bank */ 1049| |#ifdef SSR_DEC 1050| | if (hDecoder->object_type != SSR) 1051| | { 1052| |#endif 1053| 27.6k| ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape, 1054| 27.6k| hDecoder->window_shape_prev[sce->channel], spec_coef, 1055| 27.6k| hDecoder->time_out[sce->channel], hDecoder->fb_intermed[sce->channel], 1056| 27.6k| hDecoder->object_type, hDecoder->frameLength); 1057| |#ifdef SSR_DEC 1058| | } else { 1059| | ssr_decode(&(ics->ssr), hDecoder->fb, ics->window_sequence, ics->window_shape, 1060| | hDecoder->window_shape_prev[sce->channel], spec_coef, hDecoder->time_out[sce->channel], 1061| | hDecoder->ssr_overlap[sce->channel], hDecoder->ipqf_buffer[sce->channel], hDecoder->prev_fmd[sce->channel], 1062| | hDecoder->frameLength); 1063| | } 1064| |#endif 1065| | 1066| | /* save window shape for next frame */ 1067| 27.6k| hDecoder->window_shape_prev[sce->channel] = ics->window_shape; 1068| | 1069| |#ifdef LTP_DEC 1070| | if (is_ltp_ot(hDecoder->object_type)) 1071| | { 1072| | lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel], 1073| | hDecoder->fb_intermed[sce->channel], hDecoder->frameLength, hDecoder->object_type); 1074| | } 1075| |#endif 1076| | 1077| 27.6k|#ifdef SBR_DEC 1078| 27.6k| if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (1078:10): [True: 24.0k, False: 3.61k] | Branch (1078:47): [True: 1.58k, False: 2.02k] ------------------ 1079| 25.6k| && hDecoder->sbr_alloced[hDecoder->fr_ch_ele]) ------------------ | Branch (1079:12): [True: 25.6k, False: 0] ------------------ 1080| 25.6k| { 1081| 25.6k| int ele = hDecoder->fr_ch_ele; 1082| 25.6k| int ch = sce->channel; 1083| | 1084| | /* following case can happen when forceUpSampling == 1 */ 1085| 25.6k| if (hDecoder->sbr[ele] == NULL) ------------------ | Branch (1085:13): [True: 13.6k, False: 11.9k] ------------------ 1086| 13.6k| { 1087| 13.6k| hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength, 1088| 13.6k| hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index), 1089| 13.6k| hDecoder->downSampledSBR 1090| 13.6k|#ifdef DRM 1091| 13.6k| , 0 1092| 13.6k|#endif 1093| 13.6k| ); 1094| 13.6k| } 1095| 25.6k| if (!hDecoder->sbr[ele]) ------------------ | Branch (1095:13): [True: 0, False: 25.6k] ------------------ 1096| 0| return 19; 1097| | 1098| 25.6k| if (sce->ics1.window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 25.6k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (1098:13): [True: 7.58k, False: 18.0k] ------------------ 1099| 7.58k| hDecoder->sbr[ele]->maxAACLine = 8*min(sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)], sce->ics1.swb_offset_max); ------------------ | | 60| 15.1k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 7.58k, False: 0] | | | Branch (60:22): [True: 99, False: 7.48k] | | | Branch (60:35): [True: 99, False: 7.48k] | | ------------------ ------------------ 1100| 18.0k| else 1101| 18.0k| hDecoder->sbr[ele]->maxAACLine = min(sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)], sce->ics1.swb_offset_max); ------------------ | | 60| 36.0k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 18.0k, False: 0] | | | Branch (60:22): [True: 650, False: 17.3k] | | | Branch (60:35): [True: 650, False: 17.3k] | | ------------------ ------------------ 1102| | 1103| | /* check if any of the PS tools is used */ 1104| 25.6k|#if (defined(PS_DEC) || defined(DRM_PS)) 1105| 25.6k| if (hDecoder->ps_used[ele] == 0) ------------------ | Branch (1105:13): [True: 21.7k, False: 3.82k] ------------------ 1106| 21.7k| { 1107| 21.7k|#endif 1108| 21.7k| retval = sbrDecodeSingleFrame(hDecoder->sbr[ele], hDecoder->time_out[ch], 1109| 21.7k| hDecoder->postSeekResetFlag, hDecoder->downSampledSBR); 1110| 21.7k|#if (defined(PS_DEC) || defined(DRM_PS)) 1111| 21.7k| } else { 1112| 3.82k| retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[ch], 1113| 3.82k| hDecoder->time_out[ch+1], hDecoder->postSeekResetFlag, 1114| 3.82k| hDecoder->downSampledSBR); 1115| 3.82k| } 1116| 25.6k|#endif 1117| 25.6k| if (retval > 0) ------------------ | Branch (1117:13): [True: 1, False: 25.6k] ------------------ 1118| 1| return retval; 1119| 25.6k| } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (1119:17): [True: 0, False: 2.02k] | Branch (1119:54): [True: 0, False: 2.02k] ------------------ 1120| 0| && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele]) ------------------ | Branch (1120:12): [True: 0, False: 0] ------------------ 1121| 0| { 1122| 0| return 23; 1123| 0| } 1124| 27.6k|#endif 1125| | 1126| | /* copy L to R when no PS is used */ 1127| 27.6k|#if (defined(PS_DEC) || defined(DRM_PS)) 1128| 27.6k| if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0) && ------------------ | Branch (1128:9): [True: 23.8k, False: 3.82k] ------------------ 1129| 23.8k| (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2)) ------------------ | Branch (1129:9): [True: 23.8k, False: 0] ------------------ 1130| 23.8k| { 1131| 23.8k| int ele = hDecoder->fr_ch_ele; 1132| 23.8k| int ch = sce->channel; 1133| 23.8k| int frame_size = (hDecoder->sbr_alloced[ele]) ? 2 : 1; ------------------ | Branch (1133:26): [True: 21.7k, False: 2.02k] ------------------ 1134| 23.8k| frame_size *= hDecoder->frameLength*sizeof(real_t); 1135| | 1136| 23.8k| memcpy(hDecoder->time_out[ch+1], hDecoder->time_out[ch], frame_size); 1137| 23.8k| } 1138| 27.6k|#endif 1139| | 1140| 27.6k| return 0; 1141| 27.6k|} reconstruct_channel_pair: 1145| 8.84k|{ 1146| 8.84k| uint8_t retval; 1147| 8.84k| ALIGN real_t spec_coef1[1024]; 1148| 8.84k| ALIGN real_t spec_coef2[1024]; 1149| | 1150| |#ifdef PROFILE 1151| | int64_t count = faad_get_ts(); 1152| |#endif 1153| 8.84k| if (hDecoder->element_alloced[hDecoder->fr_ch_ele] != 2) ------------------ | Branch (1153:9): [True: 7.78k, False: 1.06k] ------------------ 1154| 7.78k| { 1155| 7.78k| retval = allocate_channel_pair(hDecoder, cpe->channel, (uint8_t)cpe->paired_channel); 1156| 7.78k| if (retval > 0) ------------------ | Branch (1156:13): [True: 0, False: 7.78k] ------------------ 1157| 0| return retval; 1158| | 1159| 7.78k| hDecoder->element_alloced[hDecoder->fr_ch_ele] = 2; 1160| 7.78k| } 1161| | 1162| | /* sanity check, CVE-2018-20199, CVE-2018-20360 */ 1163| 8.84k| if(!hDecoder->time_out[cpe->channel] || !hDecoder->time_out[cpe->paired_channel]) ------------------ | Branch (1163:8): [True: 0, False: 8.84k] | Branch (1163:45): [True: 0, False: 8.84k] ------------------ 1164| 0| return 15; 1165| 8.84k| if(!hDecoder->fb_intermed[cpe->channel] || !hDecoder->fb_intermed[cpe->paired_channel]) ------------------ | Branch (1165:8): [True: 0, False: 8.84k] | Branch (1165:48): [True: 0, False: 8.84k] ------------------ 1166| 0| return 15; 1167| | 1168| | /* dequantisation and scaling */ 1169| 8.84k| retval = quant_to_spec(hDecoder, ics1, spec_data1, spec_coef1, hDecoder->frameLength); 1170| 8.84k| if (retval > 0) ------------------ | Branch (1170:9): [True: 0, False: 8.84k] ------------------ 1171| 0| return retval; 1172| 8.84k| retval = quant_to_spec(hDecoder, ics2, spec_data2, spec_coef2, hDecoder->frameLength); 1173| 8.84k| if (retval > 0) ------------------ | Branch (1173:9): [True: 2, False: 8.84k] ------------------ 1174| 2| return retval; 1175| | 1176| |#ifdef PROFILE 1177| | count = faad_get_ts() - count; 1178| | hDecoder->requant_cycles += count; 1179| |#endif 1180| | 1181| | /* pns decoding */ 1182| 8.84k| if (ics1->ms_mask_present) ------------------ | Branch (1182:9): [True: 1.28k, False: 7.55k] ------------------ 1183| 1.28k| { 1184| 1.28k| pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type, 1185| 1.28k| &(hDecoder->__r1), &(hDecoder->__r2)); 1186| 7.55k| } else { 1187| 7.55k| pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 0, hDecoder->object_type, 1188| 7.55k| &(hDecoder->__r1), &(hDecoder->__r2)); 1189| 7.55k| } 1190| | 1191| | /* mid/side decoding */ 1192| 8.84k| ms_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength); 1193| | 1194| |#if 0 1195| | { 1196| | int i; 1197| | for (i = 0; i < 1024; i++) 1198| | { 1199| | //printf("%d\n", spec_coef1[i]); 1200| | printf("0x%.8X\n", spec_coef1[i]); 1201| | } 1202| | for (i = 0; i < 1024; i++) 1203| | { 1204| | //printf("%d\n", spec_coef2[i]); 1205| | printf("0x%.8X\n", spec_coef2[i]); 1206| | } 1207| | } 1208| |#endif 1209| | 1210| | /* intensity stereo decoding */ 1211| 8.84k| is_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength); 1212| | 1213| |#if 0 1214| | { 1215| | int i; 1216| | for (i = 0; i < 1024; i++) 1217| | { 1218| | printf("%d\n", spec_coef1[i]); 1219| | //printf("0x%.8X\n", spec_coef1[i]); 1220| | } 1221| | for (i = 0; i < 1024; i++) 1222| | { 1223| | printf("%d\n", spec_coef2[i]); 1224| | //printf("0x%.8X\n", spec_coef2[i]); 1225| | } 1226| | } 1227| |#endif 1228| | 1229| |#ifdef MAIN_DEC 1230| | /* MAIN object type prediction */ 1231| | if (hDecoder->object_type == MAIN) 1232| | { 1233| | /* intra channel prediction */ 1234| | ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength, 1235| | hDecoder->sf_index); 1236| | ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength, 1237| | hDecoder->sf_index); 1238| | 1239| | /* In addition, for scalefactor bands coded by perceptual 1240| | noise substitution the predictors belonging to the 1241| | corresponding spectral coefficients are reset. 1242| | */ 1243| | pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]); 1244| | pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]); 1245| | } 1246| |#endif 1247| | 1248| |#ifdef LTP_DEC 1249| | if (is_ltp_ot(hDecoder->object_type)) 1250| | { 1251| | ltp_info *ltp1 = &(ics1->ltp); 1252| | ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp); 1253| |#ifdef LD_DEC 1254| | if (hDecoder->object_type == LD) 1255| | { 1256| | if (ltp1->data_present) 1257| | { 1258| | if (ltp1->lag_update) 1259| | hDecoder->ltp_lag[cpe->channel] = ltp1->lag; 1260| | } 1261| | ltp1->lag = hDecoder->ltp_lag[cpe->channel]; 1262| | if (ltp2->data_present) 1263| | { 1264| | if (ltp2->lag_update) 1265| | hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag; 1266| | } 1267| | ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel]; 1268| | } 1269| |#endif 1270| | 1271| | /* long term prediction */ 1272| | lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb, 1273| | ics1->window_shape, hDecoder->window_shape_prev[cpe->channel], 1274| | hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength); 1275| | lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb, 1276| | ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel], 1277| | hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength); 1278| | } 1279| |#endif 1280| | 1281| | /* tns decoding */ 1282| 8.84k| tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type, 1283| 8.84k| spec_coef1, hDecoder->frameLength); 1284| 8.84k| tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type, 1285| 8.84k| spec_coef2, hDecoder->frameLength); 1286| | 1287| | /* drc decoding */ 1288| 8.84k|#if APPLY_DRC 1289| 8.84k| if (hDecoder->drc->present) ------------------ | Branch (1289:9): [True: 0, False: 8.84k] ------------------ 1290| 0| { 1291| 0| if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present) ------------------ | Branch (1291:13): [True: 0, False: 0] | Branch (1291:59): [True: 0, False: 0] ------------------ 1292| 0| drc_decode(hDecoder->drc, spec_coef1); 1293| 0| if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present) ------------------ | Branch (1293:13): [True: 0, False: 0] | Branch (1293:66): [True: 0, False: 0] ------------------ 1294| 0| drc_decode(hDecoder->drc, spec_coef2); 1295| 0| } 1296| 8.84k|#endif 1297| | /* filter bank */ 1298| |#ifdef SSR_DEC 1299| | if (hDecoder->object_type != SSR) 1300| | { 1301| |#endif 1302| 8.84k| ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape, 1303| 8.84k| hDecoder->window_shape_prev[cpe->channel], spec_coef1, 1304| 8.84k| hDecoder->time_out[cpe->channel], hDecoder->fb_intermed[cpe->channel], 1305| 8.84k| hDecoder->object_type, hDecoder->frameLength); 1306| 8.84k| ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape, 1307| 8.84k| hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2, 1308| 8.84k| hDecoder->time_out[cpe->paired_channel], hDecoder->fb_intermed[cpe->paired_channel], 1309| 8.84k| hDecoder->object_type, hDecoder->frameLength); 1310| |#ifdef SSR_DEC 1311| | } else { 1312| | ssr_decode(&(ics1->ssr), hDecoder->fb, ics1->window_sequence, ics1->window_shape, 1313| | hDecoder->window_shape_prev[cpe->channel], spec_coef1, hDecoder->time_out[cpe->channel], 1314| | hDecoder->ssr_overlap[cpe->channel], hDecoder->ipqf_buffer[cpe->channel], 1315| | hDecoder->prev_fmd[cpe->channel], hDecoder->frameLength); 1316| | ssr_decode(&(ics2->ssr), hDecoder->fb, ics2->window_sequence, ics2->window_shape, 1317| | hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2, hDecoder->time_out[cpe->paired_channel], 1318| | hDecoder->ssr_overlap[cpe->paired_channel], hDecoder->ipqf_buffer[cpe->paired_channel], 1319| | hDecoder->prev_fmd[cpe->paired_channel], hDecoder->frameLength); 1320| | } 1321| |#endif 1322| | 1323| | /* save window shape for next frame */ 1324| 8.84k| hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape; 1325| 8.84k| hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape; 1326| | 1327| |#ifdef LTP_DEC 1328| | if (is_ltp_ot(hDecoder->object_type)) 1329| | { 1330| | lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel], 1331| | hDecoder->fb_intermed[cpe->channel], hDecoder->frameLength, hDecoder->object_type); 1332| | lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel], 1333| | hDecoder->fb_intermed[cpe->paired_channel], hDecoder->frameLength, hDecoder->object_type); 1334| | } 1335| |#endif 1336| | 1337| 8.84k|#ifdef SBR_DEC 1338| 8.84k| if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (1338:10): [True: 6.75k, False: 2.08k] | Branch (1338:47): [True: 1.35k, False: 739] ------------------ 1339| 8.10k| && hDecoder->sbr_alloced[hDecoder->fr_ch_ele]) ------------------ | Branch (1339:12): [True: 8.10k, False: 0] ------------------ 1340| 8.10k| { 1341| 8.10k| int ele = hDecoder->fr_ch_ele; 1342| 8.10k| int ch0 = cpe->channel; 1343| 8.10k| int ch1 = cpe->paired_channel; 1344| | 1345| | /* following case can happen when forceUpSampling == 1 */ 1346| 8.10k| if (hDecoder->sbr[ele] == NULL) ------------------ | Branch (1346:13): [True: 2.75k, False: 5.35k] ------------------ 1347| 2.75k| { 1348| 2.75k| hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength, 1349| 2.75k| hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index), 1350| 2.75k| hDecoder->downSampledSBR 1351| 2.75k|#ifdef DRM 1352| 2.75k| , 0 1353| 2.75k|#endif 1354| 2.75k| ); 1355| 2.75k| } 1356| 8.10k| if (!hDecoder->sbr[ele]) ------------------ | Branch (1356:13): [True: 0, False: 8.10k] ------------------ 1357| 0| return 19; 1358| | 1359| 8.10k| if (cpe->ics1.window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 8.10k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (1359:13): [True: 666, False: 7.43k] ------------------ 1360| 666| hDecoder->sbr[ele]->maxAACLine = 8*min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max); ------------------ | | 60| 1.33k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 666, False: 0] | | | Branch (60:22): [True: 81, False: 585] | | | Branch (60:35): [True: 81, False: 585] | | ------------------ ------------------ 1361| 7.43k| else 1362| 7.43k| hDecoder->sbr[ele]->maxAACLine = min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max); ------------------ | | 60| 14.8k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 7.43k, False: 0] | | | Branch (60:22): [True: 373, False: 7.06k] | | | Branch (60:35): [True: 373, False: 7.06k] | | ------------------ ------------------ 1363| | 1364| 8.10k| retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele], 1365| 8.10k| hDecoder->time_out[ch0], hDecoder->time_out[ch1], 1366| 8.10k| hDecoder->postSeekResetFlag, hDecoder->downSampledSBR); 1367| 8.10k| if (retval > 0) ------------------ | Branch (1367:13): [True: 0, False: 8.10k] ------------------ 1368| 0| return retval; 1369| 8.10k| } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (1369:17): [True: 0, False: 739] | Branch (1369:54): [True: 0, False: 739] ------------------ 1370| 0| && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele]) ------------------ | Branch (1370:12): [True: 0, False: 0] ------------------ 1371| 0| { 1372| 0| return 23; 1373| 0| } 1374| 8.84k|#endif 1375| | 1376| 8.84k| return 0; 1377| 8.84k|} specrec.c:allocate_single_channel: 703| 22.3k|{ 704| 22.3k| int mul = 1; 705| | 706| |#ifdef MAIN_DEC 707| | /* MAIN object type prediction */ 708| | if (hDecoder->object_type == MAIN) 709| | { 710| | /* allocate the state only when needed */ 711| | if (hDecoder->pred_stat[channel] != NULL) 712| | { 713| | faad_free(hDecoder->pred_stat[channel]); 714| | hDecoder->pred_stat[channel] = NULL; 715| | } 716| | 717| | hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state)); 718| | reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength); 719| | } 720| |#endif 721| | 722| |#ifdef LTP_DEC 723| | if (is_ltp_ot(hDecoder->object_type)) 724| | { 725| | /* allocate the state only when needed */ 726| | if (hDecoder->lt_pred_stat[channel] != NULL) 727| | { 728| | faad_free(hDecoder->lt_pred_stat[channel]); 729| | hDecoder->lt_pred_stat[channel] = NULL; 730| | } 731| | 732| | hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t)); 733| | memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t)); 734| | } 735| |#endif 736| | 737| 22.3k| if (hDecoder->time_out[channel] != NULL) ------------------ | Branch (737:9): [True: 0, False: 22.3k] ------------------ 738| 0| { 739| 0| faad_free(hDecoder->time_out[channel]); 740| 0| hDecoder->time_out[channel] = NULL; 741| 0| } 742| | 743| 22.3k| { 744| 22.3k| mul = 1; 745| 22.3k|#ifdef SBR_DEC 746| 22.3k| hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0; 747| 22.3k| if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (747:13): [True: 18.9k, False: 3.40k] | Branch (747:50): [True: 1.55k, False: 1.84k] ------------------ 748| 20.5k| { 749| | /* SBR requires 2 times as much output data */ 750| 20.5k| mul = 2; 751| 20.5k| hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1; 752| 20.5k| } 753| 22.3k|#endif 754| 22.3k| hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t)); 755| 22.3k| memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t)); 756| 22.3k| } 757| | 758| 22.3k|#if (defined(PS_DEC) || defined(DRM_PS)) 759| 22.3k| if (output_channels == 2) ------------------ | Branch (759:9): [True: 22.3k, False: 0] ------------------ 760| 22.3k| { 761| 22.3k| if (hDecoder->time_out[channel+1] != NULL) ------------------ | Branch (761:13): [True: 0, False: 22.3k] ------------------ 762| 0| { 763| 0| faad_free(hDecoder->time_out[channel+1]); 764| 0| hDecoder->time_out[channel+1] = NULL; 765| 0| } 766| | 767| 22.3k| hDecoder->time_out[channel+1] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t)); 768| 22.3k| memset(hDecoder->time_out[channel+1], 0, mul*hDecoder->frameLength*sizeof(real_t)); 769| 22.3k| } 770| 22.3k|#endif 771| | 772| 22.3k| if (hDecoder->fb_intermed[channel] != NULL) ------------------ | Branch (772:9): [True: 0, False: 22.3k] ------------------ 773| 0| { 774| 0| faad_free(hDecoder->fb_intermed[channel]); 775| 0| hDecoder->fb_intermed[channel] = NULL; 776| 0| } 777| | 778| 22.3k| hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t)); 779| 22.3k| memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t)); 780| | 781| |#ifdef SSR_DEC 782| | if (hDecoder->object_type == SSR) 783| | { 784| | if (hDecoder->ssr_overlap[channel] == NULL) 785| | { 786| | hDecoder->ssr_overlap[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t)); 787| | memset(hDecoder->ssr_overlap[channel], 0, 2*hDecoder->frameLength*sizeof(real_t)); 788| | } 789| | if (hDecoder->prev_fmd[channel] == NULL) 790| | { 791| | uint16_t k; 792| | hDecoder->prev_fmd[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t)); 793| | for (k = 0; k < 2*hDecoder->frameLength; k++) 794| | hDecoder->prev_fmd[channel][k] = REAL_CONST(-1); 795| | } 796| | } 797| |#endif 798| | 799| 22.3k| return 0; 800| 22.3k|} specrec.c:quant_to_spec: 556| 45.3k|{ 557| 45.3k| ALIGN static const real_t pow2_table[] = 558| 45.3k| { 559| 45.3k| COEF_CONST(1.0), ------------------ | | 60| 45.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 45.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 45.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 560| 45.3k| COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */ ------------------ | | 60| 45.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 45.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 45.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 561| 45.3k| COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */ ------------------ | | 60| 45.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 45.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 45.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 562| 45.3k| COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */ ------------------ | | 60| 45.3k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 45.3k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 45.3k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 0, Folded] | | ------------------ ------------------ 563| 45.3k| }; 564| 45.3k| const real_t *tab = iq_table; 565| | 566| 45.3k| uint8_t g, sfb, win; 567| 45.3k| uint16_t width, bin, k, gindex; 568| 45.3k| uint8_t error = 0; /* Init error flag */ 569| |#ifndef FIXED_POINT 570| | real_t scf; 571| |#else 572| 45.3k| int32_t sat_shift_mask = 0; 573| 45.3k|#endif 574| | 575| 45.3k| k = 0; 576| 45.3k| gindex = 0; 577| | 578| | /* In this case quant_to_spec is no-op and spec_data remains undefined. 579| | * Without peeking into AAC specification, there is no strong evidence if 580| | * such streams are invalid -> just calm down MSAN. */ 581| 45.3k| if (ics->num_swb == 0) ------------------ | Branch (581:9): [True: 0, False: 45.3k] ------------------ 582| 0| memset(spec_data, 0, frame_len * sizeof(real_t)); 583| | 584| 159k| for (g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (584:17): [True: 114k, False: 45.3k] ------------------ 585| 114k| { 586| 114k| uint16_t j = 0; 587| 114k| uint16_t gincrease = 0; 588| 114k| uint16_t win_inc = ics->swb_offset[ics->num_swb]; 589| | 590| 2.67M| for (sfb = 0; sfb < ics->num_swb; sfb++) ------------------ | Branch (590:23): [True: 2.56M, False: 114k] ------------------ 591| 2.56M| { 592| 2.56M| int32_t exp, frac; 593| 2.56M| uint16_t wa = gindex + j; 594| 2.56M| int16_t scale_factor = ics->scale_factors[g][sfb]; 595| | 596| 2.56M| width = ics->swb_offset[sfb+1] - ics->swb_offset[sfb]; 597| | 598| 2.56M|#ifdef FIXED_POINT 599| 2.56M| scale_factor -= 100; 600| | /* IMDCT pre-scaling */ 601| 2.56M| if (hDecoder->object_type == LD) ------------------ | | 45| 2.56M|#define LD 23 ------------------ | Branch (601:17): [True: 0, False: 2.56M] ------------------ 602| 0| { 603| 0| scale_factor -= 24 /*9*/; 604| 2.56M| } else { 605| 2.56M| if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 2.56M|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (605:21): [True: 1.13M, False: 1.43M] ------------------ 606| 1.13M| scale_factor -= 16 /*7*/; 607| 1.43M| else 608| 1.43M| scale_factor -= 28 /*10*/; 609| 2.56M| } 610| 2.56M| if (scale_factor > 120) ------------------ | Branch (610:17): [True: 0, False: 2.56M] ------------------ 611| 0| scale_factor = 120; /* => exp <= 30 */ 612| |#else 613| | (void)hDecoder; 614| |#endif 615| | 616| | /* scale_factor for IS or PNS, has different meaning; fill with almost zeroes */ 617| 2.56M| if (is_intensity(ics, g, sfb) || is_noise(ics, g, sfb)) ------------------ | Branch (617:17): [True: 2.37k, False: 2.56M] | Branch (617:46): [True: 0, False: 2.56M] ------------------ 618| 2.37k| { 619| 2.37k| scale_factor = 0; 620| 2.37k| } 621| | 622| | /* scale_factor must be between 0 and 255 */ 623| 2.56M| exp = (scale_factor /* - 100 */) >> 2; 624| | /* frac must always be > 0 */ 625| 2.56M| frac = (scale_factor /* - 100 */) & 3; 626| | 627| |#ifndef FIXED_POINT 628| | scf = pow2sf_tab[exp/*+25*/] * pow2_table[frac]; 629| |#else 630| 2.56M| if (exp > 0) ------------------ | Branch (630:17): [True: 7.27k, False: 2.55M] ------------------ 631| 7.27k| sat_shift_mask = SAT_SHIFT_MASK(exp); ------------------ | | 286| 7.27k|#define SAT_SHIFT_MASK(E) (~0u << (31u - (E))) ------------------ 632| 2.56M|#endif 633| | 634| 5.35M| for (win = 0; win < ics->window_group_length[g]; win++) ------------------ | Branch (634:27): [True: 2.79M, False: 2.56M] ------------------ 635| 2.79M| { 636| 14.1M| for (bin = 0; bin < width; bin += 4) ------------------ | Branch (636:31): [True: 11.4M, False: 2.79M] ------------------ 637| 11.4M| { 638| 11.4M| uint16_t wb = wa + bin; 639| |#ifndef FIXED_POINT 640| | spec_data[wb+0] = iquant(quant_data[k+0], tab, &error) * scf; 641| | spec_data[wb+1] = iquant(quant_data[k+1], tab, &error) * scf; 642| | spec_data[wb+2] = iquant(quant_data[k+2], tab, &error) * scf; 643| | spec_data[wb+3] = iquant(quant_data[k+3], tab, &error) * scf; 644| |#else 645| 11.4M| real_t iq0 = iquant(quant_data[k+0], tab, &error); 646| 11.4M| real_t iq1 = iquant(quant_data[k+1], tab, &error); 647| 11.4M| real_t iq2 = iquant(quant_data[k+2], tab, &error); 648| 11.4M| real_t iq3 = iquant(quant_data[k+3], tab, &error); 649| | 650| 11.4M| if (exp == -32) ------------------ | Branch (650:25): [True: 8.23M, False: 3.16M] ------------------ 651| 8.23M| { 652| 8.23M| spec_data[wb+0] = 0; 653| 8.23M| spec_data[wb+1] = 0; 654| 8.23M| spec_data[wb+2] = 0; 655| 8.23M| spec_data[wb+3] = 0; 656| 8.23M| } else if (exp <= 0) { ------------------ | Branch (656:32): [True: 3.13M, False: 33.5k] ------------------ 657| 3.13M| spec_data[wb+0] = iq0 >> -exp; 658| 3.13M| spec_data[wb+1] = iq1 >> -exp; 659| 3.13M| spec_data[wb+2] = iq2 >> -exp; 660| 3.13M| spec_data[wb+3] = iq3 >> -exp; 661| 3.13M| } else { /* exp > 0 */ 662| 33.5k| spec_data[wb+0] = SAT_SHIFT(iq0, exp, sat_shift_mask); ------------------ | | 287| 33.5k|#define SAT_SHIFT(V,E,M) (((((V) >> ((E) + 1)) ^ (V)) & (M)) \ | | ------------------ | | | Branch (287:27): [True: 143, False: 33.4k] | | ------------------ | | 288| 33.5k| ? (((V) < 0) ? (int32_t)0x80000000 : 0x7FFFFFFF) \ | | ------------------ | | | Branch (288:8): [True: 126, False: 17] | | ------------------ | | 289| 33.5k| : ((int32_t)((uint32_t)(V) << (E)))) ------------------ 663| 33.5k| spec_data[wb+1] = SAT_SHIFT(iq1, exp, sat_shift_mask); ------------------ | | 287| 33.5k|#define SAT_SHIFT(V,E,M) (((((V) >> ((E) + 1)) ^ (V)) & (M)) \ | | ------------------ | | | Branch (287:27): [True: 409, False: 33.1k] | | ------------------ | | 288| 33.5k| ? (((V) < 0) ? (int32_t)0x80000000 : 0x7FFFFFFF) \ | | ------------------ | | | Branch (288:8): [True: 330, False: 79] | | ------------------ | | 289| 33.5k| : ((int32_t)((uint32_t)(V) << (E)))) ------------------ 664| 33.5k| spec_data[wb+2] = SAT_SHIFT(iq2, exp, sat_shift_mask); ------------------ | | 287| 33.5k|#define SAT_SHIFT(V,E,M) (((((V) >> ((E) + 1)) ^ (V)) & (M)) \ | | ------------------ | | | Branch (287:27): [True: 159, False: 33.3k] | | ------------------ | | 288| 33.5k| ? (((V) < 0) ? (int32_t)0x80000000 : 0x7FFFFFFF) \ | | ------------------ | | | Branch (288:8): [True: 135, False: 24] | | ------------------ | | 289| 33.5k| : ((int32_t)((uint32_t)(V) << (E)))) ------------------ 665| 33.5k| spec_data[wb+3] = SAT_SHIFT(iq3, exp, sat_shift_mask); ------------------ | | 287| 33.5k|#define SAT_SHIFT(V,E,M) (((((V) >> ((E) + 1)) ^ (V)) & (M)) \ | | ------------------ | | | Branch (287:27): [True: 452, False: 33.1k] | | ------------------ | | 288| 33.5k| ? (((V) < 0) ? (int32_t)0x80000000 : 0x7FFFFFFF) \ | | ------------------ | | | Branch (288:8): [True: 365, False: 87] | | ------------------ | | 289| 33.5k| : ((int32_t)((uint32_t)(V) << (E)))) ------------------ 666| 33.5k| } 667| 11.4M| if (frac != 0) ------------------ | Branch (667:25): [True: 69.9k, False: 11.3M] ------------------ 668| 69.9k| { 669| 69.9k| spec_data[wb+0] = MUL_C(spec_data[wb+0],pow2_table[frac]); ------------------ | | 241| 69.9k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ ------------------ 670| 69.9k| spec_data[wb+1] = MUL_C(spec_data[wb+1],pow2_table[frac]); ------------------ | | 241| 69.9k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ ------------------ 671| 69.9k| spec_data[wb+2] = MUL_C(spec_data[wb+2],pow2_table[frac]); ------------------ | | 241| 69.9k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ ------------------ 672| 69.9k| spec_data[wb+3] = MUL_C(spec_data[wb+3],pow2_table[frac]); ------------------ | | 241| 69.9k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 69.9k|#define COEF_BITS 28 | | ------------------ ------------------ 673| 69.9k| } 674| | 675| |//#define SCFS_PRINT 676| |#ifdef SCFS_PRINT 677| | printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+0]); 678| | printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+1]); 679| | printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+2]); 680| | printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+3]); 681| | //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+0]); 682| | //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+1]); 683| | //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+2]); 684| | //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+3]); 685| |#endif 686| 11.4M|#endif 687| | 688| 11.4M| gincrease += 4; 689| 11.4M| k += 4; 690| 11.4M| } 691| 2.79M| wa += win_inc; 692| 2.79M| } 693| 2.56M| j += width; 694| 2.56M| } 695| 114k| gindex += gincrease; 696| 114k| } 697| | 698| 45.3k| return error; 699| 45.3k|} specrec.c:iquant: 432| 45.6M|{ 433| 45.6M|#ifdef FIXED_POINT 434| |/* For FIXED_POINT the iq_table is prescaled by 3 bits (iq_table[]/8) */ 435| |/* BIG_IQ_TABLE allows you to use the full 8192 value table, if this is not 436| | * defined a 1026 value table and interpolation will be used 437| | */ 438| 45.6M|#ifndef BIG_IQ_TABLE 439| 45.6M| static const real_t errcorr[] = { 440| 45.6M| REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ 441| 45.6M| REAL_CONST(4.0/8.0), REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(4.0/8.0), REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(4.0/8.0), REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ REAL_CONST(4.0/8.0), REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0), ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ 442| 45.6M| REAL_CONST(0) ------------------ | | 59| 45.6M|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 45.6M|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 45.6M|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 0, Folded] | | ------------------ ------------------ 443| 45.6M| }; 444| 45.6M| real_t x1, x2; 445| 45.6M|#endif 446| 45.6M| int16_t sgn = 1; 447| | /* compute the magnitude in int: -q is evaluated as int and so does not 448| | wrap for q == -32768 the way an int16_t negation would, which keeps the 449| | comparison against IQ_TABLE_SIZE in range like the floating-point path */ 450| 45.6M| int aq = q; 451| | 452| 45.6M| if (aq < 0) ------------------ | Branch (452:9): [True: 57.8k, False: 45.5M] ------------------ 453| 57.8k| { 454| 57.8k| aq = -aq; 455| 57.8k| sgn = -1; 456| 57.8k| } 457| | 458| 45.6M| if (aq < IQ_TABLE_SIZE) ------------------ | | 8252| 45.6M|#define IQ_TABLE_SIZE 1026 ------------------ | Branch (458:9): [True: 45.6M, False: 705] ------------------ 459| 45.6M| { 460| |//#define IQUANT_PRINT 461| |#ifdef IQUANT_PRINT 462| | //printf("0x%.8X\n", sgn * tab[aq]); 463| | printf("%d\n", sgn * tab[aq]); 464| |#endif 465| 45.6M| return sgn * tab[aq]; 466| 45.6M| } 467| | 468| 705|#ifndef BIG_IQ_TABLE 469| 705| if (aq >= 8192) ------------------ | Branch (469:9): [True: 145, False: 560] ------------------ 470| 145| { 471| 145| *error = 17; 472| 145| return 0; 473| 145| } 474| | 475| | /* linear interpolation */ 476| 560| x1 = tab[aq>>3]; 477| 560| x2 = tab[(aq>>3) + 1]; 478| 560| return sgn * 16 * (MUL_R(errcorr[aq&7],(x2-x1)) + x1); ------------------ | | 239| 560| #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 560|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ | | #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS) | | ------------------ | | | | 45| 560|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | ------------------ ------------------ 479| |#else 480| | *error = 17; 481| | return 0; 482| |#endif 483| | 484| |#else 485| | if (q < 0) 486| | { 487| | /* tab contains a value for all possible q [0,8192] */ 488| | if (-q < IQ_TABLE_SIZE) 489| | return -tab[-q]; 490| | 491| | *error = 17; 492| | return 0; 493| | } else { 494| | /* tab contains a value for all possible q [0,8192] */ 495| | if (q < IQ_TABLE_SIZE) 496| | return tab[q]; 497| | 498| | *error = 17; 499| | return 0; 500| | } 501| |#endif 502| 705|} specrec.c:allocate_channel_pair: 804| 7.78k|{ 805| 7.78k| int mul = 1; 806| | 807| |#ifdef MAIN_DEC 808| | /* MAIN object type prediction */ 809| | if (hDecoder->object_type == MAIN) 810| | { 811| | /* allocate the state only when needed */ 812| | if (hDecoder->pred_stat[channel] == NULL) 813| | { 814| | hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state)); 815| | reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength); 816| | } 817| | if (hDecoder->pred_stat[paired_channel] == NULL) 818| | { 819| | hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state)); 820| | reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength); 821| | } 822| | } 823| |#endif 824| | 825| |#ifdef LTP_DEC 826| | if (is_ltp_ot(hDecoder->object_type)) 827| | { 828| | /* allocate the state only when needed */ 829| | if (hDecoder->lt_pred_stat[channel] == NULL) 830| | { 831| | hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t)); 832| | memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t)); 833| | } 834| | if (hDecoder->lt_pred_stat[paired_channel] == NULL) 835| | { 836| | hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t)); 837| | memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t)); 838| | } 839| | } 840| |#endif 841| | 842| 7.78k| { 843| 7.78k| mul = 1; 844| 7.78k|#ifdef SBR_DEC 845| 7.78k| hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0; 846| 7.78k| if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1)) ------------------ | Branch (846:13): [True: 5.93k, False: 1.84k] | Branch (846:50): [True: 1.19k, False: 651] ------------------ 847| 7.13k| { 848| | /* SBR requires 2 times as much output data */ 849| 7.13k| mul = 2; 850| 7.13k| hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1; 851| 7.13k| } 852| 7.78k|#endif 853| 7.78k| } 854| 7.78k| if (hDecoder->time_out[channel] != NULL) ------------------ | Branch (854:9): [True: 0, False: 7.78k] ------------------ 855| 0| { 856| 0| faad_free(hDecoder->time_out[channel]); 857| 0| hDecoder->time_out[channel] = NULL; 858| 0| } 859| 7.78k| if (hDecoder->time_out[paired_channel] != NULL) ------------------ | Branch (859:9): [True: 0, False: 7.78k] ------------------ 860| 0| { 861| 0| faad_free(hDecoder->time_out[paired_channel]); 862| 0| hDecoder->time_out[paired_channel] = NULL; 863| 0| } 864| 7.78k| hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t)); 865| 7.78k| memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t)); 866| 7.78k| hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t)); 867| 7.78k| memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t)); 868| | 869| 7.78k| if (hDecoder->fb_intermed[channel] != NULL) ------------------ | Branch (869:9): [True: 0, False: 7.78k] ------------------ 870| 0| { 871| 0| faad_free(hDecoder->fb_intermed[channel]); 872| 0| hDecoder->fb_intermed[channel] = NULL; 873| 0| } 874| 7.78k| if (hDecoder->fb_intermed[paired_channel] != NULL) ------------------ | Branch (874:9): [True: 0, False: 7.78k] ------------------ 875| 0| { 876| 0| faad_free(hDecoder->fb_intermed[paired_channel]); 877| 0| hDecoder->fb_intermed[paired_channel] = NULL; 878| 0| } 879| 7.78k| hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t)); 880| 7.78k| memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t)); 881| 7.78k| hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t)); 882| 7.78k| memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t)); 883| | 884| |#ifdef SSR_DEC 885| | if (hDecoder->object_type == SSR) 886| | { 887| | if (hDecoder->ssr_overlap[cpe->channel] == NULL) 888| | { 889| | hDecoder->ssr_overlap[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t)); 890| | memset(hDecoder->ssr_overlap[cpe->channel], 0, 2*hDecoder->frameLength*sizeof(real_t)); 891| | } 892| | if (hDecoder->ssr_overlap[cpe->paired_channel] == NULL) 893| | { 894| | hDecoder->ssr_overlap[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t)); 895| | memset(hDecoder->ssr_overlap[cpe->paired_channel], 0, 2*hDecoder->frameLength*sizeof(real_t)); 896| | } 897| | if (hDecoder->prev_fmd[cpe->channel] == NULL) 898| | { 899| | uint16_t k; 900| | hDecoder->prev_fmd[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t)); 901| | for (k = 0; k < 2*hDecoder->frameLength; k++) 902| | hDecoder->prev_fmd[cpe->channel][k] = REAL_CONST(-1); 903| | } 904| | if (hDecoder->prev_fmd[cpe->paired_channel] == NULL) 905| | { 906| | uint16_t k; 907| | hDecoder->prev_fmd[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t)); 908| | for (k = 0; k < 2*hDecoder->frameLength; k++) 909| | hDecoder->prev_fmd[cpe->paired_channel][k] = REAL_CONST(-1); 910| | } 911| | } 912| |#endif 913| | 914| 7.78k| return 0; 915| 7.78k|} GASpecificConfig: 111| 473|{ 112| 473| program_config pce; 113| | 114| | /* 1024 or 960 */ 115| 473| mp4ASC->frameLengthFlag = faad_get1bit(ld 116| 473| DEBUGVAR(1,138,"GASpecificConfig(): FrameLengthFlag")); 117| |#ifndef ALLOW_SMALL_FRAMELENGTH 118| | if (mp4ASC->frameLengthFlag == 1) 119| | return -3; 120| |#endif 121| | 122| 473| mp4ASC->dependsOnCoreCoder = faad_get1bit(ld 123| 473| DEBUGVAR(1,139,"GASpecificConfig(): DependsOnCoreCoder")); 124| 473| if (mp4ASC->dependsOnCoreCoder == 1) ------------------ | Branch (124:9): [True: 284, False: 189] ------------------ 125| 284| { 126| 284| mp4ASC->coreCoderDelay = (uint16_t)faad_getbits(ld, 14 127| 284| DEBUGVAR(1,140,"GASpecificConfig(): CoreCoderDelay")); 128| 284| } 129| | 130| 473| mp4ASC->extensionFlag = faad_get1bit(ld DEBUGVAR(1,141,"GASpecificConfig(): ExtensionFlag")); 131| 473| if (mp4ASC->channelsConfiguration == 0) ------------------ | Branch (131:9): [True: 127, False: 346] ------------------ 132| 127| { 133| 127| if (program_config_element(&pce, ld)) ------------------ | Branch (133:13): [True: 0, False: 127] ------------------ 134| 0| return -3; 135| | //mp4ASC->channelsConfiguration = pce.channels; 136| | 137| 127| if (pce_out != NULL) ------------------ | Branch (137:13): [True: 127, False: 0] ------------------ 138| 127| memcpy(pce_out, &pce, sizeof(program_config)); 139| | 140| | /* 141| | if (pce.num_valid_cc_elements) 142| | return -3; 143| | */ 144| 127| } 145| | 146| 473|#ifdef ERROR_RESILIENCE 147| 473| if (mp4ASC->extensionFlag == 1) ------------------ | Branch (147:9): [True: 258, False: 215] ------------------ 148| 258| { 149| | /* Error resilience not supported yet */ 150| 258| if (mp4ASC->objectTypeIndex >= ER_OBJECT_START) ------------------ | | 71| 258|#define ER_OBJECT_START 17 ------------------ | Branch (150:13): [True: 171, False: 87] ------------------ 151| 171| { 152| 171| mp4ASC->aacSectionDataResilienceFlag = faad_get1bit(ld 153| 171| DEBUGVAR(1,144,"GASpecificConfig(): aacSectionDataResilienceFlag")); 154| 171| mp4ASC->aacScalefactorDataResilienceFlag = faad_get1bit(ld 155| 171| DEBUGVAR(1,145,"GASpecificConfig(): aacScalefactorDataResilienceFlag")); 156| 171| mp4ASC->aacSpectralDataResilienceFlag = faad_get1bit(ld 157| 171| DEBUGVAR(1,146,"GASpecificConfig(): aacSpectralDataResilienceFlag")); 158| 171| } 159| | /* 1 bit: extensionFlag3 */ 160| 258| faad_getbits(ld, 1); 161| 258| } 162| 473|#endif 163| | 164| 473| return 0; 165| 473|} raw_data_block: 451| 1.86k|{ 452| 1.86k| uint8_t id_syn_ele; 453| 1.86k| uint8_t ele_this_frame = 0; 454| | 455| 1.86k| hDecoder->fr_channels = 0; 456| 1.86k| hDecoder->fr_ch_ele = 0; 457| 1.86k| hDecoder->first_syn_ele = 25; 458| 1.86k| hDecoder->has_lfe = 0; 459| | 460| 1.86k|#ifdef ERROR_RESILIENCE 461| 1.86k| if (hDecoder->object_type < ER_OBJECT_START) ------------------ | | 71| 1.86k|#define ER_OBJECT_START 17 ------------------ | Branch (461:9): [True: 1.56k, False: 294] ------------------ 462| 1.56k| { 463| 1.56k|#endif 464| | /* Table 4.4.3: raw_data_block() */ 465| 50.9k| while ((id_syn_ele = (uint8_t)faad_getbits(ld, LEN_SE_ID ------------------ | | 75| 50.9k|#define LEN_SE_ID 3 ------------------ | Branch (465:16): [True: 50.7k, False: 157] ------------------ 466| 50.9k| DEBUGVAR(1,4,"NeAACDecDecode(): id_syn_ele"))) != ID_END) ------------------ | | 93| 50.9k|#define ID_END 0x7 ------------------ 467| 50.7k| { 468| 50.7k| switch (id_syn_ele) { ------------------ | Branch (468:21): [True: 50.7k, False: 0] ------------------ 469| 28.2k| case ID_SCE: ------------------ | | 86| 28.2k|#define ID_SCE 0x0 ------------------ | Branch (469:13): [True: 28.2k, False: 22.5k] ------------------ 470| 28.2k| ele_this_frame++; 471| 28.2k| if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele; ------------------ | Branch (471:21): [True: 843, False: 27.3k] ------------------ 472| 28.2k| decode_sce_lfe(hDecoder, hInfo, ld, id_syn_ele); 473| 28.2k| if (hInfo->error > 0) ------------------ | Branch (473:21): [True: 1.09k, False: 27.1k] ------------------ 474| 1.09k| return; 475| 27.1k| break; 476| 27.1k| case ID_CPE: ------------------ | | 87| 8.63k|#define ID_CPE 0x1 ------------------ | Branch (476:13): [True: 8.63k, False: 42.1k] ------------------ 477| 8.63k| ele_this_frame++; 478| 8.63k| if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele; ------------------ | Branch (478:21): [True: 678, False: 7.96k] ------------------ 479| 8.63k| decode_cpe(hDecoder, hInfo, ld, id_syn_ele); 480| 8.63k| if (hInfo->error > 0) ------------------ | Branch (480:21): [True: 166, False: 8.47k] ------------------ 481| 166| return; 482| 8.47k| break; 483| 8.47k| case ID_LFE: ------------------ | | 89| 24|#define ID_LFE 0x3 ------------------ | Branch (483:13): [True: 24, False: 50.7k] ------------------ 484| 24|#ifdef DRM 485| 24| hInfo->error = 32; 486| |#else 487| | ele_this_frame++; 488| | hDecoder->has_lfe++; 489| | decode_sce_lfe(hDecoder, hInfo, ld, id_syn_ele); 490| |#endif 491| 24| if (hInfo->error > 0) ------------------ | Branch (491:21): [True: 24, False: 0] ------------------ 492| 24| return; 493| 0| break; 494| 48| case ID_CCE: /* not implemented yet, but skip the bits */ ------------------ | | 88| 48|#define ID_CCE 0x2 ------------------ | Branch (494:13): [True: 48, False: 50.7k] ------------------ 495| 48|#ifdef DRM 496| 48| hInfo->error = 32; 497| |#else 498| | ele_this_frame++; 499| |#ifdef COUPLING_DEC 500| | hInfo->error = coupling_channel_element(hDecoder, ld); 501| |#else 502| | hInfo->error = 6; 503| |#endif 504| |#endif 505| 48| if (hInfo->error > 0) ------------------ | Branch (505:21): [True: 48, False: 0] ------------------ 506| 48| return; 507| 0| break; 508| 13.5k| case ID_DSE: ------------------ | | 90| 13.5k|#define ID_DSE 0x4 ------------------ | Branch (508:13): [True: 13.5k, False: 37.2k] ------------------ 509| 13.5k| ele_this_frame++; 510| 13.5k| data_stream_element(hDecoder, ld); 511| 13.5k| break; 512| 90| case ID_PCE: ------------------ | | 91| 90|#define ID_PCE 0x5 ------------------ | Branch (512:13): [True: 90, False: 50.6k] ------------------ 513| 90| if (ele_this_frame != 0) ------------------ | Branch (513:21): [True: 45, False: 45] ------------------ 514| 45| { 515| 45| hInfo->error = 31; 516| 45| return; 517| 45| } 518| 45| ele_this_frame++; 519| | /* 14496-4: 5.6.4.1.2.1.3: */ 520| | /* program_configuration_element()'s in access units shall be ignored */ 521| 45| program_config_element(pce, ld); 522| | //if ((hInfo->error = program_config_element(pce, ld)) > 0) 523| | // return; 524| | //hDecoder->pce_set = 1; 525| 45| break; 526| 219| case ID_FIL: ------------------ | | 92| 219|#define ID_FIL 0x6 ------------------ | Branch (526:13): [True: 219, False: 50.5k] ------------------ 527| 219| ele_this_frame++; 528| | /* one sbr_info describes a channel_element not a channel! */ 529| | /* if we encounter SBR data here: error */ 530| | /* SBR data will be read directly in the SCE/LFE/CPE element */ 531| 219| if ((hInfo->error = fill_element(hDecoder, ld, drc ------------------ | Branch (531:21): [True: 30, False: 189] ------------------ 532| 219|#ifdef SBR_DEC 533| 219| , INVALID_SBR_ELEMENT ------------------ | | 110| 219|#define INVALID_SBR_ELEMENT 255 ------------------ 534| 219|#endif 535| 219| )) > 0) 536| 30| return; 537| 189| break; 538| 50.7k| } 539| 49.3k| if (ld->error != 0) ------------------ | Branch (539:17): [True: 0, False: 49.3k] ------------------ 540| 0| { 541| 0| hInfo->error = 32; 542| 0| return; 543| 0| } 544| 49.3k| } 545| 1.56k|#ifdef ERROR_RESILIENCE 546| 1.56k| } else { 547| | /* Table 262: er_raw_data_block() */ 548| 294| switch (hDecoder->channelConfiguration) 549| 294| { 550| 0| case 1: ------------------ | Branch (550:9): [True: 0, False: 294] ------------------ 551| 0| decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE); ------------------ | | 86| 0|#define ID_SCE 0x0 ------------------ 552| 0| if (hInfo->error > 0) ------------------ | Branch (552:17): [True: 0, False: 0] ------------------ 553| 0| return; 554| 0| break; 555| 19| case 2: ------------------ | Branch (555:9): [True: 19, False: 275] ------------------ 556| 19| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 19|#define ID_CPE 0x1 ------------------ 557| 19| if (hInfo->error > 0) ------------------ | Branch (557:17): [True: 10, False: 9] ------------------ 558| 10| return; 559| 9| break; 560| 12| case 3: ------------------ | Branch (560:9): [True: 12, False: 282] ------------------ 561| 12| decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE); ------------------ | | 86| 12|#define ID_SCE 0x0 ------------------ 562| 12| if (hInfo->error > 0) ------------------ | Branch (562:17): [True: 8, False: 4] ------------------ 563| 8| return; 564| 4| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 4|#define ID_CPE 0x1 ------------------ 565| 4| if (hInfo->error > 0) ------------------ | Branch (565:17): [True: 1, False: 3] ------------------ 566| 1| return; 567| 3| break; 568| 135| case 4: ------------------ | Branch (568:9): [True: 135, False: 159] ------------------ 569| 135| decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE); ------------------ | | 86| 135|#define ID_SCE 0x0 ------------------ 570| 135| if (hInfo->error > 0) ------------------ | Branch (570:17): [True: 3, False: 132] ------------------ 571| 3| return; 572| 132| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 132|#define ID_CPE 0x1 ------------------ 573| 132| if (hInfo->error > 0) ------------------ | Branch (573:17): [True: 6, False: 126] ------------------ 574| 6| return; 575| 126| decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE); ------------------ | | 86| 126|#define ID_SCE 0x0 ------------------ 576| 126| if (hInfo->error > 0) ------------------ | Branch (576:17): [True: 0, False: 126] ------------------ 577| 0| return; 578| 126| break; 579| 126| case 5: ------------------ | Branch (579:9): [True: 62, False: 232] ------------------ 580| 62| decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE); ------------------ | | 86| 62|#define ID_SCE 0x0 ------------------ 581| 62| if (hInfo->error > 0) ------------------ | Branch (581:17): [True: 17, False: 45] ------------------ 582| 17| return; 583| 45| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 45|#define ID_CPE 0x1 ------------------ 584| 45| if (hInfo->error > 0) ------------------ | Branch (584:17): [True: 5, False: 40] ------------------ 585| 5| return; 586| 40| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 40|#define ID_CPE 0x1 ------------------ 587| 40| if (hInfo->error > 0) ------------------ | Branch (587:17): [True: 2, False: 38] ------------------ 588| 2| return; 589| 38| break; 590| 38| case 6: ------------------ | Branch (590:9): [True: 2, False: 292] ------------------ 591| 2| decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE); ------------------ | | 86| 2|#define ID_SCE 0x0 ------------------ 592| 2| if (hInfo->error > 0) ------------------ | Branch (592:17): [True: 0, False: 2] ------------------ 593| 0| return; 594| 2| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 2|#define ID_CPE 0x1 ------------------ 595| 2| if (hInfo->error > 0) ------------------ | Branch (595:17): [True: 0, False: 2] ------------------ 596| 0| return; 597| 2| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 2|#define ID_CPE 0x1 ------------------ 598| 2| if (hInfo->error > 0) ------------------ | Branch (598:17): [True: 0, False: 2] ------------------ 599| 0| return; 600| 2| decode_sce_lfe(hDecoder, hInfo, ld, ID_LFE); ------------------ | | 89| 2|#define ID_LFE 0x3 ------------------ 601| 2| if (hInfo->error > 0) ------------------ | Branch (601:17): [True: 1, False: 1] ------------------ 602| 1| return; 603| 1| break; 604| 64| case 7: /* 8 channels */ ------------------ | Branch (604:9): [True: 64, False: 230] ------------------ 605| 64| decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE); ------------------ | | 86| 64|#define ID_SCE 0x0 ------------------ 606| 64| if (hInfo->error > 0) ------------------ | Branch (606:17): [True: 8, False: 56] ------------------ 607| 8| return; 608| 56| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 56|#define ID_CPE 0x1 ------------------ 609| 56| if (hInfo->error > 0) ------------------ | Branch (609:17): [True: 6, False: 50] ------------------ 610| 6| return; 611| 50| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 50|#define ID_CPE 0x1 ------------------ 612| 50| if (hInfo->error > 0) ------------------ | Branch (612:17): [True: 1, False: 49] ------------------ 613| 1| return; 614| 49| decode_cpe(hDecoder, hInfo, ld, ID_CPE); ------------------ | | 87| 49|#define ID_CPE 0x1 ------------------ 615| 49| if (hInfo->error > 0) ------------------ | Branch (615:17): [True: 1, False: 48] ------------------ 616| 1| return; 617| 48| decode_sce_lfe(hDecoder, hInfo, ld, ID_LFE); ------------------ | | 89| 48|#define ID_LFE 0x3 ------------------ 618| 48| if (hInfo->error > 0) ------------------ | Branch (618:17): [True: 15, False: 33] ------------------ 619| 15| return; 620| 33| break; 621| 33| default: ------------------ | Branch (621:9): [True: 0, False: 294] ------------------ 622| 0| hInfo->error = 7; 623| 0| return; 624| 294| } 625| |#if 0 626| | cnt = bits_to_decode() / 8; 627| | while (cnt >= 1) 628| | { 629| | cnt -= extension_payload(cnt); 630| | } 631| |#endif 632| 294| } 633| 367|#endif 634| | 635| | /* new in corrigendum 14496-3:2002 */ 636| 367|#ifdef DRM 637| 367| if (hDecoder->object_type != DRM_ER_LC ------------------ | | 48| 367|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ | Branch (637:9): [True: 367, False: 0] ------------------ 638| |#if 0 639| | && !hDecoder->latm_header_present 640| |#endif 641| 367| ) 642| 367|#endif 643| 367| { 644| 367| faad_byte_align(ld); 645| 367| } 646| | 647| 367| return; 648| 1.86k|} DRM_aac_scalable_main_element: 1299| 167|{ 1300| 167| uint8_t channels = hDecoder->fr_channels = 0; 1301| 167| uint8_t this_layer_stereo = (hDecoder->channelConfiguration > 1) ? 1 : 0; ------------------ | Branch (1301:33): [True: 44, False: 123] ------------------ 1302| 167| element cpe = {0}; 1303| 167| ic_stream *ics1 = &(cpe.ics1); 1304| 167| ic_stream *ics2 = &(cpe.ics2); 1305| 167| ALIGN int16_t spec_data1[1024] = {0}; 1306| 167| ALIGN int16_t spec_data2[1024] = {0}; 1307| | 1308| 167| (void)drc; /* TODO: remove unused parameter? */ 1309| 167| (void)pce; /* TODO: remove unused parameter? */ 1310| | 1311| 167| hDecoder->fr_ch_ele = 0; 1312| | 1313| 167| hInfo->error = DRM_aac_scalable_main_header(hDecoder, ics1, ics2, ld, this_layer_stereo); 1314| 167| if (hInfo->error > 0) ------------------ | Branch (1314:9): [True: 0, False: 167] ------------------ 1315| 0| return; 1316| | 1317| 167| cpe.common_window = 1; 1318| 167| if (this_layer_stereo) ------------------ | Branch (1318:9): [True: 44, False: 123] ------------------ 1319| 44| { 1320| 44| hDecoder->element_id[0] = ID_CPE; ------------------ | | 87| 44|#define ID_CPE 0x1 ------------------ 1321| 44| if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0) ------------------ | Branch (1321:13): [True: 22, False: 22] ------------------ 1322| 22| hDecoder->element_output_channels[hDecoder->fr_ch_ele] = 2; 1323| 123| } else { 1324| 123| hDecoder->element_id[0] = ID_SCE; ------------------ | | 86| 123|#define ID_SCE 0x0 ------------------ 1325| 123| } 1326| | 1327| 167| if (this_layer_stereo) ------------------ | Branch (1327:9): [True: 44, False: 123] ------------------ 1328| 44| { 1329| 44| cpe.channel = 0; 1330| 44| cpe.paired_channel = 1; 1331| 44| } 1332| | 1333| | 1334| | /* Stereo2 / Mono1 */ 1335| 167| ics1->tns_data_present = faad_get1bit(ld); 1336| | 1337| |#if defined(LTP_DEC) 1338| | ics1->ltp.data_present = faad_get1bit(ld); 1339| |#elif defined (DRM) 1340| 167| if(faad_get1bit(ld)) { ------------------ | Branch (1340:8): [True: 4, False: 163] ------------------ 1341| 4| hInfo->error = 26; 1342| 4| return; 1343| 4| } 1344| |#else 1345| | faad_get1bit(ld); 1346| |#endif 1347| | 1348| 163| hInfo->error = side_info(hDecoder, &cpe, ld, ics1, 1); 1349| 163| if (hInfo->error > 0) ------------------ | Branch (1349:9): [True: 8, False: 155] ------------------ 1350| 8| return; 1351| 155| if (this_layer_stereo) ------------------ | Branch (1351:9): [True: 35, False: 120] ------------------ 1352| 35| { 1353| | /* Stereo3 */ 1354| 35| ics2->tns_data_present = faad_get1bit(ld); 1355| |#ifdef LTP_DEC 1356| | ics1->ltp.data_present = 1357| |#endif 1358| 35| faad_get1bit(ld); 1359| 35| hInfo->error = side_info(hDecoder, &cpe, ld, ics2, 1); 1360| 35| if (hInfo->error > 0) ------------------ | Branch (1360:13): [True: 28, False: 7] ------------------ 1361| 28| return; 1362| 35| } 1363| | /* Stereo4 / Mono2 */ 1364| 127| if (ics1->tns_data_present) ------------------ | Branch (1364:9): [True: 35, False: 92] ------------------ 1365| 35| tns_data(ics1, &(ics1->tns), ld); 1366| 127| if (this_layer_stereo) ------------------ | Branch (1366:9): [True: 7, False: 120] ------------------ 1367| 7| { 1368| | /* Stereo5 */ 1369| 7| if (ics2->tns_data_present) ------------------ | Branch (1369:13): [True: 2, False: 5] ------------------ 1370| 2| tns_data(ics2, &(ics2->tns), ld); 1371| 7| } 1372| | 1373| 127|#ifdef DRM 1374| | /* CRC check */ 1375| 127| if (hDecoder->object_type == DRM_ER_LC) ------------------ | | 48| 127|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ | Branch (1375:9): [True: 127, False: 0] ------------------ 1376| 127| { 1377| 127| if ((hInfo->error = (uint8_t)faad_check_CRC(ld, (uint16_t)faad_get_processed_bits(ld) - 8)) > 0) ------------------ | Branch (1377:13): [True: 10, False: 117] ------------------ 1378| 10| return; 1379| 127| } 1380| 117|#endif 1381| | 1382| | /* Stereo6 / Mono3 */ 1383| | /* error resilient spectral data decoding */ 1384| 117| if ((hInfo->error = reordered_spectral_data(hDecoder, ics1, ld, spec_data1)) > 0) ------------------ | Branch (1384:9): [True: 0, False: 117] ------------------ 1385| 0| { 1386| 0| return; 1387| 0| } 1388| 117| if (this_layer_stereo) ------------------ | Branch (1388:9): [True: 0, False: 117] ------------------ 1389| 0| { 1390| | /* Stereo7 */ 1391| | /* error resilient spectral data decoding */ 1392| 0| if ((hInfo->error = reordered_spectral_data(hDecoder, ics2, ld, spec_data2)) > 0) ------------------ | Branch (1392:13): [True: 0, False: 0] ------------------ 1393| 0| { 1394| 0| return; 1395| 0| } 1396| 0| } 1397| | 1398| | 1399| 117|#ifdef DRM 1400| 117|#ifdef SBR_DEC 1401| | /* In case of DRM we need to read the SBR info before channel reconstruction */ 1402| 117| if ((hDecoder->sbr_present_flag == 1) && (hDecoder->object_type == DRM_ER_LC)) ------------------ | | 48| 117|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ | Branch (1402:9): [True: 117, False: 0] | Branch (1402:46): [True: 117, False: 0] ------------------ 1403| 117| { 1404| 117| bitfile ld_sbr = {0}; 1405| 117| uint32_t i; 1406| 117| uint16_t count = 0; 1407| 117| uint8_t *revbuffer; 1408| 117| uint8_t *prevbufstart; 1409| 117| uint8_t *pbufend; 1410| | 1411| | /* all forward bitreading should be finished at this point */ 1412| 117| uint32_t bitsconsumed = faad_get_processed_bits(ld); 1413| 117| uint32_t buffer_size = faad_origbitbuffer_size(ld); 1414| 117| uint8_t *buffer = (uint8_t*)faad_origbitbuffer(ld); 1415| | 1416| 117| if (bitsconsumed + 8 > buffer_size*8) ------------------ | Branch (1416:13): [True: 3, False: 114] ------------------ 1417| 3| { 1418| 3| hInfo->error = 14; 1419| 3| return; 1420| 3| } 1421| | 1422| 114| if (!hDecoder->sbr[0]) ------------------ | Branch (1422:13): [True: 110, False: 4] ------------------ 1423| 110| { 1424| 110| hDecoder->sbr[0] = sbrDecodeInit(hDecoder->frameLength, hDecoder->element_id[0], 1425| 110| 2*get_sample_rate(hDecoder->sf_index), 0 /* ds SBR */, 1); 1426| 110| } 1427| 114| if (!hDecoder->sbr[0]) ------------------ | Branch (1427:13): [True: 0, False: 114] ------------------ 1428| 0| { 1429| 0| hInfo->error = 19; 1430| 0| return; 1431| 0| } 1432| | 1433| | /* Reverse bit reading of SBR data in DRM audio frame */ 1434| 114| revbuffer = (uint8_t*)faad_malloc(buffer_size*sizeof(uint8_t)); 1435| 114| prevbufstart = revbuffer; 1436| 114| pbufend = &buffer[buffer_size - 1]; 1437| 2.07M| for (i = 0; i < buffer_size; i++) ------------------ | Branch (1437:21): [True: 2.07M, False: 114] ------------------ 1438| 2.07M| *prevbufstart++ = reverse_byte(*pbufend--); 1439| | 1440| | /* Set SBR data */ 1441| | /* consider 8 bits from AAC-CRC */ 1442| | /* SBR buffer size is original buffer size minus AAC buffer size */ 1443| 114| count = (uint16_t)bit2byte(buffer_size*8 - bitsconsumed); ------------------ | | 46| 114|#define bit2byte(a) ((a+7)>>BYTE_NUMBIT_LD) | | ------------------ | | | | 44| 114|#define BYTE_NUMBIT_LD 3 | | ------------------ ------------------ 1444| 114| faad_initbits(&ld_sbr, revbuffer, count); 1445| | 1446| 114| hDecoder->sbr[0]->sample_rate = get_sample_rate(hDecoder->sf_index); 1447| 114| hDecoder->sbr[0]->sample_rate *= 2; 1448| | 1449| 114| faad_getbits(&ld_sbr, 8); /* Skip 8-bit CRC */ 1450| | 1451| 114| hDecoder->sbr[0]->ret = sbr_extension_data(&ld_sbr, hDecoder->sbr[0], count, hDecoder->postSeekResetFlag); 1452| 114|#if (defined(PS_DEC) || defined(DRM_PS)) 1453| 114| if (hDecoder->sbr[0]->ps_used) ------------------ | Branch (1453:13): [True: 63, False: 51] ------------------ 1454| 63| { 1455| 63| hDecoder->ps_used[0] = 1; 1456| 63| hDecoder->ps_used_global = 1; 1457| 63| } 1458| 114|#endif 1459| | 1460| 114| if (ld_sbr.error) ------------------ | Branch (1460:13): [True: 1, False: 113] ------------------ 1461| 1| { 1462| 1| hDecoder->sbr[0]->ret = 1; 1463| 1| } 1464| | 1465| | /* check CRC */ 1466| | /* no need to check it if there was already an error */ 1467| 114| if (hDecoder->sbr[0]->ret == 0) ------------------ | Branch (1467:13): [True: 79, False: 35] ------------------ 1468| 79| hDecoder->sbr[0]->ret = (uint8_t)faad_check_CRC(&ld_sbr, (uint16_t)faad_get_processed_bits(&ld_sbr) - 8); 1469| | 1470| | /* SBR data was corrupted, disable it until the next header */ 1471| 114| if (hDecoder->sbr[0]->ret != 0) ------------------ | Branch (1471:13): [True: 45, False: 69] ------------------ 1472| 45| { 1473| 45| hDecoder->sbr[0]->header_count = 0; 1474| 45| } 1475| | 1476| 114| faad_endbits(&ld_sbr); 1477| | 1478| 114| if (revbuffer) ------------------ | Branch (1478:13): [True: 114, False: 0] ------------------ 1479| 114| faad_free(revbuffer); 1480| 114| } 1481| 114|#endif 1482| 114|#endif 1483| | 1484| 114| if (this_layer_stereo) ------------------ | Branch (1484:9): [True: 0, False: 114] ------------------ 1485| 0| { 1486| 0| hInfo->error = reconstruct_channel_pair(hDecoder, ics1, ics2, &cpe, spec_data1, spec_data2); 1487| 0| if (hInfo->error > 0) ------------------ | Branch (1487:13): [True: 0, False: 0] ------------------ 1488| 0| return; 1489| 114| } else { 1490| 114| hInfo->error = reconstruct_single_channel(hDecoder, ics1, &cpe, spec_data1); 1491| 114| if (hInfo->error > 0) ------------------ | Branch (1491:13): [True: 0, False: 114] ------------------ 1492| 0| return; 1493| 114| } 1494| | 1495| | /* map output channels position to internal data channels */ 1496| 114| if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2) ------------------ | Branch (1496:9): [True: 114, False: 0] ------------------ 1497| 114| { 1498| | /* this might be faulty when pce_set is true */ 1499| 114| hDecoder->internal_channel[channels] = channels; 1500| 114| hDecoder->internal_channel[channels+1] = channels+1; 1501| 114| } else { 1502| 0| hDecoder->internal_channel[channels] = channels; 1503| 0| } 1504| | 1505| 114| hDecoder->fr_channels += hDecoder->element_output_channels[hDecoder->fr_ch_ele]; 1506| 114| hDecoder->fr_ch_ele++; 1507| | 1508| 114| return; 1509| 114|} get_adif_header: 2401| 43|{ 2402| 43| uint8_t i; 2403| | 2404| | /* adif_id[0] = */ faad_getbits(ld, 8 2405| 43| DEBUGVAR(1,106,"get_adif_header(): adif_id[0]")); 2406| 43| /* adif_id[1] = */ faad_getbits(ld, 8 2407| 43| DEBUGVAR(1,107,"get_adif_header(): adif_id[1]")); 2408| 43| /* adif_id[2] = */ faad_getbits(ld, 8 2409| 43| DEBUGVAR(1,108,"get_adif_header(): adif_id[2]")); 2410| 43| /* adif_id[3] = */ faad_getbits(ld, 8 2411| 43| DEBUGVAR(1,109,"get_adif_header(): adif_id[3]")); 2412| 43| adif->copyright_id_present = faad_get1bit(ld 2413| 43| DEBUGVAR(1,110,"get_adif_header(): copyright_id_present")); 2414| 43| if(adif->copyright_id_present) ------------------ | Branch (2414:8): [True: 17, False: 26] ------------------ 2415| 17| { 2416| 170| for (i = 0; i < 72/8; i++) ------------------ | Branch (2416:21): [True: 153, False: 17] ------------------ 2417| 153| { 2418| 153| adif->copyright_id[i] = (int8_t)faad_getbits(ld, 8 2419| 153| DEBUGVAR(1,111,"get_adif_header(): copyright_id")); 2420| 153| } 2421| 17| adif->copyright_id[i] = 0; 2422| 17| } 2423| 43| adif->original_copy = faad_get1bit(ld 2424| 43| DEBUGVAR(1,112,"get_adif_header(): original_copy")); 2425| 43| adif->home = faad_get1bit(ld 2426| 43| DEBUGVAR(1,113,"get_adif_header(): home")); 2427| 43| adif->bitstream_type = faad_get1bit(ld 2428| 43| DEBUGVAR(1,114,"get_adif_header(): bitstream_type")); 2429| 43| adif->bitrate = faad_getbits(ld, 23 2430| 43| DEBUGVAR(1,115,"get_adif_header(): bitrate")); 2431| 43| adif->num_program_config_elements = (uint8_t)faad_getbits(ld, 4 2432| 43| DEBUGVAR(1,116,"get_adif_header(): num_program_config_elements")); 2433| | 2434| 715| for (i = 0; i < adif->num_program_config_elements + 1; i++) ------------------ | Branch (2434:17): [True: 672, False: 43] ------------------ 2435| 672| { 2436| 672| if(adif->bitstream_type == 0) ------------------ | Branch (2436:12): [True: 112, False: 560] ------------------ 2437| 112| { 2438| 112| adif->adif_buffer_fullness = faad_getbits(ld, 20 2439| 112| DEBUGVAR(1,117,"get_adif_header(): adif_buffer_fullness")); 2440| 560| } else { 2441| 560| adif->adif_buffer_fullness = 0; 2442| 560| } 2443| | 2444| 672| program_config_element(&adif->pce[i], ld); 2445| 672| } 2446| 43|} adts_frame: 2450| 1.03k|{ 2451| | /* faad_byte_align(ld); */ 2452| 1.03k| if (adts_fixed_header(adts, ld)) ------------------ | Branch (2452:9): [True: 1.01k, False: 14] ------------------ 2453| 1.01k| return 5; 2454| 14| adts_variable_header(adts, ld); 2455| 14| adts_error_check(adts, ld); 2456| | 2457| 14| return 0; 2458| 1.03k|} syntax.c:program_config_element: 175| 844|{ 176| 844| uint8_t i; 177| | 178| 844| memset(pce, 0, sizeof(program_config)); 179| | 180| 844| pce->channels = 0; 181| | 182| 844| pce->element_instance_tag = (uint8_t)faad_getbits(ld, 4 183| 844| DEBUGVAR(1,10,"program_config_element(): element_instance_tag")); 184| | 185| 844| pce->object_type = (uint8_t)faad_getbits(ld, 2 186| 844| DEBUGVAR(1,11,"program_config_element(): object_type")); 187| 844| pce->sf_index = (uint8_t)faad_getbits(ld, 4 188| 844| DEBUGVAR(1,12,"program_config_element(): sf_index")); 189| 844| pce->num_front_channel_elements = (uint8_t)faad_getbits(ld, 4 190| 844| DEBUGVAR(1,13,"program_config_element(): num_front_channel_elements")); 191| 844| pce->num_side_channel_elements = (uint8_t)faad_getbits(ld, 4 192| 844| DEBUGVAR(1,14,"program_config_element(): num_side_channel_elements")); 193| 844| pce->num_back_channel_elements = (uint8_t)faad_getbits(ld, 4 194| 844| DEBUGVAR(1,15,"program_config_element(): num_back_channel_elements")); 195| 844| pce->num_lfe_channel_elements = (uint8_t)faad_getbits(ld, 2 196| 844| DEBUGVAR(1,16,"program_config_element(): num_lfe_channel_elements")); 197| 844| pce->num_assoc_data_elements = (uint8_t)faad_getbits(ld, 3 198| 844| DEBUGVAR(1,17,"program_config_element(): num_assoc_data_elements")); 199| 844| pce->num_valid_cc_elements = (uint8_t)faad_getbits(ld, 4 200| 844| DEBUGVAR(1,18,"program_config_element(): num_valid_cc_elements")); 201| | 202| 844| pce->mono_mixdown_present = faad_get1bit(ld 203| 844| DEBUGVAR(1,19,"program_config_element(): mono_mixdown_present")); 204| 844| if (pce->mono_mixdown_present == 1) ------------------ | Branch (204:9): [True: 301, False: 543] ------------------ 205| 301| { 206| 301| pce->mono_mixdown_element_number = (uint8_t)faad_getbits(ld, 4 207| 301| DEBUGVAR(1,20,"program_config_element(): mono_mixdown_element_number")); 208| 301| } 209| | 210| 844| pce->stereo_mixdown_present = faad_get1bit(ld 211| 844| DEBUGVAR(1,21,"program_config_element(): stereo_mixdown_present")); 212| 844| if (pce->stereo_mixdown_present == 1) ------------------ | Branch (212:9): [True: 296, False: 548] ------------------ 213| 296| { 214| 296| pce->stereo_mixdown_element_number = (uint8_t)faad_getbits(ld, 4 215| 296| DEBUGVAR(1,22,"program_config_element(): stereo_mixdown_element_number")); 216| 296| } 217| | 218| 844| pce->matrix_mixdown_idx_present = faad_get1bit(ld 219| 844| DEBUGVAR(1,23,"program_config_element(): matrix_mixdown_idx_present")); 220| 844| if (pce->matrix_mixdown_idx_present == 1) ------------------ | Branch (220:9): [True: 259, False: 585] ------------------ 221| 259| { 222| 259| pce->matrix_mixdown_idx = (uint8_t)faad_getbits(ld, 2 223| 259| DEBUGVAR(1,24,"program_config_element(): matrix_mixdown_idx")); 224| 259| pce->pseudo_surround_enable = faad_get1bit(ld 225| 259| DEBUGVAR(1,25,"program_config_element(): pseudo_surround_enable")); 226| 259| } 227| | 228| 3.85k| for (i = 0; i < pce->num_front_channel_elements; i++) ------------------ | Branch (228:17): [True: 3.00k, False: 844] ------------------ 229| 3.00k| { 230| 3.00k| pce->front_element_is_cpe[i] = faad_get1bit(ld 231| 3.00k| DEBUGVAR(1,26,"program_config_element(): front_element_is_cpe")); 232| 3.00k| pce->front_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4 233| 3.00k| DEBUGVAR(1,27,"program_config_element(): front_element_tag_select")); 234| | 235| 3.00k| if (pce->front_element_is_cpe[i] & 1) ------------------ | Branch (235:13): [True: 972, False: 2.03k] ------------------ 236| 972| { 237| 972| pce->cpe_channel[pce->front_element_tag_select[i]] = pce->channels; 238| 972| pce->num_front_channels += 2; 239| 972| pce->channels += 2; 240| 2.03k| } else { 241| 2.03k| pce->sce_channel[pce->front_element_tag_select[i]] = pce->channels; 242| 2.03k| pce->num_front_channels++; 243| 2.03k| pce->channels++; 244| 2.03k| } 245| 3.00k| } 246| | 247| 4.73k| for (i = 0; i < pce->num_side_channel_elements; i++) ------------------ | Branch (247:17): [True: 3.89k, False: 844] ------------------ 248| 3.89k| { 249| 3.89k| pce->side_element_is_cpe[i] = faad_get1bit(ld 250| 3.89k| DEBUGVAR(1,28,"program_config_element(): side_element_is_cpe")); 251| 3.89k| pce->side_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4 252| 3.89k| DEBUGVAR(1,29,"program_config_element(): side_element_tag_select")); 253| | 254| 3.89k| if (pce->side_element_is_cpe[i] & 1) ------------------ | Branch (254:13): [True: 922, False: 2.96k] ------------------ 255| 922| { 256| 922| pce->cpe_channel[pce->side_element_tag_select[i]] = pce->channels; 257| 922| pce->num_side_channels += 2; 258| 922| pce->channels += 2; 259| 2.96k| } else { 260| 2.96k| pce->sce_channel[pce->side_element_tag_select[i]] = pce->channels; 261| 2.96k| pce->num_side_channels++; 262| 2.96k| pce->channels++; 263| 2.96k| } 264| 3.89k| } 265| | 266| 3.68k| for (i = 0; i < pce->num_back_channel_elements; i++) ------------------ | Branch (266:17): [True: 2.84k, False: 844] ------------------ 267| 2.84k| { 268| 2.84k| pce->back_element_is_cpe[i] = faad_get1bit(ld 269| 2.84k| DEBUGVAR(1,30,"program_config_element(): back_element_is_cpe")); 270| 2.84k| pce->back_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4 271| 2.84k| DEBUGVAR(1,31,"program_config_element(): back_element_tag_select")); 272| | 273| 2.84k| if (pce->back_element_is_cpe[i] & 1) ------------------ | Branch (273:13): [True: 828, False: 2.01k] ------------------ 274| 828| { 275| 828| pce->cpe_channel[pce->back_element_tag_select[i]] = pce->channels; 276| 828| pce->channels += 2; 277| 828| pce->num_back_channels += 2; 278| 2.01k| } else { 279| 2.01k| pce->sce_channel[pce->back_element_tag_select[i]] = pce->channels; 280| 2.01k| pce->num_back_channels++; 281| 2.01k| pce->channels++; 282| 2.01k| } 283| 2.84k| } 284| | 285| 1.56k| for (i = 0; i < pce->num_lfe_channel_elements; i++) ------------------ | Branch (285:17): [True: 716, False: 844] ------------------ 286| 716| { 287| 716| pce->lfe_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4 288| 716| DEBUGVAR(1,32,"program_config_element(): lfe_element_tag_select")); 289| | 290| 716| pce->sce_channel[pce->lfe_element_tag_select[i]] = pce->channels; 291| 716| pce->num_lfe_channels++; 292| 716| pce->channels++; 293| 716| } 294| | 295| 2.07k| for (i = 0; i < pce->num_assoc_data_elements; i++) ------------------ | Branch (295:17): [True: 1.22k, False: 844] ------------------ 296| 1.22k| pce->assoc_data_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4 297| 1.22k| DEBUGVAR(1,33,"program_config_element(): assoc_data_element_tag_select")); 298| | 299| 4.40k| for (i = 0; i < pce->num_valid_cc_elements; i++) ------------------ | Branch (299:17): [True: 3.56k, False: 844] ------------------ 300| 3.56k| { 301| 3.56k| pce->cc_element_is_ind_sw[i] = faad_get1bit(ld 302| 3.56k| DEBUGVAR(1,34,"program_config_element(): cc_element_is_ind_sw")); 303| 3.56k| pce->valid_cc_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4 304| 3.56k| DEBUGVAR(1,35,"program_config_element(): valid_cc_element_tag_select")); 305| 3.56k| } 306| | 307| 844| faad_byte_align(ld); 308| | 309| 844| pce->comment_field_bytes = (uint8_t)faad_getbits(ld, 8 310| 844| DEBUGVAR(1,36,"program_config_element(): comment_field_bytes")); 311| | 312| 7.77k| for (i = 0; i < pce->comment_field_bytes; i++) ------------------ | Branch (312:17): [True: 6.93k, False: 844] ------------------ 313| 6.93k| { 314| 6.93k| pce->comment_field_data[i] = (uint8_t)faad_getbits(ld, 8 315| 6.93k| DEBUGVAR(1,37,"program_config_element(): comment_field_data")); 316| 6.93k| } 317| 844| pce->comment_field_data[i] = 0; 318| | 319| 844| if (pce->channels > MAX_CHANNELS) ------------------ | | 43| 844|#define MAX_CHANNELS 64 ------------------ | Branch (319:9): [True: 32, False: 812] ------------------ 320| 32| return 22; 321| | 322| 812| return 0; 323| 844|} syntax.c:decode_sce_lfe: 328| 28.6k|{ 329| 28.6k| uint8_t channels = hDecoder->fr_channels; 330| 28.6k| uint8_t tag = 0; 331| | 332| | /* One or two channels are used; 333| | exact number will be known after single_lfe_channel_element 334| | */ 335| 28.6k| if (channels+2 > MAX_CHANNELS) ------------------ | | 43| 28.6k|#define MAX_CHANNELS 64 ------------------ | Branch (335:9): [True: 811, False: 27.8k] ------------------ 336| 811| { 337| 811| hInfo->error = 12; 338| 811| return; 339| 811| } 340| 27.8k| if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS) ------------------ | | 44| 27.8k|#define MAX_SYNTAX_ELEMENTS 48 ------------------ | Branch (340:9): [True: 0, False: 27.8k] ------------------ 341| 0| { 342| 0| hInfo->error = 13; 343| 0| return; 344| 0| } 345| | 346| | /* for SCE hDecoder->element_output_channels[] is not set here because this 347| | can become 2 when some form of Parametric Stereo coding is used 348| | */ 349| | 350| 27.8k| if (hDecoder->element_id[hDecoder->fr_ch_ele] != INVALID_ELEMENT_ID && ------------------ | | 94| 55.7k|#define INVALID_ELEMENT_ID 255 ------------------ | Branch (350:9): [True: 5.43k, False: 22.4k] ------------------ 351| 5.43k| hDecoder->element_id[hDecoder->fr_ch_ele] != id_syn_ele) ------------------ | Branch (351:9): [True: 45, False: 5.38k] ------------------ 352| 45| { 353| | /* element inconsistency */ 354| 45| hInfo->error = 21; 355| 45| return; 356| 45| } 357| | 358| | /* save the syntax element id */ 359| 27.8k| hDecoder->element_id[hDecoder->fr_ch_ele] = id_syn_ele; 360| | 361| | /* decode the element */ 362| 27.8k| hInfo->error = single_lfe_channel_element(hDecoder, ld, channels, &tag); 363| | 364| | /* map output channels position to internal data channels */ 365| 27.8k| if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2) ------------------ | Branch (365:9): [True: 27.5k, False: 237] ------------------ 366| 27.5k| { 367| | /* this might be faulty when pce_set is true */ 368| 27.5k| hDecoder->internal_channel[channels] = channels; 369| 27.5k| hDecoder->internal_channel[channels+1] = channels+1; 370| 27.5k| } else { 371| 237| if (hDecoder->pce_set) ------------------ | Branch (371:13): [True: 38, False: 199] ------------------ 372| 38| { 373| 38| if (hDecoder->pce.channels > MAX_CHANNELS) ------------------ | | 43| 38|#define MAX_CHANNELS 64 ------------------ | Branch (373:17): [True: 0, False: 38] ------------------ 374| 0| { 375| 0| hInfo->error = 22; 376| 0| return; 377| 0| } 378| 38| hDecoder->internal_channel[hDecoder->pce.sce_channel[tag]] = channels; 379| 199| } else { 380| 199| hDecoder->internal_channel[channels] = channels; 381| 199| } 382| 237| } 383| | 384| 27.8k| hDecoder->fr_channels += hDecoder->element_output_channels[hDecoder->fr_ch_ele]; 385| 27.8k| hDecoder->fr_ch_ele++; 386| 27.8k|} syntax.c:single_lfe_channel_element: 654| 27.8k|{ 655| 27.8k| uint8_t retval = 0; 656| 27.8k| element sce = {0}; 657| 27.8k| ic_stream *ics = &(sce.ics1); 658| 27.8k| ALIGN int16_t spec_data[1024] = {0}; 659| | 660| 27.8k| sce.element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG ------------------ | | 76| 27.8k|#define LEN_TAG 4 ------------------ 661| 27.8k| DEBUGVAR(1,38,"single_lfe_channel_element(): element_instance_tag")); 662| | 663| 27.8k| *tag = sce.element_instance_tag; 664| 27.8k| sce.channel = channel; 665| 27.8k| sce.paired_channel = -1; 666| | 667| 27.8k| retval = individual_channel_stream(hDecoder, &sce, ld, ics, 0, spec_data); 668| 27.8k| if (retval > 0) ------------------ | Branch (668:9): [True: 248, False: 27.5k] ------------------ 669| 248| return retval; 670| | 671| | /* IS not allowed in single channel */ 672| 27.5k| if (ics->is_used) ------------------ | Branch (672:9): [True: 10, False: 27.5k] ------------------ 673| 10| return 32; 674| | 675| 27.5k|#ifdef SBR_DEC 676| | /* check if next bitstream element is a fill element */ 677| | /* if so, read it now so SBR decoding can be done in case of a file with SBR */ 678| 27.5k| if (faad_showbits(ld, LEN_SE_ID) == ID_FIL) ------------------ | | 75| 27.5k|#define LEN_SE_ID 3 ------------------ if (faad_showbits(ld, LEN_SE_ID) == ID_FIL) ------------------ | | 92| 27.5k|#define ID_FIL 0x6 ------------------ | Branch (678:9): [True: 8.16k, False: 19.3k] ------------------ 679| 8.16k| { 680| 8.16k| faad_flushbits(ld, LEN_SE_ID); ------------------ | | 75| 8.16k|#define LEN_SE_ID 3 ------------------ 681| | 682| | /* one sbr_info describes a channel_element not a channel! */ 683| 8.16k| if ((retval = fill_element(hDecoder, ld, hDecoder->drc, hDecoder->fr_ch_ele)) > 0) ------------------ | Branch (683:13): [True: 24, False: 8.14k] ------------------ 684| 24| { 685| 24| return retval; 686| 24| } 687| 8.16k| } 688| 27.5k|#endif 689| | 690| | /* noiseless coding is done, spectral reconstruction is done now */ 691| 27.5k| retval = reconstruct_single_channel(hDecoder, ics, &sce, spec_data); 692| 27.5k| if (retval > 0) ------------------ | Branch (692:9): [True: 10, False: 27.5k] ------------------ 693| 10| return retval; 694| | 695| 27.5k| return 0; 696| 27.5k|} syntax.c:individual_channel_stream: 1674| 45.7k|{ 1675| 45.7k| uint8_t result; 1676| | 1677| 45.7k| result = side_info(hDecoder, ele, ld, ics, scal_flag); 1678| 45.7k| if (result > 0) ------------------ | Branch (1678:9): [True: 352, False: 45.3k] ------------------ 1679| 352| return result; 1680| | 1681| 45.3k| if (hDecoder->object_type >= ER_OBJECT_START) ------------------ | | 71| 45.3k|#define ER_OBJECT_START 17 ------------------ | Branch (1681:9): [True: 1.16k, False: 44.1k] ------------------ 1682| 1.16k| { 1683| 1.16k| if (ics->tns_data_present) ------------------ | Branch (1683:13): [True: 23, False: 1.13k] ------------------ 1684| 23| tns_data(ics, &(ics->tns), ld); 1685| 1.16k| } 1686| | 1687| 45.3k|#ifdef DRM 1688| | /* CRC check */ 1689| 45.3k| if (hDecoder->object_type == DRM_ER_LC) ------------------ | | 48| 45.3k|#define DRM_ER_LC 27 /* special object type for DRM */ ------------------ | Branch (1689:9): [True: 0, False: 45.3k] ------------------ 1690| 0| { 1691| 0| if ((result = (uint8_t)faad_check_CRC(ld, (uint16_t)faad_get_processed_bits(ld) - 8)) > 0) ------------------ | Branch (1691:13): [True: 0, False: 0] ------------------ 1692| 0| return result; 1693| 0| } 1694| 45.3k|#endif 1695| | 1696| 45.3k|#ifdef ERROR_RESILIENCE 1697| 45.3k| if (hDecoder->aacSpectralDataResilienceFlag) ------------------ | Branch (1697:9): [True: 359, False: 44.9k] ------------------ 1698| 359| { 1699| | /* error resilient spectral data decoding */ 1700| 359| if ((result = reordered_spectral_data(hDecoder, ics, ld, spec_data)) > 0) ------------------ | Branch (1700:13): [True: 4, False: 355] ------------------ 1701| 4| { 1702| 4| return result; 1703| 4| } 1704| 44.9k| } else { 1705| 44.9k|#endif 1706| | /* decode the spectral data */ 1707| 44.9k| if ((result = spectral_data(hDecoder, ics, ld, spec_data)) > 0) ------------------ | Branch (1707:13): [True: 1, False: 44.9k] ------------------ 1708| 1| { 1709| 1| return result; 1710| 1| } 1711| 44.9k|#ifdef ERROR_RESILIENCE 1712| 44.9k| } 1713| 45.3k|#endif 1714| | 1715| | /* pulse coding reconstruction */ 1716| 45.3k| if (ics->pulse_data_present) ------------------ | Branch (1716:9): [True: 1.05k, False: 44.2k] ------------------ 1717| 1.05k| { 1718| 1.05k| if (ics->window_sequence != EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 1.05k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (1718:13): [True: 1.04k, False: 8] ------------------ 1719| 1.04k| { 1720| 1.04k| if ((result = pulse_decode(ics, spec_data, hDecoder->frameLength)) > 0) ------------------ | Branch (1720:17): [True: 0, False: 1.04k] ------------------ 1721| 0| return result; 1722| 1.04k| } else { 1723| 8| return 2; /* pulse coding not allowed for short blocks */ 1724| 8| } 1725| 1.05k| } 1726| | 1727| 45.3k| return 0; 1728| 45.3k|} syntax.c:spectral_data: 2158| 44.9k|{ 2159| 44.9k| int8_t i; 2160| 44.9k| uint8_t g; 2161| 44.9k| uint16_t inc, k, p = 0; 2162| 44.9k| uint8_t groups = 0; 2163| 44.9k| uint8_t sect_cb; 2164| 44.9k| uint8_t result; 2165| 44.9k| uint16_t nshort = hDecoder->frameLength/8; 2166| | 2167| |#ifdef PROFILE 2168| | int64_t count = faad_get_ts(); 2169| |#endif 2170| | 2171| 159k| for(g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (2171:16): [True: 114k, False: 44.9k] ------------------ 2172| 114k| { 2173| 114k| p = groups*nshort; 2174| | 2175| 122k| for (i = 0; i < ics->num_sec[g]; i++) ------------------ | Branch (2175:21): [True: 8.07k, False: 114k] ------------------ 2176| 8.07k| { 2177| 8.07k| sect_cb = ics->sect_cb[g][i]; 2178| | 2179| 8.07k| inc = (sect_cb >= FIRST_PAIR_HCB) ? 2 : 4; ------------------ | | 102| 8.07k|#define FIRST_PAIR_HCB 5 ------------------ | Branch (2179:19): [True: 3.54k, False: 4.52k] ------------------ 2180| | 2181| 8.07k| switch (sect_cb) 2182| 8.07k| { 2183| 3.40k| case ZERO_HCB: ------------------ | | 101| 3.40k|#define ZERO_HCB 0 ------------------ | Branch (2183:13): [True: 3.40k, False: 4.66k] ------------------ 2184| 3.40k| case NOISE_HCB: ------------------ | | 106| 3.40k|#define NOISE_HCB 13 ------------------ | Branch (2184:13): [True: 0, False: 8.07k] ------------------ 2185| 3.58k| case INTENSITY_HCB: ------------------ | | 108| 3.58k|#define INTENSITY_HCB 15 ------------------ | Branch (2185:13): [True: 174, False: 7.90k] ------------------ 2186| 4.01k| case INTENSITY_HCB2: ------------------ | | 107| 4.01k|#define INTENSITY_HCB2 14 ------------------ | Branch (2186:13): [True: 432, False: 7.64k] ------------------ 2187| |//#define SD_PRINT 2188| |#ifdef SD_PRINT 2189| | { 2190| | int j; 2191| | for (j = ics->sect_sfb_offset[g][ics->sect_start[g][i]]; j < ics->sect_sfb_offset[g][ics->sect_end[g][i]]; j++) 2192| | { 2193| | printf("%d\n", 0); 2194| | } 2195| | } 2196| |#endif 2197| |//#define SFBO_PRINT 2198| |#ifdef SFBO_PRINT 2199| | printf("%d\n", ics->sect_sfb_offset[g][ics->sect_start[g][i]]); 2200| |#endif 2201| 4.01k| p += (ics->sect_sfb_offset[g][ics->sect_end[g][i]] - 2202| 4.01k| ics->sect_sfb_offset[g][ics->sect_start[g][i]]); 2203| 4.01k| break; 2204| 4.06k| default: ------------------ | Branch (2204:13): [True: 4.06k, False: 4.01k] ------------------ 2205| |#ifdef SFBO_PRINT 2206| | printf("%d\n", ics->sect_sfb_offset[g][ics->sect_start[g][i]]); 2207| |#endif 2208| 4.06k| for (k = ics->sect_sfb_offset[g][ics->sect_start[g][i]]; 2209| 142k| k < ics->sect_sfb_offset[g][ics->sect_end[g][i]]; k += inc) ------------------ | Branch (2209:22): [True: 138k, False: 4.06k] ------------------ 2210| 138k| { 2211| 138k| if ((result = huffman_spectral_data(sect_cb, ld, &spectral_data[p])) > 0) ------------------ | Branch (2211:25): [True: 1, False: 138k] ------------------ 2212| 1| return result; 2213| |#ifdef SD_PRINT 2214| | { 2215| | int j; 2216| | for (j = p; j < p+inc; j++) 2217| | { 2218| | printf("%d\n", spectral_data[j]); 2219| | } 2220| | } 2221| |#endif 2222| 138k| p += inc; 2223| 138k| } 2224| 4.06k| break; 2225| 8.07k| } 2226| 8.07k| } 2227| 114k| groups += ics->window_group_length[g]; 2228| 114k| } 2229| | 2230| |#ifdef PROFILE 2231| | count = faad_get_ts() - count; 2232| | hDecoder->spectral_cycles += count; 2233| |#endif 2234| | 2235| 44.9k| return 0; 2236| 44.9k|} syntax.c:decode_cpe: 390| 9.03k|{ 391| 9.03k| uint8_t channels = hDecoder->fr_channels; 392| 9.03k| uint8_t tag = 0; 393| | 394| 9.03k| if (channels+2 > MAX_CHANNELS) ------------------ | | 43| 9.03k|#define MAX_CHANNELS 64 ------------------ | Branch (394:9): [True: 41, False: 8.99k] ------------------ 395| 41| { 396| 41| hInfo->error = 12; 397| 41| return; 398| 41| } 399| 8.99k| if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS) ------------------ | | 44| 8.99k|#define MAX_SYNTAX_ELEMENTS 48 ------------------ | Branch (399:9): [True: 0, False: 8.99k] ------------------ 400| 0| { 401| 0| hInfo->error = 13; 402| 0| return; 403| 0| } 404| 8.99k| if (hDecoder->pce_set && (hDecoder->pce.channels > MAX_CHANNELS)) ------------------ | | 43| 1.62k|#define MAX_CHANNELS 64 ------------------ | Branch (404:9): [True: 1.62k, False: 7.37k] | Branch (404:30): [True: 0, False: 1.62k] ------------------ 405| 0| { 406| 0| hInfo->error = 22; 407| 0| return; 408| 0| } 409| | 410| | /* for CPE the number of output channels is always 2 */ 411| 8.99k| if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0) ------------------ | Branch (411:9): [True: 7.89k, False: 1.09k] ------------------ 412| 7.89k| { 413| | /* element_output_channels not set yet */ 414| 7.89k| hDecoder->element_output_channels[hDecoder->fr_ch_ele] = 2; 415| 7.89k| } else if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] != 2) { ------------------ | Branch (415:16): [True: 0, False: 1.09k] ------------------ 416| | /* element inconsistency */ 417| 0| hInfo->error = 21; 418| 0| return; 419| 0| } 420| | 421| 8.99k| if (hDecoder->element_id[hDecoder->fr_ch_ele] != INVALID_ELEMENT_ID && ------------------ | | 94| 17.9k|#define INVALID_ELEMENT_ID 255 ------------------ | Branch (421:9): [True: 1.10k, False: 7.89k] ------------------ 422| 1.10k| hDecoder->element_id[hDecoder->fr_ch_ele] != id_syn_ele) ------------------ | Branch (422:9): [True: 9, False: 1.09k] ------------------ 423| 9| { 424| | /* element inconsistency */ 425| 9| hInfo->error = 21; 426| 9| return; 427| 9| } 428| | 429| | /* save the syntax element id */ 430| 8.98k| hDecoder->element_id[hDecoder->fr_ch_ele] = id_syn_ele; 431| | 432| | /* decode the element */ 433| 8.98k| hInfo->error = channel_pair_element(hDecoder, ld, channels, &tag); 434| | 435| | /* map output channel position to internal data channels */ 436| 8.98k| if (hDecoder->pce_set) ------------------ | Branch (436:9): [True: 1.62k, False: 7.36k] ------------------ 437| 1.62k| { 438| 1.62k| hDecoder->internal_channel[hDecoder->pce.cpe_channel[tag]] = channels; 439| 1.62k| hDecoder->internal_channel[hDecoder->pce.cpe_channel[tag]+1] = channels+1; 440| 7.36k| } else { 441| 7.36k| hDecoder->internal_channel[channels] = channels; 442| 7.36k| hDecoder->internal_channel[channels+1] = channels+1; 443| 7.36k| } 444| | 445| 8.98k| hDecoder->fr_channels += 2; 446| 8.98k| hDecoder->fr_ch_ele++; 447| 8.98k|} syntax.c:channel_pair_element: 701| 8.98k|{ 702| 8.98k| ALIGN int16_t spec_data1[1024] = {0}; 703| 8.98k| ALIGN int16_t spec_data2[1024] = {0}; 704| 8.98k| element cpe = {0}; 705| 8.98k| ic_stream *ics1 = &(cpe.ics1); 706| 8.98k| ic_stream *ics2 = &(cpe.ics2); 707| 8.98k| uint8_t result; 708| | 709| 8.98k| cpe.channel = channels; 710| 8.98k| cpe.paired_channel = channels+1; 711| | 712| 8.98k| cpe.element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG ------------------ | | 76| 8.98k|#define LEN_TAG 4 ------------------ 713| 8.98k| DEBUGVAR(1,39,"channel_pair_element(): element_instance_tag")); 714| 8.98k| *tag = cpe.element_instance_tag; 715| | 716| 8.98k| if ((cpe.common_window = faad_get1bit(ld ------------------ | Branch (716:9): [True: 4.35k, False: 4.63k] ------------------ 717| 8.98k| DEBUGVAR(1,40,"channel_pair_element(): common_window"))) & 1) 718| 4.35k| { 719| | /* both channels have common ics information */ 720| 4.35k| if ((result = ics_info(hDecoder, ics1, ld, cpe.common_window)) > 0) ------------------ | Branch (720:13): [True: 10, False: 4.34k] ------------------ 721| 10| return result; 722| | 723| 4.34k| ics1->ms_mask_present = (uint8_t)faad_getbits(ld, 2 724| 4.34k| DEBUGVAR(1,41,"channel_pair_element(): ms_mask_present")); 725| 4.34k| if (ics1->ms_mask_present == 3) ------------------ | Branch (725:13): [True: 1, False: 4.34k] ------------------ 726| 1| { 727| | /* bitstream error */ 728| 1| return 32; 729| 1| } 730| 4.34k| if (ics1->ms_mask_present == 1) ------------------ | Branch (730:13): [True: 722, False: 3.62k] ------------------ 731| 722| { 732| 722| uint8_t g, sfb; 733| 3.06k| for (g = 0; g < ics1->num_window_groups; g++) ------------------ | Branch (733:25): [True: 2.34k, False: 722] ------------------ 734| 2.34k| { 735| 6.50k| for (sfb = 0; sfb < ics1->max_sfb; sfb++) ------------------ | Branch (735:31): [True: 4.16k, False: 2.34k] ------------------ 736| 4.16k| { 737| 4.16k| ics1->ms_used[g][sfb] = faad_get1bit(ld 738| 4.16k| DEBUGVAR(1,42,"channel_pair_element(): faad_get1bit")); 739| 4.16k| } 740| 2.34k| } 741| 722| } 742| | 743| 4.34k|#ifdef ERROR_RESILIENCE 744| 4.34k| if ((hDecoder->object_type >= ER_OBJECT_START) && (ics1->predictor_data_present)) ------------------ | | 71| 4.34k|#define ER_OBJECT_START 17 ------------------ | Branch (744:13): [True: 25, False: 4.31k] | Branch (744:59): [True: 10, False: 15] ------------------ 745| 10| { 746| 10| if (( ------------------ | Branch (746:17): [True: 2, False: 8] ------------------ 747| |#ifdef LTP_DEC 748| | ics1->ltp.data_present = 749| |#endif 750| 10| faad_get1bit(ld DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1) 751| 2| { 752| |#ifdef LTP_DEC 753| | if ((result = ltp_data(hDecoder, ics1, &(ics1->ltp), ld)) > 0) 754| | { 755| | return result; 756| | } 757| |#else 758| 2| return 26; 759| 2|#endif 760| 2| } 761| 10| } 762| 4.34k|#endif 763| | 764| 4.34k| memcpy(ics2, ics1, sizeof(ic_stream)); 765| 4.63k| } else { 766| 4.63k| ics1->ms_mask_present = 0; 767| 4.63k| } 768| | 769| 8.97k| if ((result = individual_channel_stream(hDecoder, &cpe, ld, ics1, ------------------ | Branch (769:9): [True: 66, False: 8.90k] ------------------ 770| 8.97k| 0, spec_data1)) > 0) 771| 66| { 772| 66| return result; 773| 66| } 774| | 775| 8.90k|#ifdef ERROR_RESILIENCE 776| 8.90k| if (cpe.common_window && (hDecoder->object_type >= ER_OBJECT_START) && ------------------ | | 71| 4.32k|#define ER_OBJECT_START 17 ------------------ | Branch (776:9): [True: 4.32k, False: 4.58k] | Branch (776:30): [True: 22, False: 4.30k] ------------------ 777| 22| (ics1->predictor_data_present)) ------------------ | Branch (777:9): [True: 8, False: 14] ------------------ 778| 8| { 779| 8| if (( ------------------ | Branch (779:13): [True: 1, False: 7] ------------------ 780| |#ifdef LTP_DEC 781| | ics1->ltp2.data_present = 782| |#endif 783| 8| faad_get1bit(ld DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1) 784| 1| { 785| |#ifdef LTP_DEC 786| | if ((result = ltp_data(hDecoder, ics1, &(ics1->ltp2), ld)) > 0) 787| | { 788| | return result; 789| | } 790| |#else 791| 1| return 26; 792| 1|#endif 793| 1| } 794| 8| } 795| 8.90k|#endif 796| | 797| 8.90k| if ((result = individual_channel_stream(hDecoder, &cpe, ld, ics2, ------------------ | Branch (797:9): [True: 51, False: 8.85k] ------------------ 798| 8.90k| 0, spec_data2)) > 0) 799| 51| { 800| 51| return result; 801| 51| } 802| | 803| 8.85k|#ifdef SBR_DEC 804| | /* check if next bitstream element is a fill element */ 805| | /* if so, read it now so SBR decoding can be done in case of a file with SBR */ 806| 8.85k| if (faad_showbits(ld, LEN_SE_ID) == ID_FIL) ------------------ | | 75| 8.85k|#define LEN_SE_ID 3 ------------------ if (faad_showbits(ld, LEN_SE_ID) == ID_FIL) ------------------ | | 92| 8.85k|#define ID_FIL 0x6 ------------------ | Branch (806:9): [True: 4.71k, False: 4.14k] ------------------ 807| 4.71k| { 808| 4.71k| faad_flushbits(ld, LEN_SE_ID); ------------------ | | 75| 4.71k|#define LEN_SE_ID 3 ------------------ 809| | 810| | /* one sbr_info describes a channel_element not a channel! */ 811| 4.71k| if ((result = fill_element(hDecoder, ld, hDecoder->drc, hDecoder->fr_ch_ele)) > 0) ------------------ | Branch (811:13): [True: 15, False: 4.69k] ------------------ 812| 15| { 813| 15| return result; 814| 15| } 815| 4.71k| } 816| 8.84k|#endif 817| | 818| | /* noiseless coding is done, spectral reconstruction is done now */ 819| 8.84k| if ((result = reconstruct_channel_pair(hDecoder, ics1, ics2, &cpe, ------------------ | Branch (819:9): [True: 2, False: 8.84k] ------------------ 820| 8.84k| spec_data1, spec_data2)) > 0) 821| 2| { 822| 2| return result; 823| 2| } 824| | 825| 8.84k| return 0; 826| 8.84k|} syntax.c:ics_info: 831| 41.3k|{ 832| 41.3k| uint8_t retval = 0; 833| 41.3k| uint8_t ics_reserved_bit; 834| | 835| 41.3k| ics_reserved_bit = faad_get1bit(ld 836| 41.3k| DEBUGVAR(1,43,"ics_info(): ics_reserved_bit")); 837| 41.3k| if (ics_reserved_bit != 0) ------------------ | Branch (837:9): [True: 105, False: 41.2k] ------------------ 838| 105| return 32; 839| 41.2k| ics->window_sequence = (uint8_t)faad_getbits(ld, 2 840| 41.2k| DEBUGVAR(1,44,"ics_info(): window_sequence")); 841| 41.2k| ics->window_shape = faad_get1bit(ld 842| 41.2k| DEBUGVAR(1,45,"ics_info(): window_shape")); 843| | 844| |#ifdef LD_DEC 845| | /* No block switching in LD */ 846| | if ((hDecoder->object_type == LD) && (ics->window_sequence != ONLY_LONG_SEQUENCE)) 847| | return 32; 848| |#endif 849| | 850| 41.2k| if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 41.2k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (850:9): [True: 11.3k, False: 29.9k] ------------------ 851| 11.3k| { 852| 11.3k| ics->max_sfb = (uint8_t)faad_getbits(ld, 4 853| 11.3k| DEBUGVAR(1,46,"ics_info(): max_sfb (short)")); 854| 11.3k| ics->scale_factor_grouping = (uint8_t)faad_getbits(ld, 7 855| 11.3k| DEBUGVAR(1,47,"ics_info(): scale_factor_grouping")); 856| 29.9k| } else { 857| 29.9k| ics->max_sfb = (uint8_t)faad_getbits(ld, 6 858| 29.9k| DEBUGVAR(1,48,"ics_info(): max_sfb (long)")); 859| 29.9k| } 860| | 861| | /* get the grouping information */ 862| 41.2k| if ((retval = window_grouping_info(hDecoder, ics)) > 0) ------------------ | Branch (862:9): [True: 37, False: 41.2k] ------------------ 863| 37| return retval; 864| | 865| | 866| | /* should be an error */ 867| | /* check the range of max_sfb */ 868| 41.2k| if (ics->max_sfb > ics->num_swb) ------------------ | Branch (868:9): [True: 0, False: 41.2k] ------------------ 869| 0| return 16; 870| | 871| 41.2k| if (ics->window_sequence != EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 41.2k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (871:9): [True: 29.9k, False: 11.2k] ------------------ 872| 29.9k| { 873| 29.9k| if ((ics->predictor_data_present = faad_get1bit(ld ------------------ | Branch (873:13): [True: 4.76k, False: 25.1k] ------------------ 874| 29.9k| DEBUGVAR(1,49,"ics_info(): predictor_data_present"))) & 1) 875| 4.76k| { 876| 4.76k| if (hDecoder->object_type == MAIN) /* MPEG2 style AAC predictor */ ------------------ | | 40| 4.76k|#define MAIN 1 ------------------ | Branch (876:17): [True: 3.11k, False: 1.64k] ------------------ 877| 3.11k| { 878| 3.11k| uint8_t sfb; 879| 3.11k| uint8_t predictor_reset, predictor_reset_group_number, prediction_used; 880| 3.11k| uint8_t limit = min(ics->max_sfb, max_pred_sfb(hDecoder->sf_index)); ------------------ | | 60| 3.11k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 2.97k, False: 136] | | ------------------ ------------------ 881| | 882| 3.11k| predictor_reset = faad_get1bit(ld DEBUGVAR(1,53,"ics_info(): pred.predictor_reset")); 883| 3.11k| if (predictor_reset) ------------------ | Branch (883:21): [True: 2.94k, False: 168] ------------------ 884| 2.94k| { 885| 2.94k| predictor_reset_group_number = 886| 2.94k| (uint8_t)faad_getbits(ld, 5 DEBUGVAR(1,54,"ics_info(): pred.predictor_reset_group_number")); 887| 2.94k| } else { 888| 168| predictor_reset_group_number = 0; 889| 168| } 890| | 891| 16.2k| for (sfb = 0; sfb < limit; sfb++) ------------------ | Branch (891:31): [True: 13.1k, False: 3.11k] ------------------ 892| 13.1k| { 893| 13.1k| prediction_used = faad_get1bit(ld DEBUGVAR(1,55,"ics_info(): pred.prediction_used")); 894| |#ifdef MAIN_DEC 895| | ics->pred.prediction_used[sfb] = prediction_used; 896| |#endif 897| 13.1k| } 898| |#ifdef MAIN_DEC 899| | ics->pred.limit = limit; 900| | ics->pred.predictor_reset = predictor_reset; 901| | ics->pred.predictor_reset_group_number = predictor_reset_group_number; 902| |#else 903| 3.11k| (void)predictor_reset_group_number; 904| 3.11k| (void)prediction_used; 905| 3.11k|#endif 906| 3.11k| } 907| |#ifdef LTP_DEC 908| | else { /* Long Term Prediction */ 909| | if (hDecoder->object_type < ER_OBJECT_START) 910| | { 911| | if ((ics->ltp.data_present = faad_get1bit(ld 912| | DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1) 913| | { 914| | if ((retval = ltp_data(hDecoder, ics, &(ics->ltp), ld)) > 0) 915| | { 916| | return retval; 917| | } 918| | } 919| | if (common_window) 920| | { 921| | if ((ics->ltp2.data_present = faad_get1bit(ld 922| | DEBUGVAR(1,51,"ics_info(): ltp2.data_present"))) & 1) 923| | { 924| | if ((retval = ltp_data(hDecoder, ics, &(ics->ltp2), ld)) > 0) 925| | { 926| | return retval; 927| | } 928| | } 929| | } 930| | } 931| |#ifdef ERROR_RESILIENCE 932| | if (!common_window && (hDecoder->object_type >= ER_OBJECT_START)) 933| | { 934| | if ((ics->ltp.data_present = faad_get1bit(ld 935| | DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1) 936| | { 937| | if ((retval = ltp_data(hDecoder, ics, &(ics->ltp), ld)) > 0) 938| | { 939| | return retval; 940| | } 941| | } 942| | } 943| |#endif /* ERROR_RESILIENCE */ 944| | } 945| |#else /* LTP_DEC */ 946| 4.76k| (void)common_window; 947| 4.76k|#endif /* LTP_DEC */ 948| 4.76k| } 949| 29.9k| } 950| | 951| 41.2k| return retval; 952| 41.2k|} syntax.c:data_stream_element: 1081| 13.5k|{ 1082| 13.5k| uint8_t byte_aligned; 1083| 13.5k| uint16_t i, count; 1084| 13.5k| (void)hDecoder; /* TODO: remove parameter; rename method; why result is unused? */ 1085| | 1086| 13.5k| /* element_instance_tag = */ faad_getbits(ld, LEN_TAG ------------------ | | 76| 13.5k|#define LEN_TAG 4 ------------------ 1087| 13.5k| DEBUGVAR(1,60,"data_stream_element(): element_instance_tag")); 1088| 13.5k| byte_aligned = faad_get1bit(ld 1089| 13.5k| DEBUGVAR(1,61,"data_stream_element(): byte_aligned")); 1090| 13.5k| count = (uint16_t)faad_getbits(ld, 8 1091| 13.5k| DEBUGVAR(1,62,"data_stream_element(): count")); 1092| 13.5k| if (count == 255) ------------------ | Branch (1092:9): [True: 566, False: 12.9k] ------------------ 1093| 566| { 1094| 566| count += (uint16_t)faad_getbits(ld, 8 1095| 566| DEBUGVAR(1,63,"data_stream_element(): extra count")); 1096| 566| } 1097| 13.5k| if (byte_aligned) ------------------ | Branch (1097:9): [True: 6.27k, False: 7.25k] ------------------ 1098| 6.27k| faad_byte_align(ld); 1099| | 1100| 243k| for (i = 0; i < count; i++) ------------------ | Branch (1100:17): [True: 230k, False: 13.5k] ------------------ 1101| 230k| { 1102| 230k| faad_getbits(ld, LEN_BYTE ------------------ | | 77| 230k|#define LEN_BYTE 8 ------------------ 1103| 230k| DEBUGVAR(1,64,"data_stream_element(): data_stream_byte")); 1104| 230k| } 1105| | 1106| 13.5k| return count; 1107| 13.5k|} syntax.c:fill_element: 1115| 13.1k|{ 1116| 13.1k| uint16_t count; 1117| 13.1k|#ifdef SBR_DEC 1118| 13.1k| uint8_t bs_extension_type; 1119| 13.1k|#endif 1120| | 1121| 13.1k| count = (uint16_t)faad_getbits(ld, 4 1122| 13.1k| DEBUGVAR(1,65,"fill_element(): count")); 1123| 13.1k| if (count == 15) ------------------ | Branch (1123:9): [True: 1.06k, False: 12.0k] ------------------ 1124| 1.06k| { 1125| 1.06k| count += (uint16_t)faad_getbits(ld, 8 1126| 1.06k| DEBUGVAR(1,66,"fill_element(): extra count")) - 1; 1127| 1.06k| } 1128| | 1129| 13.1k| if (count > 0) ------------------ | Branch (1129:9): [True: 12.8k, False: 248] ------------------ 1130| 12.8k| { 1131| 12.8k|#ifdef SBR_DEC 1132| 12.8k| bs_extension_type = (uint8_t)faad_showbits(ld, 4); 1133| | 1134| 12.8k| if ((bs_extension_type == EXT_SBR_DATA) || ------------------ | | 43| 12.8k|#define EXT_SBR_DATA 13 ------------------ | Branch (1134:13): [True: 3.68k, False: 9.16k] ------------------ 1135| 9.16k| (bs_extension_type == EXT_SBR_DATA_CRC)) ------------------ | | 44| 9.16k|#define EXT_SBR_DATA_CRC 14 ------------------ | Branch (1135:13): [True: 9.10k, False: 62] ------------------ 1136| 12.7k| { 1137| 12.7k| if (sbr_ele == INVALID_SBR_ELEMENT) ------------------ | | 110| 12.7k|#define INVALID_SBR_ELEMENT 255 ------------------ | Branch (1137:17): [True: 7, False: 12.7k] ------------------ 1138| 7| return 24; 1139| | 1140| 12.7k| if (!hDecoder->sbr[sbr_ele]) ------------------ | Branch (1140:17): [True: 11.1k, False: 1.64k] ------------------ 1141| 11.1k| { 1142| 11.1k| hDecoder->sbr[sbr_ele] = sbrDecodeInit(hDecoder->frameLength, 1143| 11.1k| hDecoder->element_id[sbr_ele], 2*get_sample_rate(hDecoder->sf_index), 1144| 11.1k| hDecoder->downSampledSBR 1145| 11.1k|#ifdef DRM 1146| 11.1k| , 0 1147| 11.1k|#endif 1148| 11.1k| ); 1149| 11.1k| } 1150| 12.7k| if (!hDecoder->sbr[sbr_ele]) ------------------ | Branch (1150:17): [True: 0, False: 12.7k] ------------------ 1151| 0| return 19; 1152| | 1153| 12.7k| hDecoder->sbr_present_flag = 1; 1154| | 1155| | /* parse the SBR data */ 1156| 12.7k| hDecoder->sbr[sbr_ele]->ret = sbr_extension_data(ld, hDecoder->sbr[sbr_ele], count, 1157| 12.7k| hDecoder->postSeekResetFlag); 1158| | 1159| |#if 0 1160| | if (hDecoder->sbr[sbr_ele]->ret > 0) 1161| | { 1162| | printf("%s\n", NeAACDecGetErrorMessage(hDecoder->sbr[sbr_ele]->ret)); 1163| | } 1164| |#endif 1165| | 1166| 12.7k|#if (defined(PS_DEC) || defined(DRM_PS)) 1167| 12.7k| if (hDecoder->sbr[sbr_ele]->ps_used) ------------------ | Branch (1167:17): [True: 2.88k, False: 9.89k] ------------------ 1168| 2.88k| { 1169| 2.88k| hDecoder->ps_used[sbr_ele] = 1; 1170| | 1171| | /* set element independent flag to 1 as well */ 1172| 2.88k| hDecoder->ps_used_global = 1; 1173| 2.88k| } 1174| 12.7k|#endif 1175| 12.7k| } else { 1176| 62|#endif 1177| |#ifndef DRM 1178| | while (count > 0) 1179| | { 1180| | uint16_t payload_bytes = extension_payload(ld, drc, count); 1181| | if (payload_bytes <= count) { 1182| | count -= payload_bytes; 1183| | } else { 1184| | count = 0; 1185| | } 1186| | } 1187| |#else 1188| 62| (void)drc; 1189| 62| return 30; 1190| 62|#endif 1191| 62|#ifdef SBR_DEC 1192| 62| } 1193| 12.8k|#endif 1194| 12.8k| } 1195| | 1196| 13.0k| return 0; 1197| 13.1k|} syntax.c:DRM_aac_scalable_main_header: 1514| 167|{ 1515| 167| uint8_t retval = 0; 1516| 167| uint8_t ics_reserved_bit; 1517| | 1518| 167| ics_reserved_bit = faad_get1bit(ld 1519| 167| DEBUGVAR(1,300,"aac_scalable_main_header(): ics_reserved_bits")); 1520| 167| if (ics_reserved_bit != 0) ------------------ | Branch (1520:9): [True: 0, False: 167] ------------------ 1521| 0| return 32; 1522| 167| ics1->window_sequence = (uint8_t)faad_getbits(ld, 2 1523| 167| DEBUGVAR(1,301,"aac_scalable_main_header(): window_sequence")); 1524| 167| ics1->window_shape = faad_get1bit(ld 1525| 167| DEBUGVAR(1,302,"aac_scalable_main_header(): window_shape")); 1526| | 1527| 167| if (ics1->window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 167|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (1527:9): [True: 85, False: 82] ------------------ 1528| 85| { 1529| 85| ics1->max_sfb = (uint8_t)faad_getbits(ld, 4 1530| 85| DEBUGVAR(1,303,"aac_scalable_main_header(): max_sfb (short)")); 1531| 85| ics1->scale_factor_grouping = (uint8_t)faad_getbits(ld, 7 1532| 85| DEBUGVAR(1,304,"aac_scalable_main_header(): scale_factor_grouping")); 1533| 85| } else { 1534| 82| ics1->max_sfb = (uint8_t)faad_getbits(ld, 6 1535| 82| DEBUGVAR(1,305,"aac_scalable_main_header(): max_sfb (long)")); 1536| 82| } 1537| | 1538| | /* get the grouping information */ 1539| 167| if ((retval = window_grouping_info(hDecoder, ics1)) > 0) ------------------ | Branch (1539:9): [True: 0, False: 167] ------------------ 1540| 0| return retval; 1541| | 1542| | /* should be an error */ 1543| | /* check the range of max_sfb */ 1544| 167| if (ics1->max_sfb > ics1->num_swb) ------------------ | Branch (1544:9): [True: 0, False: 167] ------------------ 1545| 0| return 16; 1546| | 1547| 167| if (this_layer_stereo) ------------------ | Branch (1547:9): [True: 44, False: 123] ------------------ 1548| 44| { 1549| 44| ics1->ms_mask_present = (uint8_t)faad_getbits(ld, 2 1550| 44| DEBUGVAR(1,306,"aac_scalable_main_header(): ms_mask_present")); 1551| 44| if (ics1->ms_mask_present == 3) ------------------ | Branch (1551:13): [True: 0, False: 44] ------------------ 1552| 0| { 1553| | /* bitstream error */ 1554| 0| return 32; 1555| 0| } 1556| 44| if (ics1->ms_mask_present == 1) ------------------ | Branch (1556:13): [True: 16, False: 28] ------------------ 1557| 16| { 1558| 16| uint8_t g, sfb; 1559| 32| for (g = 0; g < ics1->num_window_groups; g++) ------------------ | Branch (1559:25): [True: 16, False: 16] ------------------ 1560| 16| { 1561| 192| for (sfb = 0; sfb < ics1->max_sfb; sfb++) ------------------ | Branch (1561:31): [True: 176, False: 16] ------------------ 1562| 176| { 1563| 176| ics1->ms_used[g][sfb] = faad_get1bit(ld 1564| 176| DEBUGVAR(1,307,"aac_scalable_main_header(): faad_get1bit")); 1565| 176| } 1566| 16| } 1567| 16| } 1568| | 1569| 44| memcpy(ics2, ics1, sizeof(ic_stream)); 1570| 123| } else { 1571| 123| ics1->ms_mask_present = 0; 1572| 123| } 1573| | 1574| 167| return 0; 1575| 167|} syntax.c:side_info: 1580| 45.9k|{ 1581| 45.9k| uint8_t result; 1582| | 1583| 45.9k| ics->global_gain = (uint8_t)faad_getbits(ld, 8 1584| 45.9k| DEBUGVAR(1,67,"individual_channel_stream(): global_gain")); 1585| | 1586| 45.9k| if (!ele->common_window && !scal_flag) ------------------ | Branch (1586:9): [True: 37.0k, False: 8.86k] | Branch (1586:32): [True: 37.0k, False: 0] ------------------ 1587| 37.0k| { 1588| 37.0k| if ((result = ics_info(hDecoder, ics, ld, ele->common_window)) > 0) ------------------ | Branch (1588:13): [True: 132, False: 36.9k] ------------------ 1589| 132| return result; 1590| 37.0k| } 1591| | 1592| 45.7k| if ((result = section_data(hDecoder, ics, ld)) > 0) ------------------ | Branch (1592:9): [True: 192, False: 45.5k] ------------------ 1593| 192| return result; 1594| | 1595| 45.5k| if ((result = scale_factor_data(hDecoder, ics, ld)) > 0) ------------------ | Branch (1595:9): [True: 0, False: 45.5k] ------------------ 1596| 0| return result; 1597| | 1598| 45.5k| if (!scal_flag) ------------------ | Branch (1598:9): [True: 45.4k, False: 166] ------------------ 1599| 45.4k| { 1600| | /** 1601| | ** NOTE: It could be that pulse data is available in scalable AAC too, 1602| | ** as said in Amendment 1, this could be only the case for ER AAC, 1603| | ** though. (have to check this out later) 1604| | **/ 1605| | /* get pulse data */ 1606| 45.4k| if ((ics->pulse_data_present = faad_get1bit(ld ------------------ | Branch (1606:13): [True: 1.08k, False: 44.3k] ------------------ 1607| 45.4k| DEBUGVAR(1,68,"individual_channel_stream(): pulse_data_present"))) & 1) 1608| 1.08k| { 1609| 1.08k| if ((result = pulse_data(ics, &(ics->pul), ld)) > 0) ------------------ | Branch (1609:17): [True: 25, False: 1.06k] ------------------ 1610| 25| return result; 1611| 1.08k| } 1612| | 1613| | /* get tns data */ 1614| 45.3k| if ((ics->tns_data_present = faad_get1bit(ld ------------------ | Branch (1614:13): [True: 5.03k, False: 40.3k] ------------------ 1615| 45.3k| DEBUGVAR(1,69,"individual_channel_stream(): tns_data_present"))) & 1) 1616| 5.03k| { 1617| 5.03k|#ifdef ERROR_RESILIENCE 1618| 5.03k| if (hDecoder->object_type < ER_OBJECT_START) ------------------ | | 71| 5.03k|#define ER_OBJECT_START 17 ------------------ | Branch (1618:17): [True: 5.01k, False: 23] ------------------ 1619| 5.01k|#endif 1620| 5.01k| tns_data(ics, &(ics->tns), ld); 1621| 5.03k| } 1622| | 1623| | /* get gain control data */ 1624| 45.3k| if ((ics->gain_control_data_present = faad_get1bit(ld ------------------ | Branch (1624:13): [True: 35, False: 45.3k] ------------------ 1625| 45.3k| DEBUGVAR(1,70,"individual_channel_stream(): gain_control_data_present"))) & 1) 1626| 35| { 1627| |#ifdef SSR_DEC 1628| | if (hDecoder->object_type != SSR) 1629| | return 1; 1630| | else 1631| | gain_control_data(ld, ics); 1632| |#else 1633| 35| return 1; 1634| 35|#endif 1635| 35| } 1636| 45.3k| } 1637| | 1638| 45.5k|#ifdef ERROR_RESILIENCE 1639| 45.5k| if (hDecoder->aacSpectralDataResilienceFlag) ------------------ | Branch (1639:9): [True: 517, False: 44.9k] ------------------ 1640| 517| { 1641| 517| ics->length_of_reordered_spectral_data = (uint16_t)faad_getbits(ld, 14 1642| 517| DEBUGVAR(1,147,"individual_channel_stream(): length_of_reordered_spectral_data")); 1643| | 1644| 517| if (hDecoder->channelConfiguration == 2) ------------------ | Branch (1644:13): [True: 22, False: 495] ------------------ 1645| 22| { 1646| 22| if (ics->length_of_reordered_spectral_data > 6144) ------------------ | Branch (1646:17): [True: 0, False: 22] ------------------ 1647| 0| ics->length_of_reordered_spectral_data = 6144; 1648| 495| } else { 1649| 495| if (ics->length_of_reordered_spectral_data > 12288) ------------------ | Branch (1649:17): [True: 63, False: 432] ------------------ 1650| 63| ics->length_of_reordered_spectral_data = 12288; 1651| 495| } 1652| | 1653| 517| ics->length_of_longest_codeword = (uint8_t)faad_getbits(ld, 6 1654| 517| DEBUGVAR(1,148,"individual_channel_stream(): length_of_longest_codeword")); 1655| 517| if (ics->length_of_longest_codeword >= 49) ------------------ | Branch (1655:13): [True: 97, False: 420] ------------------ 1656| 97| ics->length_of_longest_codeword = 49; 1657| 517| } 1658| | 1659| | /* RVLC spectral data is put here */ 1660| 45.5k| if (hDecoder->aacScalefactorDataResilienceFlag) ------------------ | Branch (1660:9): [True: 1.93k, False: 43.5k] ------------------ 1661| 1.93k| { 1662| 1.93k| if ((result = rvlc_decode_scale_factors(ics, ld)) > 0) ------------------ | Branch (1662:13): [True: 4, False: 1.93k] ------------------ 1663| 4| return result; 1664| 1.93k| } 1665| 45.5k|#endif 1666| | 1667| 45.5k| return 0; 1668| 45.5k|} syntax.c:section_data: 1732| 45.7k|{ 1733| 45.7k| uint8_t g; 1734| 45.7k| uint8_t sect_esc_val, sect_bits; 1735| 45.7k| uint8_t sect_lim; /* 51 or 120, anyways less than 127. */ 1736| | 1737| 45.7k| if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) { ------------------ | | 98| 45.7k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (1737:9): [True: 12.3k, False: 33.3k] ------------------ 1738| 12.3k| sect_bits = 3; 1739| 12.3k| sect_lim = 8 * 15; 1740| 33.3k| } else { 1741| 33.3k| sect_bits = 5; 1742| 33.3k| sect_lim = MAX_SFB; ------------------ | | 46| 33.3k|#define MAX_SFB 51 ------------------ 1743| 33.3k| } 1744| 45.7k| sect_esc_val = (1u<max_sfb); 1748| | printf(" sect top cb\n"); 1749| |#endif 1750| | 1751| 161k| for (g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (1751:17): [True: 115k, False: 45.5k] ------------------ 1752| 115k| { 1753| 115k| uint8_t k = 0; 1754| 115k| uint8_t i = 0; 1755| | 1756| 133k| while (k < ics->max_sfb) ------------------ | Branch (1756:16): [True: 18.3k, False: 115k] ------------------ 1757| 18.3k| { 1758| 18.3k|#ifdef ERROR_RESILIENCE 1759| 18.3k| uint8_t vcb11 = 0; 1760| 18.3k|#endif 1761| 18.3k| uint8_t sfb; 1762| 18.3k| uint8_t sect_len_incr; 1763| 18.3k| uint8_t sect_len = 0; 1764| 18.3k| uint8_t sect_cb_bits = 4; 1765| | 1766| | /* if "faad_getbits" detects error and returns "0", "k" is never 1767| | incremented and we cannot leave the while loop */ 1768| 18.3k| if (ld->error != 0) ------------------ | Branch (1768:17): [True: 0, False: 18.3k] ------------------ 1769| 0| return 14; 1770| 18.3k| if (i >= sect_lim) ------------------ | Branch (1770:17): [True: 59, False: 18.3k] ------------------ 1771| 59| return 15; 1772| | 1773| 18.3k|#ifdef ERROR_RESILIENCE 1774| 18.3k| if (hDecoder->aacSectionDataResilienceFlag) ------------------ | Branch (1774:17): [True: 10.9k, False: 7.32k] ------------------ 1775| 10.9k| sect_cb_bits = 5; 1776| 18.3k|#endif 1777| | 1778| 18.3k| ics->sect_cb[g][i] = (uint8_t)faad_getbits(ld, sect_cb_bits 1779| 18.3k| DEBUGVAR(1,71,"section_data(): sect_cb")); 1780| | 1781| 18.3k| if (ics->sect_cb[g][i] == 12) ------------------ | Branch (1781:17): [True: 16, False: 18.3k] ------------------ 1782| 16| return 32; 1783| | 1784| |#if 0 1785| | printf("%d\n", ics->sect_cb[g][i]); 1786| |#endif 1787| | 1788| |#ifndef DRM 1789| | if (ics->sect_cb[g][i] == NOISE_HCB) 1790| | ics->noise_used = 1; 1791| |#else 1792| | /* PNS not allowed in DRM */ 1793| 18.3k| if (ics->sect_cb[g][i] == NOISE_HCB) ------------------ | | 106| 18.3k|#define NOISE_HCB 13 ------------------ | Branch (1793:17): [True: 12, False: 18.2k] ------------------ 1794| 12| return 29; 1795| 18.2k|#endif 1796| 18.2k| if (ics->sect_cb[g][i] == INTENSITY_HCB2 || ics->sect_cb[g][i] == INTENSITY_HCB) ------------------ | | 107| 36.5k|#define INTENSITY_HCB2 14 ------------------ if (ics->sect_cb[g][i] == INTENSITY_HCB2 || ics->sect_cb[g][i] == INTENSITY_HCB) ------------------ | | 108| 17.8k|#define INTENSITY_HCB 15 ------------------ | Branch (1796:17): [True: 467, False: 17.8k] | Branch (1796:57): [True: 1.02k, False: 16.7k] ------------------ 1797| 1.49k| ics->is_used = 1; 1798| | 1799| 18.2k|#ifdef ERROR_RESILIENCE 1800| 18.2k| if (hDecoder->aacSectionDataResilienceFlag) ------------------ | Branch (1800:17): [True: 10.9k, False: 7.29k] ------------------ 1801| 10.9k| { 1802| 10.9k| if ((ics->sect_cb[g][i] == 11) || ------------------ | Branch (1802:21): [True: 68, False: 10.9k] ------------------ 1803| 10.9k| ((ics->sect_cb[g][i] >= 16) && (ics->sect_cb[g][i] <= 32))) ------------------ | Branch (1803:22): [True: 2.75k, False: 8.17k] | Branch (1803:52): [True: 2.75k, False: 0] ------------------ 1804| 2.82k| { 1805| 2.82k| vcb11 = 1; 1806| 2.82k| } 1807| 10.9k| } 1808| 18.2k| if (vcb11) ------------------ | Branch (1808:17): [True: 2.82k, False: 15.4k] ------------------ 1809| 2.82k| { 1810| 2.82k| sect_len_incr = 1; 1811| 15.4k| } else { 1812| 15.4k|#endif 1813| 15.4k| sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits 1814| 15.4k| DEBUGVAR(1,72,"section_data(): sect_len_incr")); 1815| 15.4k|#ifdef ERROR_RESILIENCE 1816| 15.4k| } 1817| 18.2k|#endif 1818| 18.5k| while (sect_len_incr == sect_esc_val /* && ------------------ | Branch (1818:20): [True: 263, False: 18.2k] ------------------ 1819| 18.2k| (k+sect_len < ics->max_sfb)*/) 1820| 263| { 1821| 263| sect_len += sect_len_incr; 1822| 263| if (sect_len > sect_lim) ------------------ | Branch (1822:21): [True: 5, False: 258] ------------------ 1823| 5| return 15; 1824| 258| sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits 1825| 258| DEBUGVAR(1,72,"section_data(): sect_len_incr")); 1826| 258| } 1827| | 1828| 18.2k| sect_len += sect_len_incr; 1829| | 1830| 18.2k| ics->sect_start[g][i] = k; 1831| 18.2k| ics->sect_end[g][i] = k + sect_len; 1832| | 1833| |#if 0 1834| | printf("%d\n", ics->sect_start[g][i]); 1835| |#endif 1836| |#if 0 1837| | printf("%d\n", ics->sect_end[g][i]); 1838| |#endif 1839| | 1840| 18.2k| if (sect_len > sect_lim) ------------------ | Branch (1840:17): [True: 2, False: 18.2k] ------------------ 1841| 2| return 15; 1842| 18.2k| if (k + sect_len > sect_lim) ------------------ | Branch (1842:17): [True: 1, False: 18.2k] ------------------ 1843| 1| return 15; 1844| | 1845| 63.8k| for (sfb = k; sfb < k + sect_len; sfb++) ------------------ | Branch (1845:27): [True: 45.5k, False: 18.2k] ------------------ 1846| 45.5k| { 1847| 45.5k| ics->sfb_cb[g][sfb] = ics->sect_cb[g][i]; 1848| |#if 0 1849| | printf("%d\n", ics->sfb_cb[g][sfb]); 1850| |#endif 1851| 45.5k| } 1852| | 1853| |#if 0 1854| | printf(" %6d %6d %6d\n", 1855| | i, 1856| | ics->sect_end[g][i], 1857| | ics->sect_cb[g][i]); 1858| |#endif 1859| | 1860| 18.2k| k += sect_len; /* k <= sect_lim */ 1861| 18.2k| i++; 1862| 18.2k| } 1863| 115k| ics->num_sec[g] = i; 1864| | 1865| | /* the sum of all sect_len_incr elements for a given window 1866| | * group shall equal max_sfb */ 1867| 115k| if (k != ics->max_sfb) ------------------ | Branch (1867:13): [True: 97, False: 115k] ------------------ 1868| 97| { 1869| 97| return 32; 1870| 97| } 1871| |#if 0 1872| | printf("%d\n", ics->num_sec[g]); 1873| |#endif 1874| 115k| } 1875| | 1876| |#if 0 1877| | printf("\n"); 1878| |#endif 1879| | 1880| 45.5k| return 0; 1881| 45.7k|} syntax.c:scale_factor_data: 1989| 45.5k|{ 1990| 45.5k| uint8_t ret = 0; 1991| |#ifdef PROFILE 1992| | int64_t count = faad_get_ts(); 1993| |#endif 1994| | 1995| 45.5k|#ifdef ERROR_RESILIENCE 1996| 45.5k| if (!hDecoder->aacScalefactorDataResilienceFlag) ------------------ | Branch (1996:9): [True: 43.6k, False: 1.94k] ------------------ 1997| 43.6k| { 1998| 43.6k|#endif 1999| 43.6k| ret = decode_scale_factors(ics, ld); 2000| 43.6k|#ifdef ERROR_RESILIENCE 2001| 43.6k| } else { 2002| | /* In ER AAC the parameters for RVLC are seperated from the actual 2003| | data that holds the scale_factors. 2004| | Strangely enough, 2 parameters for HCR are put inbetween them. 2005| | */ 2006| 1.94k| ret = rvlc_scale_factor_data(ics, ld); 2007| 1.94k| } 2008| 45.5k|#endif 2009| | 2010| |#ifdef PROFILE 2011| | count = faad_get_ts() - count; 2012| | hDecoder->scalefac_cycles += count; 2013| |#endif 2014| | 2015| 45.5k| return ret; 2016| 45.5k|} syntax.c:decode_scale_factors: 1895| 43.6k|{ 1896| 43.6k| uint8_t g, sfb; 1897| 43.6k| int16_t t; 1898| | 1899| 43.6k| int16_t scale_factor = ics->global_gain; 1900| 43.6k| int16_t is_position = 0; 1901| 43.6k| int16_t scale_factor_max = 255; 1902| 43.6k|#ifdef FIXED_POINT 1903| | /* TODO: consider rolling out to regular build. */ 1904| 43.6k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 1905| | /* The value is inexact, adjusted to current fuzzer findings. */ 1906| 43.6k| scale_factor_max = 165; 1907| 43.6k|#endif // FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 1908| 43.6k|#endif // FIXED_POINT 1909| |#ifndef DRM 1910| | int8_t noise_pcm_flag = 1; 1911| | int16_t noise_energy = ics->global_gain - 90; 1912| |#endif 1913| | 1914| 155k| for (g = 0; g < ics->num_window_groups; g++) ------------------ | Branch (1914:17): [True: 111k, False: 43.6k] ------------------ 1915| 111k| { 1916| 147k| for (sfb = 0; sfb < ics->max_sfb; sfb++) ------------------ | Branch (1916:23): [True: 35.5k, False: 111k] ------------------ 1917| 35.5k| { 1918| 35.5k| switch (ics->sfb_cb[g][sfb]) 1919| 35.5k| { 1920| 10.2k| case ZERO_HCB: /* zero book */ ------------------ | | 101| 10.2k|#define ZERO_HCB 0 ------------------ | Branch (1920:13): [True: 10.2k, False: 25.2k] ------------------ 1921| 10.2k| ics->scale_factors[g][sfb] = 0; 1922| |//#define SF_PRINT 1923| |#ifdef SF_PRINT 1924| | printf("%d\n", ics->scale_factors[g][sfb]); 1925| |#endif 1926| 10.2k| break; 1927| 533| case INTENSITY_HCB: /* intensity books */ ------------------ | | 108| 533|#define INTENSITY_HCB 15 ------------------ | Branch (1927:13): [True: 533, False: 35.0k] ------------------ 1928| 2.49k| case INTENSITY_HCB2: ------------------ | | 107| 2.49k|#define INTENSITY_HCB2 14 ------------------ | Branch (1928:13): [True: 1.96k, False: 33.5k] ------------------ 1929| | 1930| | /* decode intensity position */ 1931| 2.49k| t = huffman_scale_factor(ld); 1932| 2.49k| is_position += (t - 60); 1933| 2.49k| ics->scale_factors[g][sfb] = is_position; 1934| |#ifdef SF_PRINT 1935| | printf("%d\n", ics->scale_factors[g][sfb]); 1936| |#endif 1937| | 1938| 2.49k| break; 1939| 0| case NOISE_HCB: /* noise books */ ------------------ | | 106| 0|#define NOISE_HCB 13 ------------------ | Branch (1939:13): [True: 0, False: 35.5k] ------------------ 1940| | 1941| |#ifndef DRM 1942| | /* decode noise energy */ 1943| | if (noise_pcm_flag) 1944| | { 1945| | noise_pcm_flag = 0; 1946| | t = (int16_t)faad_getbits(ld, 9 1947| | DEBUGVAR(1,73,"scale_factor_data(): first noise")) - 256; 1948| | } else { 1949| | t = huffman_scale_factor(ld); 1950| | t -= 60; 1951| | } 1952| | noise_energy += t; 1953| | ics->scale_factors[g][sfb] = noise_energy; 1954| |#ifdef SF_PRINT 1955| | printf("%d\n", ics->scale_factors[g][sfb]); 1956| |#endif 1957| |#else 1958| | /* PNS not allowed in DRM */ 1959| 0| return 29; 1960| 0|#endif 1961| | 1962| 0| break; 1963| 22.7k| default: /* spectral books */ ------------------ | Branch (1963:13): [True: 22.7k, False: 12.7k] ------------------ 1964| | 1965| | /* ics->scale_factors[g][sfb] must be between 0 and 255 */ 1966| | 1967| 22.7k| ics->scale_factors[g][sfb] = 0; 1968| | 1969| | /* decode scale factor */ 1970| 22.7k| t = huffman_scale_factor(ld); 1971| 22.7k| scale_factor += (t - 60); 1972| 22.7k| if (scale_factor < 0 || scale_factor > 255) ------------------ | Branch (1972:21): [True: 0, False: 22.7k] | Branch (1972:41): [True: 0, False: 22.7k] ------------------ 1973| 0| return 4; 1974| 22.7k| ics->scale_factors[g][sfb] = min(scale_factor, scale_factor_max); ------------------ | | 60| 22.7k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 18.7k, False: 3.97k] | | ------------------ ------------------ 1975| |#ifdef SF_PRINT 1976| | printf("%d\n", ics->scale_factors[g][sfb]); 1977| |#endif 1978| | 1979| 22.7k| break; 1980| 35.5k| } 1981| 35.5k| } 1982| 111k| } 1983| | 1984| 43.6k| return 0; 1985| 43.6k|} syntax.c:pulse_data: 956| 1.08k|{ 957| 1.08k| uint8_t i; 958| | 959| 1.08k| pul->number_pulse = (uint8_t)faad_getbits(ld, 2 960| 1.08k| DEBUGVAR(1,56,"pulse_data(): number_pulse")); 961| 1.08k| pul->pulse_start_sfb = (uint8_t)faad_getbits(ld, 6 962| 1.08k| DEBUGVAR(1,57,"pulse_data(): pulse_start_sfb")); 963| | 964| | /* check the range of pulse_start_sfb */ 965| 1.08k| if (pul->pulse_start_sfb > ics->num_swb) ------------------ | Branch (965:9): [True: 25, False: 1.06k] ------------------ 966| 25| return 16; 967| | 968| 3.86k| for (i = 0; i < pul->number_pulse+1; i++) ------------------ | Branch (968:17): [True: 2.79k, False: 1.06k] ------------------ 969| 2.79k| { 970| 2.79k| pul->pulse_offset[i] = (uint8_t)faad_getbits(ld, 5 971| 2.79k| DEBUGVAR(1,58,"pulse_data(): pulse_offset")); 972| |#if 0 973| | printf("%d\n", pul->pulse_offset[i]); 974| |#endif 975| 2.79k| pul->pulse_amp[i] = (uint8_t)faad_getbits(ld, 4 976| 2.79k| DEBUGVAR(1,59,"pulse_data(): pulse_amp")); 977| |#if 0 978| | printf("%d\n", pul->pulse_amp[i]); 979| |#endif 980| 2.79k| } 981| | 982| 1.06k| return 0; 983| 1.08k|} syntax.c:tns_data: 2020| 5.07k|{ 2021| 5.07k| uint8_t w, filt, i, coef_bits; 2022| 5.07k| uint8_t n_filt_bits = 2; 2023| 5.07k| uint8_t length_bits = 6; 2024| 5.07k| uint8_t order_bits = 5; 2025| | 2026| 5.07k| if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) ------------------ | | 98| 5.07k|#define EIGHT_SHORT_SEQUENCE 0x2 ------------------ | Branch (2026:9): [True: 1.60k, False: 3.46k] ------------------ 2027| 1.60k| { 2028| 1.60k| n_filt_bits = 1; 2029| 1.60k| length_bits = 4; 2030| 1.60k| order_bits = 3; 2031| 1.60k| } 2032| | 2033| 21.3k| for (w = 0; w < ics->num_windows; w++) ------------------ | Branch (2033:17): [True: 16.2k, False: 5.07k] ------------------ 2034| 16.2k| { 2035| 16.2k| uint8_t start_coef_bits = 3; 2036| 16.2k| tns->n_filt[w] = (uint8_t)faad_getbits(ld, n_filt_bits 2037| 16.2k| DEBUGVAR(1,74,"tns_data(): n_filt")); 2038| |#if 0 2039| | printf("%d\n", tns->n_filt[w]); 2040| |#endif 2041| | 2042| 16.2k| if (tns->n_filt[w]) ------------------ | Branch (2042:13): [True: 6.01k, False: 10.2k] ------------------ 2043| 6.01k| { 2044| 6.01k| if ((tns->coef_res[w] = faad_get1bit(ld ------------------ | Branch (2044:17): [True: 2.10k, False: 3.91k] ------------------ 2045| 6.01k| DEBUGVAR(1,75,"tns_data(): coef_res"))) & 1) 2046| 2.10k| start_coef_bits = 4; 2047| |#if 0 2048| | printf("%d\n", tns->coef_res[w]); 2049| |#endif 2050| 6.01k| } 2051| | 2052| 25.6k| for (filt = 0; filt < tns->n_filt[w]; filt++) ------------------ | Branch (2052:24): [True: 9.34k, False: 16.2k] ------------------ 2053| 9.34k| { 2054| 9.34k| tns->length[w][filt] = (uint8_t)faad_getbits(ld, length_bits 2055| 9.34k| DEBUGVAR(1,76,"tns_data(): length")); 2056| |#if 0 2057| | printf("%d\n", tns->length[w][filt]); 2058| |#endif 2059| 9.34k| tns->order[w][filt] = (uint8_t)faad_getbits(ld, order_bits 2060| 9.34k| DEBUGVAR(1,77,"tns_data(): order")); 2061| |#if 0 2062| | printf("%d\n", tns->order[w][filt]); 2063| |#endif 2064| 9.34k| if (tns->order[w][filt]) ------------------ | Branch (2064:17): [True: 5.05k, False: 4.28k] ------------------ 2065| 5.05k| { 2066| 5.05k| tns->direction[w][filt] = faad_get1bit(ld 2067| 5.05k| DEBUGVAR(1,78,"tns_data(): direction")); 2068| |#if 0 2069| | printf("%d\n", tns->direction[w][filt]); 2070| |#endif 2071| 5.05k| tns->coef_compress[w][filt] = faad_get1bit(ld 2072| 5.05k| DEBUGVAR(1,79,"tns_data(): coef_compress")); 2073| |#if 0 2074| | printf("%d\n", tns->coef_compress[w][filt]); 2075| |#endif 2076| | 2077| 5.05k| coef_bits = start_coef_bits - tns->coef_compress[w][filt]; 2078| 34.5k| for (i = 0; i < tns->order[w][filt]; i++) ------------------ | Branch (2078:29): [True: 29.5k, False: 5.05k] ------------------ 2079| 29.5k| { 2080| 29.5k| tns->coef[w][filt][i] = (uint8_t)faad_getbits(ld, coef_bits 2081| 29.5k| DEBUGVAR(1,80,"tns_data(): coef")); 2082| |#if 0 2083| | printf("%d\n", tns->coef[w][filt][i]); 2084| |#endif 2085| 29.5k| } 2086| 5.05k| } 2087| 9.34k| } 2088| 16.2k| } 2089| 5.07k|} syntax.c:adts_fixed_header: 2462| 1.03k|{ 2463| 1.03k| uint16_t i; 2464| 1.03k| uint8_t sync_err = 1; 2465| | 2466| | /* try to recover from sync errors */ 2467| 783k| for (i = 0; i < 768; i++) ------------------ | Branch (2467:17): [True: 782k, False: 1.01k] ------------------ 2468| 782k| { 2469| 782k| adts->syncword = (uint16_t)faad_showbits(ld, 12); 2470| 782k| if (adts->syncword != 0xFFF) ------------------ | Branch (2470:13): [True: 782k, False: 14] ------------------ 2471| 782k| { 2472| 782k| faad_getbits(ld, 8 2473| 782k| DEBUGVAR(0,0,"")); 2474| 782k| } else { 2475| 14| sync_err = 0; 2476| 14| faad_getbits(ld, 12 2477| 14| DEBUGVAR(1,118,"adts_fixed_header(): syncword")); 2478| 14| break; 2479| 14| } 2480| 782k| } 2481| 1.03k| if (sync_err) ------------------ | Branch (2481:9): [True: 1.01k, False: 14] ------------------ 2482| 1.01k| return 5; 2483| | 2484| 14| adts->id = faad_get1bit(ld 2485| 14| DEBUGVAR(1,119,"adts_fixed_header(): id")); 2486| 14| adts->layer = (uint8_t)faad_getbits(ld, 2 2487| 14| DEBUGVAR(1,120,"adts_fixed_header(): layer")); 2488| 14| adts->protection_absent = faad_get1bit(ld 2489| 14| DEBUGVAR(1,121,"adts_fixed_header(): protection_absent")); 2490| 14| adts->profile = (uint8_t)faad_getbits(ld, 2 2491| 14| DEBUGVAR(1,122,"adts_fixed_header(): profile")); 2492| 14| adts->sf_index = (uint8_t)faad_getbits(ld, 4 2493| 14| DEBUGVAR(1,123,"adts_fixed_header(): sf_index")); 2494| 14| adts->private_bit = faad_get1bit(ld 2495| 14| DEBUGVAR(1,124,"adts_fixed_header(): private_bit")); 2496| 14| adts->channel_configuration = (uint8_t)faad_getbits(ld, 3 2497| 14| DEBUGVAR(1,125,"adts_fixed_header(): channel_configuration")); 2498| 14| adts->original = faad_get1bit(ld 2499| 14| DEBUGVAR(1,126,"adts_fixed_header(): original")); 2500| 14| adts->home = faad_get1bit(ld 2501| 14| DEBUGVAR(1,127,"adts_fixed_header(): home")); 2502| | 2503| 14| if (adts->old_format == 1) ------------------ | Branch (2503:9): [True: 0, False: 14] ------------------ 2504| 0| { 2505| | /* Removed in corrigendum 14496-3:2002 */ 2506| 0| if (adts->id == 0) ------------------ | Branch (2506:13): [True: 0, False: 0] ------------------ 2507| 0| { 2508| 0| adts->emphasis = (uint8_t)faad_getbits(ld, 2 2509| 0| DEBUGVAR(1,128,"adts_fixed_header(): emphasis")); 2510| 0| } 2511| 0| } 2512| | 2513| 14| return 0; 2514| 1.03k|} syntax.c:adts_variable_header: 2518| 14|{ 2519| 14| adts->copyright_identification_bit = faad_get1bit(ld 2520| 14| DEBUGVAR(1,129,"adts_variable_header(): copyright_identification_bit")); 2521| 14| adts->copyright_identification_start = faad_get1bit(ld 2522| 14| DEBUGVAR(1,130,"adts_variable_header(): copyright_identification_start")); 2523| 14| adts->aac_frame_length = (uint16_t)faad_getbits(ld, 13 2524| 14| DEBUGVAR(1,131,"adts_variable_header(): aac_frame_length")); 2525| 14| adts->adts_buffer_fullness = (uint16_t)faad_getbits(ld, 11 2526| 14| DEBUGVAR(1,132,"adts_variable_header(): adts_buffer_fullness")); 2527| 14| adts->no_raw_data_blocks_in_frame = (uint8_t)faad_getbits(ld, 2 2528| 14| DEBUGVAR(1,133,"adts_variable_header(): no_raw_data_blocks_in_frame")); 2529| 14|} syntax.c:adts_error_check: 2533| 14|{ 2534| 14| if (adts->protection_absent == 0) ------------------ | Branch (2534:9): [True: 1, False: 13] ------------------ 2535| 1| { 2536| 1| adts->crc_check = (uint16_t)faad_getbits(ld, 16 2537| 1| DEBUGVAR(1,134,"adts_error_check(): crc_check")); 2538| 1| } 2539| 14|} tns_decode_frame: 86| 45.3k|{ 87| 45.3k| uint8_t w, f, tns_order; 88| 45.3k| int8_t inc; 89| 45.3k| int16_t size; 90| 45.3k| uint16_t bottom, top, start, end; 91| 45.3k| uint16_t nshort = frame_len/8; 92| 45.3k| real_t lpc[TNS_MAX_ORDER+1]; 93| 45.3k| uint8_t exp; 94| | 95| 45.3k| if (!ics->tns_data_present) ------------------ | Branch (95:9): [True: 40.2k, False: 5.03k] ------------------ 96| 40.2k| return; 97| | 98| 21.1k| for (w = 0; w < ics->num_windows; w++) ------------------ | Branch (98:17): [True: 16.1k, False: 5.03k] ------------------ 99| 16.1k| { 100| 16.1k| bottom = ics->num_swb; 101| | 102| 25.3k| for (f = 0; f < tns->n_filt[w]; f++) ------------------ | Branch (102:21): [True: 9.26k, False: 16.1k] ------------------ 103| 9.26k| { 104| 9.26k| top = bottom; 105| 9.26k| bottom = max(top - tns->length[w][f], 0); ------------------ | | 57| 9.26k|#define max(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (57:20): [True: 7.21k, False: 2.04k] | | ------------------ ------------------ 106| 9.26k| tns_order = min(tns->order[w][f], TNS_MAX_ORDER); ------------------ | | 60| 9.26k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 8.83k, False: 437] | | ------------------ ------------------ 107| 9.26k| if (!tns_order) ------------------ | Branch (107:17): [True: 4.27k, False: 4.99k] ------------------ 108| 4.27k| continue; 109| | 110| 4.99k| exp = tns_decode_coef(tns_order, tns->coef_res[w]+3, 111| 4.99k| tns->coef_compress[w][f], tns->coef[w][f], lpc); 112| | 113| 4.99k| start = min(bottom, max_tns_sfb(sr_index, object_type, (ics->window_sequence == EIGHT_SHORT_SEQUENCE))); ------------------ | | 60| 4.99k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 4.55k, False: 439] | | ------------------ ------------------ 114| 4.99k| start = min(start, ics->max_sfb); ------------------ | | 60| 4.99k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 438, False: 4.55k] | | ------------------ ------------------ 115| 4.99k| start = min(ics->swb_offset[start], ics->swb_offset_max); ------------------ | | 60| 4.99k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 4.99k, False: 1] | | ------------------ ------------------ 116| | 117| 4.99k| end = min(top, max_tns_sfb(sr_index, object_type, (ics->window_sequence == EIGHT_SHORT_SEQUENCE))); ------------------ | | 60| 4.99k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 2.15k, False: 2.84k] | | ------------------ ------------------ 118| 4.99k| end = min(end, ics->max_sfb); ------------------ | | 60| 4.99k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 182, False: 4.81k] | | ------------------ ------------------ 119| 4.99k| end = min(ics->swb_offset[end], ics->swb_offset_max); ------------------ | | 60| 4.99k|#define min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:20): [True: 4.97k, False: 17] | | ------------------ ------------------ 120| | 121| 4.99k| size = end - start; 122| 4.99k| if (size <= 0) ------------------ | Branch (122:17): [True: 4.65k, False: 341] ------------------ 123| 4.65k| continue; 124| | 125| 341| if (tns->direction[w][f]) ------------------ | Branch (125:17): [True: 262, False: 79] ------------------ 126| 262| { 127| 262| inc = -1; 128| 262| start = end - 1; 129| 262| } else { 130| 79| inc = 1; 131| 79| } 132| | 133| 341| tns_ar_filter(&spec[(w*nshort)+start], size, inc, lpc, tns_order, exp); 134| 341| } 135| 16.1k| } 136| 5.03k|} tns.c:tns_decode_coef: 196| 4.99k|{ 197| 4.99k| uint8_t i, m; 198| 4.99k| real_t tmp2[TNS_MAX_ORDER+1], b[TNS_MAX_ORDER+1]; 199| 4.99k| uint8_t table_index = 2 * (coef_compress != 0) + (coef_res_bits != 3); 200| 4.99k| real_t* tns_coef = all_tns_coefs[table_index]; 201| 4.99k| uint8_t exp = 0; 202| | 203| | /* Conversion to signed integer */ 204| 32.6k| for (i = 0; i < order; i++) ------------------ | Branch (204:17): [True: 27.6k, False: 4.99k] ------------------ 205| 27.6k| tmp2[i] = tns_coef[coef[i]]; 206| | 207| | /* Conversion to LPC coefficients */ 208| 4.99k| a[0] = COEF_CONST(1.0); ------------------ | | 60| 4.99k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 4.99k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 4.99k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 4.99k, Folded] | | ------------------ ------------------ 209| 32.6k| for (m = 1; m <= order; m++) ------------------ | Branch (209:17): [True: 27.6k, False: 4.99k] ------------------ 210| 27.6k| { 211| 27.6k| a[m] = tmp2[m-1]; /* changed */ 212| 172k| for (i = 1; i < m; i++) /* loop only while i> COEF_BITS) | | ------------------ | | | | 43| 145k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 145k|#define COEF_BITS 28 | | ------------------ ------------------ 214| | 215| 172k| for (i = 1; i < m; i++) /* loop only while i>= exp; 220| | 221| | /* OK not to check after the last iteration. */ 222| 27.6k| if (m < order) ------------------ | Branch (222:13): [True: 22.6k, False: 4.99k] ------------------ 223| 22.6k| { 224| 22.6k| real_t sum_abs = COEF_CONST(0.0); ------------------ | | 60| 22.6k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 22.6k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 22.6k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 22.6k, Folded] | | ------------------ ------------------ 225| 167k| for (i = 1; i <= m; ++i) ------------------ | Branch (225:25): [True: 145k, False: 22.6k] ------------------ 226| 145k| { 227| 145k| sum_abs += (a[i] >= 0) ? a[i] : -a[i]; ------------------ | Branch (227:28): [True: 77.2k, False: 68.0k] ------------------ 228| 145k| } 229| | /* Next iteration would turn sum to 2*sum + 1; maximal "coef" is 7.999 */ 230| 22.6k| if (sum_abs >= COEF_CONST(3.5)) ------------------ | | 60| 22.6k|#define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 22.6k|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 22.6k|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5))) | | ------------------ | | | | 44| 0|#define COEF_PRECISION (1 << COEF_BITS) | | | | ------------------ | | | | | | 43| 0|#define COEF_BITS 28 | | | | ------------------ | | ------------------ | | | Branch (60:24): [True: 22.6k, Folded] | | ------------------ ------------------ | Branch (230:17): [True: 2.74k, False: 19.8k] ------------------ 231| 2.74k| { 232| 2.74k| exp++; 233| 30.5k| for (i = 1; i <= m; ++i) ------------------ | Branch (233:29): [True: 27.7k, False: 2.74k] ------------------ 234| 27.7k| { 235| 27.7k| a[i] >>= 1; 236| 27.7k| } 237| 2.74k| } 238| 22.6k| } 239| 27.6k|#endif 240| 27.6k| } 241| 4.99k| return exp; 242| 4.99k|} tns.c:tns_ar_filter: 246| 341|{ 247| | /* 248| | - Simple all-pole filter of order "order" defined by 249| | y(n) = x(n) - lpc[1]*y(n-1) - ... - lpc[order]*y(n-order) 250| | - The state variables of the filter are initialized to zero every time 251| | - The output data is written over the input data ("in-place operation") 252| | - An input vector of "size" samples is processed and the index increment 253| | to the next data sample is given by "inc" 254| | */ 255| | 256| 341| uint8_t j; 257| 341| uint16_t i; 258| | /* state is stored as a double ringbuffer */ 259| 341| real_t state[2*TNS_MAX_ORDER] = {0}; 260| 341| int8_t state_index = 0; 261| 341| int32_t mul = 1; 262| | 263| 341|#ifdef FIXED_POINT 264| 341| if (exp >= 4) ------------------ | Branch (264:9): [True: 61, False: 280] ------------------ 265| 61| return; 266| 280| mul = 1 << exp; 267| |#else 268| | (void)exp; 269| |#endif 270| | 271| 15.4k| for (i = 0; i < size; i++) ------------------ | Branch (271:17): [True: 15.1k, False: 280] ------------------ 272| 15.1k| { 273| 15.1k| real_t y = REAL_CONST(0.0); ------------------ | | 59| 15.1k|#define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 15.1k|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 15.1k|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5))) | | ------------------ | | | | 46| 0|#define REAL_PRECISION (1 << REAL_BITS) | | | | ------------------ | | | | | | 45| 0|#define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR | | | | ------------------ | | ------------------ | | | Branch (59:24): [True: 15.1k, Folded] | | ------------------ ------------------ 274| 164k| for (j = 0; j < order; j++) ------------------ | Branch (274:21): [True: 148k, False: 15.1k] ------------------ 275| 148k| y += MUL_C(state[state_index+j], lpc[j+1]); ------------------ | | 241| 148k| #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 148k|#define COEF_BITS 28 | | ------------------ | | #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS) | | ------------------ | | | | 43| 148k|#define COEF_BITS 28 | | ------------------ ------------------ 276| 15.1k| y = *spectrum - (y * mul); 277| | 278| | /* double ringbuffer state */ 279| 15.1k| state_index--; 280| 15.1k| if (state_index < 0) ------------------ | Branch (280:13): [True: 2.46k, False: 12.7k] ------------------ 281| 2.46k| state_index = order-1; 282| 15.1k| state[state_index] = state[state_index + order] = y; 283| | 284| 15.1k| *spectrum = y; 285| 15.1k| spectrum += inc; 286| | 287| |//#define TNS_PRINT 288| |#ifdef TNS_PRINT 289| | //printf("%d\n", y); 290| | printf("0x%.8X\n", y); 291| |#endif 292| 15.1k| } 293| 280|}