stream_encoder.c:safe_calloc_: 116| 58.9k|{ 117| 58.9k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 118| | /* Fail if requested */ 119| 58.9k| if(alloc_check()) ------------------ | Branch (119:5): [True: 0, False: 58.9k] ------------------ 120| 0| return NULL; 121| 58.9k|#endif 122| 58.9k| if(!nmemb || !size) ------------------ | Branch (122:5): [True: 0, False: 58.9k] | Branch (122:15): [True: 0, False: 58.9k] ------------------ 123| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 124| 58.9k| return calloc(nmemb, size); 125| 58.9k|} stream_encoder.c:alloc_check: 70| 58.9k|static inline int alloc_check(void) { 71| 58.9k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 58.9k, False: 0] ------------------ 72| 58.9k| return 0; 73| 0| else if(alloc_check_counter++ == alloc_check_threshold) ------------------ | Branch (73:10): [True: 0, False: 0] ------------------ 74| 0| return 1; 75| 0| else if(alloc_check_keep_failing && (alloc_check_counter > alloc_check_threshold)) ------------------ | Branch (75:10): [True: 0, False: 0] | Branch (75:38): [True: 0, False: 0] ------------------ 76| 0| return 1; 77| 0| else { 78| 0| return 0; 79| 0| } 80| 58.9k|} bitwriter.c:safe_realloc_nofree_mul_2op_: 290| 1.68k|{ 291| 1.68k| if(!size1 || !size2) ------------------ | Branch (291:5): [True: 0, False: 1.68k] | Branch (291:15): [True: 0, False: 1.68k] ------------------ 292| 0| return realloc(ptr, 0); /* preserve POSIX realloc(ptr, 0) semantics */ 293| 1.68k| if(size1 > SIZE_MAX / size2) ------------------ | Branch (293:5): [True: 0, False: 1.68k] ------------------ 294| 0| return 0; 295| 1.68k| return realloc_(ptr, size1*size2); 296| 1.68k|} bitwriter.c:realloc_: 219| 1.68k|{ 220| | /* Fail if requested */ 221| 1.68k| if(alloc_check()) ------------------ | Branch (221:5): [True: 0, False: 1.68k] ------------------ 222| 0| return NULL; 223| 1.68k| return realloc(ptr, size); 224| 1.68k|} bitwriter.c:alloc_check: 70| 1.68k|static inline int alloc_check(void) { 71| 1.68k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 1.68k, False: 0] ------------------ 72| 1.68k| return 0; 73| 0| else if(alloc_check_counter++ == alloc_check_threshold) ------------------ | Branch (73:10): [True: 0, False: 0] ------------------ 74| 0| return 1; 75| 0| else if(alloc_check_keep_failing && (alloc_check_counter > alloc_check_threshold)) ------------------ | Branch (75:10): [True: 0, False: 0] | Branch (75:38): [True: 0, False: 0] ------------------ 76| 0| return 1; 77| 0| else { 78| 0| return 0; 79| 0| } 80| 1.68k|} format.c:safe_realloc_: 200| 425k|{ 201| 425k| void *oldptr; 202| 425k| void *newptr; 203| 425k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 204| | /* Fail if requested */ 205| 425k| if(alloc_check() && size > 0) { ------------------ | Branch (205:5): [True: 0, False: 425k] | Branch (205:22): [True: 0, False: 0] ------------------ 206| 0| free(ptr); 207| 0| return NULL; 208| 0| } 209| 425k|#endif 210| 425k| oldptr = ptr; 211| 425k| newptr = realloc(ptr, size); 212| 425k| if(size > 0 && newptr == 0) ------------------ | Branch (212:5): [True: 425k, False: 0] | Branch (212:17): [True: 0, False: 425k] ------------------ 213| 0| free(oldptr); 214| 425k| return newptr; 215| 425k|} format.c:alloc_check: 70| 425k|static inline int alloc_check(void) { 71| 425k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 425k, False: 0] ------------------ 72| 425k| return 0; 73| 0| else if(alloc_check_counter++ == alloc_check_threshold) ------------------ | Branch (73:10): [True: 0, False: 0] ------------------ 74| 0| return 1; 75| 0| else if(alloc_check_keep_failing && (alloc_check_counter > alloc_check_threshold)) ------------------ | Branch (75:10): [True: 0, False: 0] | Branch (75:38): [True: 0, False: 0] ------------------ 76| 0| return 1; 77| 0| else { 78| 0| return 0; 79| 0| } 80| 425k|} md5.c:safe_realloc_: 200| 9.06k|{ 201| 9.06k| void *oldptr; 202| 9.06k| void *newptr; 203| 9.06k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 204| | /* Fail if requested */ 205| 9.06k| if(alloc_check() && size > 0) { ------------------ | Branch (205:5): [True: 0, False: 9.06k] | Branch (205:22): [True: 0, False: 0] ------------------ 206| 0| free(ptr); 207| 0| return NULL; 208| 0| } 209| 9.06k|#endif 210| 9.06k| oldptr = ptr; 211| 9.06k| newptr = realloc(ptr, size); 212| 9.06k| if(size > 0 && newptr == 0) ------------------ | Branch (212:5): [True: 9.06k, False: 0] | Branch (212:17): [True: 0, False: 9.06k] ------------------ 213| 0| free(oldptr); 214| 9.06k| return newptr; 215| 9.06k|} md5.c:alloc_check: 70| 9.06k|static inline int alloc_check(void) { 71| 9.06k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 9.06k, False: 0] ------------------ 72| 9.06k| return 0; 73| 0| else if(alloc_check_counter++ == alloc_check_threshold) ------------------ | Branch (73:10): [True: 0, False: 0] ------------------ 74| 0| return 1; 75| 0| else if(alloc_check_keep_failing && (alloc_check_counter > alloc_check_threshold)) ------------------ | Branch (75:10): [True: 0, False: 0] | Branch (75:38): [True: 0, False: 0] ------------------ 76| 0| return 1; 77| 0| else { 78| 0| return 0; 79| 0| } 80| 9.06k|} memory.c:safe_malloc_add_2op_: 130| 346k|{ 131| 346k| size2 += size1; 132| 346k| if(size2 < size1) ------------------ | Branch (132:5): [True: 0, False: 346k] ------------------ 133| 0| return 0; 134| 346k| return safe_malloc_(size2); 135| 346k|} memory.c:safe_malloc_: 89| 346k|{ 90| 346k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 91| | /* Fail if requested */ 92| 346k| if(alloc_check()) ------------------ | Branch (92:5): [True: 0, False: 346k] ------------------ 93| 0| return NULL; 94| 346k|#endif 95| | /* malloc(0) is undefined; FLAC src convention is to always allocate */ 96| 346k| if(!size) ------------------ | Branch (96:5): [True: 0, False: 346k] ------------------ 97| 0| size++; 98| 346k| return malloc(size); 99| 346k|} memory.c:alloc_check: 70| 346k|static inline int alloc_check(void) { 71| 346k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 346k, False: 0] ------------------ 72| 346k| return 0; 73| 0| else if(alloc_check_counter++ == alloc_check_threshold) ------------------ | Branch (73:10): [True: 0, False: 0] ------------------ 74| 0| return 1; 75| 0| else if(alloc_check_keep_failing && (alloc_check_counter > alloc_check_threshold)) ------------------ | Branch (75:10): [True: 0, False: 0] | Branch (75:38): [True: 0, False: 0] ------------------ 76| 0| return 1; 77| 0| else { 78| 0| return 0; 79| 0| } 80| 346k|} stream_decoder.c:safe_calloc_: 116| 24.4k|{ 117| 24.4k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 118| | /* Fail if requested */ 119| 24.4k| if(alloc_check()) ------------------ | Branch (119:5): [True: 0, False: 24.4k] ------------------ 120| 0| return NULL; 121| 24.4k|#endif 122| 24.4k| if(!nmemb || !size) ------------------ | Branch (122:5): [True: 0, False: 24.4k] | Branch (122:15): [True: 0, False: 24.4k] ------------------ 123| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 124| 24.4k| return calloc(nmemb, size); 125| 24.4k|} stream_decoder.c:alloc_check: 70| 37.8k|static inline int alloc_check(void) { 71| 37.8k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 37.8k, False: 0] ------------------ 72| 37.8k| return 0; 73| 0| else if(alloc_check_counter++ == alloc_check_threshold) ------------------ | Branch (73:10): [True: 0, False: 0] ------------------ 74| 0| return 1; 75| 0| else if(alloc_check_keep_failing && (alloc_check_counter > alloc_check_threshold)) ------------------ | Branch (75:10): [True: 0, False: 0] | Branch (75:38): [True: 0, False: 0] ------------------ 76| 0| return 1; 77| 0| else { 78| 0| return 0; 79| 0| } 80| 37.8k|} stream_decoder.c:safe_malloc_muladd2_: 188| 13.3k|{ 189| 13.3k| if(!size1 || (!size2 && !size3)) ------------------ | Branch (189:5): [True: 0, False: 13.3k] | Branch (189:16): [True: 0, False: 13.3k] | Branch (189:26): [True: 0, False: 0] ------------------ 190| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 191| 13.3k| size2 += size3; 192| 13.3k| if(size2 < size3) ------------------ | Branch (192:5): [True: 0, False: 13.3k] ------------------ 193| 0| return 0; 194| 13.3k| if(size1 > SIZE_MAX / size2) ------------------ | Branch (194:5): [True: 0, False: 13.3k] ------------------ 195| 0| return 0; 196| 13.3k| return malloc_(size1*size2); 197| 13.3k|} stream_decoder.c:malloc_: 103| 13.3k|{ 104| | /* Fail if requested */ 105| 13.3k| if(alloc_check()) ------------------ | Branch (105:5): [True: 0, False: 13.3k] ------------------ 106| 0| return NULL; 107| 13.3k| return malloc(size); 108| 13.3k|} LLVMFuzzerTestOneInput: 58| 11.5k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 59| 11.5k| fuzzing::datasource::Datasource ds(data, size); 60| 11.5k| FLAC::Encoder::FuzzerStream encoder(ds); 61| | 62| 11.5k| try { 63| 11.5k| const int channels = ds.Get(); 64| 11.5k| const int bps = ds.Get(); 65| 11.5k| encoder.set_channels(channels); 66| 11.5k| encoder.set_bits_per_sample(bps); 67| | 68| 11.5k| { 69| 11.5k| const bool res = encoder.set_streamable_subset(ds.Get()); 70| 11.5k| fuzzing::memory::memory_test(res); 71| 11.5k| } 72| 11.5k| { 73| 11.5k| const bool res = encoder.set_ogg_serial_number(ds.Get()); 74| 11.5k| fuzzing::memory::memory_test(res); 75| 11.5k| } 76| 11.5k| { 77| 11.5k| const bool res = encoder.set_verify(ds.Get()); 78| 11.5k| fuzzing::memory::memory_test(res); 79| 11.5k| } 80| 11.5k| { 81| 11.5k| const bool res = encoder.set_compression_level(ds.Get()); 82| 11.5k| fuzzing::memory::memory_test(res); 83| 11.5k| } 84| 11.5k| { 85| 11.5k| const bool res = encoder.set_do_exhaustive_model_search(ds.Get()); 86| 11.5k| fuzzing::memory::memory_test(res); 87| 11.5k| } 88| 11.5k| { 89| 11.5k| const bool res = encoder.set_do_mid_side_stereo(ds.Get()); 90| 11.5k| fuzzing::memory::memory_test(res); 91| 11.5k| } 92| 11.5k| { 93| 11.5k| const bool res = encoder.set_loose_mid_side_stereo(ds.Get()); 94| 11.5k| fuzzing::memory::memory_test(res); 95| 11.5k| } 96| 11.5k| { 97| 11.5k| const auto s = ds.Get(); 98| 11.5k| const bool res = encoder.set_apodization(s.data()); 99| 11.5k| fuzzing::memory::memory_test(res); 100| 11.5k| } 101| 11.5k| { 102| 11.5k| const bool res = encoder.set_max_lpc_order(ds.Get()); 103| 11.5k| fuzzing::memory::memory_test(res); 104| 11.5k| } 105| 11.5k| { 106| 11.5k| const bool res = encoder.set_qlp_coeff_precision(ds.Get()); 107| 11.5k| fuzzing::memory::memory_test(res); 108| 11.5k| } 109| 11.5k| { 110| 11.5k| const bool res = encoder.set_do_qlp_coeff_prec_search(ds.Get()); 111| 11.5k| fuzzing::memory::memory_test(res); 112| 11.5k| } 113| 11.5k| { 114| 11.5k| const bool res = encoder.set_do_escape_coding(ds.Get()); 115| 11.5k| fuzzing::memory::memory_test(res); 116| 11.5k| } 117| 11.5k| { 118| 11.5k| const bool res = encoder.set_min_residual_partition_order(ds.Get()); 119| 11.5k| fuzzing::memory::memory_test(res); 120| 11.5k| } 121| 11.5k| { 122| 11.5k| const bool res = encoder.set_max_residual_partition_order(ds.Get()); 123| 11.5k| fuzzing::memory::memory_test(res); 124| 11.5k| } 125| 11.5k| { 126| 11.5k| const bool res = encoder.set_rice_parameter_search_dist(ds.Get()); 127| 11.5k| fuzzing::memory::memory_test(res); 128| 11.5k| } 129| 11.5k| { 130| 11.5k| const bool res = encoder.set_total_samples_estimate(ds.Get()); 131| 11.5k| fuzzing::memory::memory_test(res); 132| 11.5k| } 133| 11.5k| { 134| 11.5k| const bool res = encoder.set_blocksize(ds.Get()); 135| 11.5k| fuzzing::memory::memory_test(res); 136| 11.5k| } 137| 11.5k| { 138| 11.5k| const bool res = encoder.set_limit_min_bitrate(ds.Get()); 139| 11.5k| fuzzing::memory::memory_test(res); 140| 11.5k| } 141| 11.5k| { 142| 11.5k| const bool res = encoder.set_sample_rate(ds.Get()); 143| 11.5k| fuzzing::memory::memory_test(res); 144| 11.5k| } 145| 11.5k| { 146| 11.5k| const bool res = encoder.set_num_threads(ds.Get()); 147| 11.5k| fuzzing::memory::memory_test(res); 148| 11.5k| } 149| | 150| 11.5k| if ( size > 2 * 65535 * 4 ) { ------------------ | Branch (150:14): [True: 206, False: 11.3k] ------------------ 151| | /* With large inputs and expensive options enabled, the fuzzer can get *really* slow. 152| | * Some combinations can make the fuzzer timeout (>60 seconds). However, while combining 153| | * options makes the fuzzer slower, most options do not expose new code when combined. 154| | * Therefore, combining slow options is disabled for large inputs. Any input containing 155| | * more than 65536 * 2 samples of 32 bits each (max blocksize, stereo) is considered large 156| | */ 157| 206| encoder.set_do_qlp_coeff_prec_search(false); 158| 206| encoder.set_do_exhaustive_model_search(false); 159| 206| } 160| 11.5k| if ( size > 2 * 4096 * 4 + 250 ) { ------------------ | Branch (160:14): [True: 1.37k, False: 10.1k] ------------------ 161| | /* With subdivide_tukey in the mix testing apodizations can get really expensive. Therefore 162| | * this is disabled for inputs of more than one whole stereo block of 32-bit inputs plus a 163| | * bit of overhead */ 164| 1.37k| encoder.set_apodization(""); 165| 1.37k| } 166| | 167| 11.5k| { 168| 11.5k| ::FLAC__StreamEncoderInitStatus ret; 169| 11.5k| if ( ds.Get() ) { ------------------ | Branch (169:18): [True: 6.64k, False: 4.93k] ------------------ 170| 6.64k| ret = encoder.init(); 171| 6.64k| } else { 172| 4.93k| ret = encoder.init_ogg(); 173| 4.93k| } 174| | 175| 11.5k| if ( ret != FLAC__STREAM_ENCODER_INIT_STATUS_OK ) { ------------------ | Branch (175:18): [True: 265, False: 11.3k] ------------------ 176| 265| goto end; 177| 265| } 178| 11.5k| } 179| | 180| | /* These sets must fail, because encoder is already initialized */ 181| 11.3k| { 182| 11.3k| bool res = false; 183| 11.3k| res = res || encoder.set_streamable_subset(true); ------------------ | Branch (183:19): [True: 1.93k, False: 9.37k] | Branch (183:26): [True: 0, False: 9.37k] ------------------ 184| 11.3k| res = res || encoder.set_ogg_serial_number(0); ------------------ | Branch (184:19): [True: 1.93k, False: 9.37k] | Branch (184:26): [True: 0, False: 9.37k] ------------------ 185| 11.3k| res = res || encoder.set_verify(true); ------------------ | Branch (185:19): [True: 1.93k, False: 9.37k] | Branch (185:26): [True: 0, False: 9.37k] ------------------ 186| 11.3k| res = res || encoder.set_compression_level(0); ------------------ | Branch (186:19): [True: 1.93k, False: 9.37k] | Branch (186:26): [True: 0, False: 9.37k] ------------------ 187| 11.3k| res = res || encoder.set_do_exhaustive_model_search(true); ------------------ | Branch (187:19): [True: 1.93k, False: 9.37k] | Branch (187:26): [True: 0, False: 9.37k] ------------------ 188| 11.3k| res = res || encoder.set_do_mid_side_stereo(true); ------------------ | Branch (188:19): [True: 1.93k, False: 9.37k] | Branch (188:26): [True: 0, False: 9.37k] ------------------ 189| 11.3k| res = res || encoder.set_loose_mid_side_stereo(true); ------------------ | Branch (189:19): [True: 1.93k, False: 9.37k] | Branch (189:26): [True: 0, False: 9.37k] ------------------ 190| 11.3k| res = res || encoder.set_apodization("test"); ------------------ | Branch (190:19): [True: 1.93k, False: 9.37k] | Branch (190:26): [True: 0, False: 9.37k] ------------------ 191| 11.3k| res = res || encoder.set_max_lpc_order(0); ------------------ | Branch (191:19): [True: 1.93k, False: 9.37k] | Branch (191:26): [True: 0, False: 9.37k] ------------------ 192| 11.3k| res = res || encoder.set_qlp_coeff_precision(0); ------------------ | Branch (192:19): [True: 1.93k, False: 9.37k] | Branch (192:26): [True: 0, False: 9.37k] ------------------ 193| 11.3k| res = res || encoder.set_do_qlp_coeff_prec_search(true); ------------------ | Branch (193:19): [True: 1.93k, False: 9.37k] | Branch (193:26): [True: 0, False: 9.37k] ------------------ 194| 11.3k| res = res || encoder.set_do_escape_coding(true); ------------------ | Branch (194:19): [True: 1.93k, False: 9.37k] | Branch (194:26): [True: 0, False: 9.37k] ------------------ 195| 11.3k| res = res || encoder.set_min_residual_partition_order(0); ------------------ | Branch (195:19): [True: 1.93k, False: 9.37k] | Branch (195:26): [True: 0, False: 9.37k] ------------------ 196| 11.3k| res = res || encoder.set_max_residual_partition_order(0); ------------------ | Branch (196:19): [True: 1.93k, False: 9.37k] | Branch (196:26): [True: 0, False: 9.37k] ------------------ 197| 11.3k| res = res || encoder.set_rice_parameter_search_dist(0); ------------------ | Branch (197:19): [True: 1.93k, False: 9.37k] | Branch (197:26): [True: 0, False: 9.37k] ------------------ 198| 11.3k| res = res || encoder.set_total_samples_estimate(0); ------------------ | Branch (198:19): [True: 1.93k, False: 9.37k] | Branch (198:26): [True: 0, False: 9.37k] ------------------ 199| 11.3k| res = res || encoder.set_channels(channels); ------------------ | Branch (199:19): [True: 1.93k, False: 9.37k] | Branch (199:26): [True: 0, False: 9.37k] ------------------ 200| 11.3k| res = res || encoder.set_bits_per_sample(16); ------------------ | Branch (200:19): [True: 1.93k, False: 9.37k] | Branch (200:26): [True: 0, False: 9.37k] ------------------ 201| 11.3k| res = res || encoder.set_limit_min_bitrate(true); ------------------ | Branch (201:19): [True: 1.93k, False: 9.37k] | Branch (201:26): [True: 0, False: 9.37k] ------------------ 202| 11.3k| res = res || encoder.set_blocksize(3021); ------------------ | Branch (202:19): [True: 1.93k, False: 9.37k] | Branch (202:26): [True: 0, False: 9.37k] ------------------ 203| 11.3k| res = res || encoder.set_sample_rate(44100); ------------------ | Branch (203:19): [True: 1.93k, False: 9.37k] | Branch (203:26): [True: 0, False: 9.37k] ------------------ 204| 11.3k| res = res || (encoder.set_num_threads(4) == FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK); ------------------ | | 291| 9.37k|#define FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK 0 ------------------ | Branch (204:19): [True: 1.93k, False: 9.37k] | Branch (204:26): [True: 0, False: 9.37k] ------------------ 205| 11.3k| fuzzing::memory::memory_test(res); 206| 11.3k| if(res) ------------------ | Branch (206:16): [True: 0, False: 11.3k] ------------------ 207| 0| abort(); 208| 11.3k| } 209| | 210| | 211| 11.3k| { 212| | /* XORing values as otherwise compiler will optimize, apparently */ 213| 11.3k| bool res = false; 214| 11.3k| res = res != encoder.get_streamable_subset(); 215| 11.3k| res = res != encoder.get_verify(); 216| 11.3k| res = res != encoder.get_do_exhaustive_model_search(); 217| 11.3k| res = res != encoder.get_do_mid_side_stereo(); 218| 11.3k| res = res != encoder.get_loose_mid_side_stereo(); 219| 11.3k| res = res != encoder.get_max_lpc_order(); 220| 11.3k| res = res != encoder.get_qlp_coeff_precision(); 221| 11.3k| res = res != encoder.get_do_qlp_coeff_prec_search(); 222| 11.3k| res = res != encoder.get_do_escape_coding(); 223| 11.3k| res = res != encoder.get_min_residual_partition_order(); 224| 11.3k| res = res != encoder.get_max_residual_partition_order(); 225| 11.3k| res = res != encoder.get_rice_parameter_search_dist(); 226| 11.3k| res = res != encoder.get_total_samples_estimate(); 227| 11.3k| res = res != encoder.get_channels(); 228| 11.3k| res = res != encoder.get_bits_per_sample(); 229| 11.3k| res = res != encoder.get_limit_min_bitrate(); 230| 11.3k| res = res != encoder.get_blocksize(); 231| 11.3k| res = res != encoder.get_sample_rate(); 232| 11.3k| res = res != encoder.get_num_threads(); 233| 11.3k| fuzzing::memory::memory_test(res); 234| 11.3k| } 235| | 236| | 237| 224k| while ( ds.Get() ) { ------------------ | Branch (237:17): [True: 213k, False: 11.3k] ------------------ 238| 213k| { 239| 213k| auto dat = ds.GetVector(); 240| | 241| 213k| if( ds.Get() ) ------------------ | Branch (241:21): [True: 193k, False: 20.1k] ------------------ 242| | /* Mask */ 243| 23.7M| for (size_t i = 0; i < dat.size(); i++) ------------------ | Branch (243:40): [True: 23.5M, False: 193k] ------------------ 244| | /* If we get here, bps is 4 or larger, or init will have failed */ 245| 23.5M| dat[i] = (int32_t)(((uint32_t)(dat[i]) << (32-bps)) >> (32-bps)); 246| | 247| 213k| const uint32_t samples = dat.size() / channels; 248| 213k| if ( samples > 0 ) { ------------------ | Branch (248:22): [True: 178k, False: 34.7k] ------------------ 249| 178k| const int32_t* ptr = dat.data(); 250| 178k| const bool res = encoder.process_interleaved(ptr, samples); 251| 178k| fuzzing::memory::memory_test(res); 252| 178k| } 253| 213k| } 254| 213k| } 255| 11.3k| } catch ( ... ) { } 256| | 257| 11.5k|end: 258| 11.5k| { 259| 11.5k| const bool res = encoder.finish(); 260| 11.5k| fuzzing::memory::memory_test(res); 261| 11.5k| } 262| 11.5k| return 0; 263| 11.5k|} _ZN4FLAC7Encoder12FuzzerStreamC2ERN7fuzzing10datasource10DatasourceE: 41| 11.5k| Stream() { } _ZN4FLAC7Encoder12FuzzerStream14write_callbackEPKhmjj: 43| 147k| ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte buffer[], size_t bytes, uint32_t /* samples */, uint32_t /* current_frame */) override { 44| 147k| fuzzing::memory::memory_test(buffer, bytes); 45| |#if 0 46| | try { 47| | if ( ds.Get() == true ) { 48| | return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 49| | } 50| | } catch ( ... ) { } 51| |#endif 52| 147k| return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 53| 147k| } _ZN7fuzzing10datasource4Base3GetIbEET_m: 72| 30.3M|{ 73| 30.3M| uint8_t ret; 74| 30.3M| const auto v = get(sizeof(ret), sizeof(ret), id); 75| 30.3M| memcpy(&ret, v.data(), sizeof(ret)); 76| 30.3M| return (ret % 2) ? true : false; ------------------ | Branch (76:12): [True: 30.0M, False: 280k] ------------------ 77| 30.3M|} _ZN7fuzzing10datasource4Base3GetINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_m: 80| 11.5k|{ 81| 11.5k| auto data = GetData(id); 82| 11.5k| return std::string(data.data(), data.data() + data.size()); 83| 11.5k|} _ZN7fuzzing10datasource4Base7GetDataEmmm: 104| 11.5k|{ 105| 11.5k| return get(min, max, id); 106| 11.5k|} _ZN7fuzzing10datasource10DatasourceC2EPKhm: 151| 11.5k| Base(), data(_data), size(_size), idx(0), left(size) 152| 11.5k|{ 153| 11.5k|} _ZN7fuzzing10datasource10Datasource3getEmmm: 155| 60.0M|std::vector Datasource::get(const size_t min, const size_t max, const uint64_t id) { 156| 60.0M| (void)id; 157| | 158| 60.0M| uint32_t getSize; 159| 60.0M| if ( left < sizeof(getSize) ) { ------------------ | Branch (159:10): [True: 8.91k, False: 60.0M] ------------------ 160| 8.91k| throw OutOfData(); 161| 8.91k| } 162| 60.0M| memcpy(&getSize, data + idx, sizeof(getSize)); 163| 60.0M| idx += sizeof(getSize); 164| 60.0M| left -= sizeof(getSize); 165| | 166| 60.0M| if ( getSize < min ) { ------------------ | Branch (166:10): [True: 34.8k, False: 59.9M] ------------------ 167| 34.8k| getSize = min; 168| 34.8k| } 169| 60.0M| if ( max && getSize > max ) { ------------------ | Branch (169:10): [True: 60.0M, False: 11.5k] | Branch (169:17): [True: 59.9M, False: 35.3k] ------------------ 170| 59.9M| getSize = max; 171| 59.9M| } 172| | 173| 60.0M| if ( left < getSize ) { ------------------ | Branch (173:10): [True: 1.03k, False: 60.0M] ------------------ 174| 1.03k| throw OutOfData(); 175| 1.03k| } 176| | 177| 60.0M| std::vector ret(getSize); 178| | 179| 60.0M| if ( getSize > 0 ) { ------------------ | Branch (179:10): [True: 60.0M, False: 7.72k] ------------------ 180| 60.0M| memcpy(ret.data(), data + idx, getSize); 181| 60.0M| } 182| 60.0M| idx += getSize; 183| 60.0M| left -= getSize; 184| | 185| 60.0M| return ret; 186| 60.0M|} _ZN7fuzzing10datasource4BaseC2Ev: 43| 11.5k| Base(void) = default; _ZN7fuzzing10datasource4BaseD2Ev: 44| 11.5k| virtual ~Base(void) = default; _ZN7fuzzing10datasource4Base9OutOfDataC2Ev: 53| 9.94k| OutOfData() = default; _ZN7fuzzing10datasource4Base3GetItEET_m: 64| 9.78k|{ 65| 9.78k| T ret; 66| 9.78k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 9.78k| memcpy(&ret, v.data(), sizeof(ret)); 68| 9.78k| return ret; 69| 9.78k|} _ZN7fuzzing10datasource4Base3GetIhEET_m: 64| 46.1k|{ 65| 46.1k| T ret; 66| 46.1k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 46.1k| memcpy(&ret, v.data(), sizeof(ret)); 68| 46.1k| return ret; 69| 46.1k|} _ZN7fuzzing10datasource4Base3GetIlEET_m: 64| 11.5k|{ 65| 11.5k| T ret; 66| 11.5k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 11.5k| memcpy(&ret, v.data(), sizeof(ret)); 68| 11.5k| return ret; 69| 11.5k|} _ZN7fuzzing10datasource4Base3GetIjEET_m: 64| 58.7k|{ 65| 58.7k| T ret; 66| 58.7k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 58.7k| memcpy(&ret, v.data(), sizeof(ret)); 68| 58.7k| return ret; 69| 58.7k|} _ZN7fuzzing10datasource4Base3GetImEET_m: 64| 9.79k|{ 65| 9.79k| T ret; 66| 9.79k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 9.79k| memcpy(&ret, v.data(), sizeof(ret)); 68| 9.79k| return ret; 69| 9.79k|} _ZN7fuzzing10datasource4Base9GetVectorIiEENSt3__16vectorIT_NS3_9allocatorIS5_EEEEm: 122| 213k|std::vector Base::GetVector(const uint64_t id) { 123| 213k| std::vector ret; 124| | 125| 29.7M| while ( Get(id) == true ) { ------------------ | Branch (125:13): [True: 29.5M, False: 213k] ------------------ 126| 29.5M| ret.push_back( Get(id) ); 127| 29.5M| } 128| | 129| 213k| return ret; 130| 213k|} _ZN7fuzzing10datasource4Base3GetIiEET_m: 64| 29.5M|{ 65| 29.5M| T ret; 66| 29.5M| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 29.5M| memcpy(&ret, v.data(), sizeof(ret)); 68| 29.5M| return ret; 69| 29.5M|} _ZN7fuzzing9exception13FlowExceptionC2Ev: 41| 9.94k| FlowException(void) : ExceptionBase() { } _ZN7fuzzing9exception13ExceptionBaseC2Ev: 34| 9.94k| ExceptionBase(void) = default; _ZN7fuzzing6memory16memory_test_asanEPKvm: 50| 147k|{ 51| 147k| (void)data; 52| 147k| (void)size; 53| | 54| |#if ASAN == 1 55| | if ( __asan_region_is_poisoned(data, size) != NULL ) { 56| | abort(); 57| | } 58| |#endif 59| 147k|} _ZN7fuzzing6memory16memory_test_msanEPKvm: 62| 147k|{ 63| 147k| (void)data; 64| 147k| (void)size; 65| | 66| |#if MSAN == 1 67| | __msan_check_mem_is_initialized(data, size); 68| |#endif 69| 147k|} _ZN7fuzzing6memory11memory_testEPKvm: 72| 147k|{ 73| 147k| memory_test_asan(data, size); 74| 147k| memory_test_msan(data, size); 75| 147k|} _ZN7fuzzing6memory11memory_testIbEEvRKT_: 79| 418k|{ 80| 418k| (void)t; 81| 418k|} _ZN4FLAC7Encoder6StreamC2Ev: 56| 11.5k| encoder_(::FLAC__stream_encoder_new()) 57| 11.5k| { } _ZN4FLAC7Encoder6StreamD2Ev: 60| 11.5k| { 61| 11.5k| if(0 != encoder_) { ------------------ | Branch (61:7): [True: 11.5k, False: 0] ------------------ 62| 11.5k| (void)::FLAC__stream_encoder_finish(encoder_); 63| 11.5k| ::FLAC__stream_encoder_delete(encoder_); 64| 11.5k| } 65| 11.5k| } _ZNK4FLAC7Encoder6Stream8is_validEv: 68| 818k| { 69| 818k| return 0 != encoder_; 70| 818k| } _ZN4FLAC7Encoder6Stream21set_ogg_serial_numberEl: 73| 20.8k| { 74| 20.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 75| 20.8k| return static_cast(::FLAC__stream_encoder_set_ogg_serial_number(encoder_, value)); 76| 20.8k| } _ZN4FLAC7Encoder6Stream10set_verifyEb: 79| 20.8k| { 80| 20.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 81| 20.8k| return static_cast(::FLAC__stream_encoder_set_verify(encoder_, value)); 82| 20.8k| } _ZN4FLAC7Encoder6Stream21set_streamable_subsetEb: 85| 20.9k| { 86| 20.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 87| 20.9k| return static_cast(::FLAC__stream_encoder_set_streamable_subset(encoder_, value)); 88| 20.9k| } _ZN4FLAC7Encoder6Stream12set_channelsEj: 91| 20.9k| { 92| 20.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 93| 20.9k| return static_cast(::FLAC__stream_encoder_set_channels(encoder_, value)); 94| 20.9k| } _ZN4FLAC7Encoder6Stream19set_bits_per_sampleEj: 97| 20.9k| { 98| 20.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 99| 20.9k| return static_cast(::FLAC__stream_encoder_set_bits_per_sample(encoder_, value)); 100| 20.9k| } _ZN4FLAC7Encoder6Stream15set_sample_rateEj: 103| 19.0k| { 104| 19.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 105| 19.0k| return static_cast(::FLAC__stream_encoder_set_sample_rate(encoder_, value)); 106| 19.0k| } _ZN4FLAC7Encoder6Stream21set_compression_levelEj: 109| 20.8k| { 110| 20.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 111| 20.8k| return static_cast(::FLAC__stream_encoder_set_compression_level(encoder_, value)); 112| 20.8k| } _ZN4FLAC7Encoder6Stream13set_blocksizeEj: 115| 19.0k| { 116| 19.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 117| 19.0k| return static_cast(::FLAC__stream_encoder_set_blocksize(encoder_, value)); 118| 19.0k| } _ZN4FLAC7Encoder6Stream22set_do_mid_side_stereoEb: 121| 20.8k| { 122| 20.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 123| 20.8k| return static_cast(::FLAC__stream_encoder_set_do_mid_side_stereo(encoder_, value)); 124| 20.8k| } _ZN4FLAC7Encoder6Stream25set_loose_mid_side_stereoEb: 127| 20.8k| { 128| 20.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 129| 20.8k| return static_cast(::FLAC__stream_encoder_set_loose_mid_side_stereo(encoder_, value)); 130| 20.8k| } _ZN4FLAC7Encoder6Stream15set_apodizationEPKc: 133| 22.2k| { 134| 22.2k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 22.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 22.2k] | | ------------------ ------------------ 135| 22.2k| return static_cast(::FLAC__stream_encoder_set_apodization(encoder_, specification)); 136| 22.2k| } _ZN4FLAC7Encoder6Stream17set_max_lpc_orderEj: 139| 19.3k| { 140| 19.3k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.3k] | | ------------------ ------------------ 141| 19.3k| return static_cast(::FLAC__stream_encoder_set_max_lpc_order(encoder_, value)); 142| 19.3k| } _ZN4FLAC7Encoder6Stream23set_qlp_coeff_precisionEj: 145| 19.2k| { 146| 19.2k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.2k] | | ------------------ ------------------ 147| 19.2k| return static_cast(::FLAC__stream_encoder_set_qlp_coeff_precision(encoder_, value)); 148| 19.2k| } _ZN4FLAC7Encoder6Stream28set_do_qlp_coeff_prec_searchEb: 151| 19.4k| { 152| 19.4k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.4k] | | ------------------ ------------------ 153| 19.4k| return static_cast(::FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder_, value)); 154| 19.4k| } _ZN4FLAC7Encoder6Stream20set_do_escape_codingEb: 157| 19.1k| { 158| 19.1k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 159| 19.1k| return static_cast(::FLAC__stream_encoder_set_do_escape_coding(encoder_, value)); 160| 19.1k| } _ZN4FLAC7Encoder6Stream30set_do_exhaustive_model_searchEb: 163| 21.0k| { 164| 21.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.0k] | | ------------------ ------------------ 165| 21.0k| return static_cast(::FLAC__stream_encoder_set_do_exhaustive_model_search(encoder_, value)); 166| 21.0k| } _ZN4FLAC7Encoder6Stream32set_min_residual_partition_orderEj: 169| 19.1k| { 170| 19.1k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 171| 19.1k| return static_cast(::FLAC__stream_encoder_set_min_residual_partition_order(encoder_, value)); 172| 19.1k| } _ZN4FLAC7Encoder6Stream32set_max_residual_partition_orderEj: 175| 19.1k| { 176| 19.1k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 177| 19.1k| return static_cast(::FLAC__stream_encoder_set_max_residual_partition_order(encoder_, value)); 178| 19.1k| } _ZN4FLAC7Encoder6Stream30set_rice_parameter_search_distEj: 181| 19.1k| { 182| 19.1k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 183| 19.1k| return static_cast(::FLAC__stream_encoder_set_rice_parameter_search_dist(encoder_, value)); 184| 19.1k| } _ZN4FLAC7Encoder6Stream26set_total_samples_estimateEm: 187| 19.1k| { 188| 19.1k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 189| 19.1k| return static_cast(::FLAC__stream_encoder_set_total_samples_estimate(encoder_, value)); 190| 19.1k| } _ZN4FLAC7Encoder6Stream21set_limit_min_bitrateEb: 215| 19.0k| { 216| 19.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 217| 19.0k| return static_cast(::FLAC__stream_encoder_set_limit_min_bitrate(encoder_, value)); 218| 19.0k| } _ZN4FLAC7Encoder6Stream15set_num_threadsEj: 221| 19.0k| { 222| 19.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 223| 19.0k| return ::FLAC__stream_encoder_set_num_threads(encoder_, value); 224| 19.0k| } _ZNK4FLAC7Encoder6Stream10get_verifyEv: 245| 9.37k| { 246| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 247| 9.37k| return static_cast(::FLAC__stream_encoder_get_verify(encoder_)); 248| 9.37k| } _ZNK4FLAC7Encoder6Stream21get_streamable_subsetEv: 251| 9.37k| { 252| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 253| 9.37k| return static_cast(::FLAC__stream_encoder_get_streamable_subset(encoder_)); 254| 9.37k| } _ZNK4FLAC7Encoder6Stream22get_do_mid_side_stereoEv: 257| 9.37k| { 258| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 259| 9.37k| return static_cast(::FLAC__stream_encoder_get_do_mid_side_stereo(encoder_)); 260| 9.37k| } _ZNK4FLAC7Encoder6Stream25get_loose_mid_side_stereoEv: 263| 9.37k| { 264| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 265| 9.37k| return static_cast(::FLAC__stream_encoder_get_loose_mid_side_stereo(encoder_)); 266| 9.37k| } _ZNK4FLAC7Encoder6Stream12get_channelsEv: 269| 9.37k| { 270| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 271| 9.37k| return ::FLAC__stream_encoder_get_channels(encoder_); 272| 9.37k| } _ZNK4FLAC7Encoder6Stream19get_bits_per_sampleEv: 275| 9.37k| { 276| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 277| 9.37k| return ::FLAC__stream_encoder_get_bits_per_sample(encoder_); 278| 9.37k| } _ZNK4FLAC7Encoder6Stream15get_sample_rateEv: 281| 9.37k| { 282| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 283| 9.37k| return ::FLAC__stream_encoder_get_sample_rate(encoder_); 284| 9.37k| } _ZNK4FLAC7Encoder6Stream13get_blocksizeEv: 287| 9.37k| { 288| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 289| 9.37k| return ::FLAC__stream_encoder_get_blocksize(encoder_); 290| 9.37k| } _ZNK4FLAC7Encoder6Stream17get_max_lpc_orderEv: 293| 9.37k| { 294| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 295| 9.37k| return ::FLAC__stream_encoder_get_max_lpc_order(encoder_); 296| 9.37k| } _ZNK4FLAC7Encoder6Stream23get_qlp_coeff_precisionEv: 299| 9.37k| { 300| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 301| 9.37k| return ::FLAC__stream_encoder_get_qlp_coeff_precision(encoder_); 302| 9.37k| } _ZNK4FLAC7Encoder6Stream28get_do_qlp_coeff_prec_searchEv: 305| 9.37k| { 306| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 307| 9.37k| return static_cast(::FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder_)); 308| 9.37k| } _ZNK4FLAC7Encoder6Stream20get_do_escape_codingEv: 311| 9.37k| { 312| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 313| 9.37k| return static_cast(::FLAC__stream_encoder_get_do_escape_coding(encoder_)); 314| 9.37k| } _ZNK4FLAC7Encoder6Stream30get_do_exhaustive_model_searchEv: 317| 9.37k| { 318| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 319| 9.37k| return static_cast(::FLAC__stream_encoder_get_do_exhaustive_model_search(encoder_)); 320| 9.37k| } _ZNK4FLAC7Encoder6Stream32get_min_residual_partition_orderEv: 323| 9.37k| { 324| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 325| 9.37k| return ::FLAC__stream_encoder_get_min_residual_partition_order(encoder_); 326| 9.37k| } _ZNK4FLAC7Encoder6Stream32get_max_residual_partition_orderEv: 329| 9.37k| { 330| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 331| 9.37k| return ::FLAC__stream_encoder_get_max_residual_partition_order(encoder_); 332| 9.37k| } _ZNK4FLAC7Encoder6Stream30get_rice_parameter_search_distEv: 335| 9.37k| { 336| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 337| 9.37k| return ::FLAC__stream_encoder_get_rice_parameter_search_dist(encoder_); 338| 9.37k| } _ZNK4FLAC7Encoder6Stream26get_total_samples_estimateEv: 341| 9.37k| { 342| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 343| 9.37k| return ::FLAC__stream_encoder_get_total_samples_estimate(encoder_); 344| 9.37k| } _ZNK4FLAC7Encoder6Stream21get_limit_min_bitrateEv: 347| 9.37k| { 348| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 349| 9.37k| return static_cast(::FLAC__stream_encoder_get_limit_min_bitrate(encoder_)); 350| 9.37k| } _ZNK4FLAC7Encoder6Stream15get_num_threadsEv: 353| 9.37k| { 354| 9.37k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 355| 9.37k| return ::FLAC__stream_encoder_get_num_threads(encoder_); 356| 9.37k| } _ZN4FLAC7Encoder6Stream4initEv: 359| 6.64k| { 360| 6.64k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 6.64k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.64k] | | ------------------ ------------------ 361| 6.64k| return ::FLAC__stream_encoder_init_stream(encoder_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /*client_data=*/(void*)this); 362| 6.64k| } _ZN4FLAC7Encoder6Stream8init_oggEv: 365| 3.00k| { 366| 3.00k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 3.00k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.00k] | | ------------------ ------------------ 367| 3.00k| return ::FLAC__stream_encoder_init_ogg_stream(encoder_, read_callback_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /*client_data=*/(void*)this); 368| 3.00k| } _ZN4FLAC7Encoder6Stream6finishEv: 371| 11.5k| { 372| 11.5k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 11.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5k] | | ------------------ ------------------ 373| 11.5k| return static_cast(::FLAC__stream_encoder_finish(encoder_)); 374| 11.5k| } _ZN4FLAC7Encoder6Stream19process_interleavedEPKij: 383| 178k| { 384| 178k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 178k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 178k] | | ------------------ ------------------ 385| 178k| return static_cast(::FLAC__stream_encoder_process_interleaved(encoder_, buffer, samples)); 386| 178k| } _ZN4FLAC7Encoder6Stream13seek_callbackEm: 395| 9.30k| { 396| 9.30k| (void)absolute_byte_offset; 397| 9.30k| return ::FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED; 398| 9.30k| } _ZN4FLAC7Encoder6Stream13tell_callbackEPm: 401| 37.5k| { 402| 37.5k| (void)absolute_byte_offset; 403| 37.5k| return ::FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED; 404| 37.5k| } _ZN4FLAC7Encoder6Stream17metadata_callbackEPK20FLAC__StreamMetadata: 407| 9.30k| { 408| 9.30k| (void)metadata; 409| 9.30k| } _ZN4FLAC7Encoder6Stream15write_callback_EPK19FLAC__StreamEncoderPKhmjjPv: 421| 147k| { 422| 147k| (void)encoder; 423| 147k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 147k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 147k] | | ------------------ ------------------ 424| 147k| Stream *instance = reinterpret_cast(client_data); 425| 147k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 147k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 147k] | | ------------------ ------------------ 426| 147k| return instance->write_callback(buffer, bytes, samples, current_frame); 427| 147k| } _ZN4FLAC7Encoder6Stream14seek_callback_EPK19FLAC__StreamEncodermPv: 430| 9.30k| { 431| 9.30k| (void)encoder; 432| 9.30k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 9.30k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.30k] | | ------------------ ------------------ 433| 9.30k| Stream *instance = reinterpret_cast(client_data); 434| 9.30k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 9.30k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.30k] | | ------------------ ------------------ 435| 9.30k| return instance->seek_callback(absolute_byte_offset); 436| 9.30k| } _ZN4FLAC7Encoder6Stream14tell_callback_EPK19FLAC__StreamEncoderPmPv: 439| 37.5k| { 440| 37.5k| (void)encoder; 441| 37.5k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 37.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 37.5k] | | ------------------ ------------------ 442| 37.5k| Stream *instance = reinterpret_cast(client_data); 443| 37.5k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 37.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 37.5k] | | ------------------ ------------------ 444| 37.5k| return instance->tell_callback(absolute_byte_offset); 445| 37.5k| } _ZN4FLAC7Encoder6Stream18metadata_callback_EPK19FLAC__StreamEncoderPK20FLAC__StreamMetadataPv: 448| 9.30k| { 449| 9.30k| (void)encoder; 450| 9.30k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 9.30k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.30k] | | ------------------ ------------------ 451| 9.30k| Stream *instance = reinterpret_cast(client_data); 452| 9.30k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 9.30k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.30k] | | ------------------ ------------------ 453| 9.30k| instance->metadata_callback(metadata); 454| 9.30k| } FLAC__bitmath_silog2: 64| 26.3M|{ 65| 26.3M| if(v == 0) ------------------ | Branch (65:5): [True: 152k, False: 26.2M] ------------------ 66| 152k| return 0; 67| | 68| 26.2M| if(v == -1) ------------------ | Branch (68:5): [True: 0, False: 26.2M] ------------------ 69| 0| return 2; 70| | 71| 26.2M| v = (v < 0) ? (-(v+1)) : v; ------------------ | Branch (71:6): [True: 0, False: 26.2M] ------------------ 72| 26.2M| return FLAC__bitmath_ilog2_wide(v)+2; 73| 26.2M|} FLAC__bitreader_new: 257| 8.16k|{ 258| 8.16k| FLAC__BitReader *br = calloc(1, sizeof(FLAC__BitReader)); 259| | 260| | /* calloc() implies: 261| | memset(br, 0, sizeof(FLAC__BitReader)); 262| | br->buffer = 0; 263| | br->capacity = 0; 264| | br->words = br->bytes = 0; 265| | br->consumed_words = br->consumed_bits = 0; 266| | br->read_callback = 0; 267| | br->client_data = 0; 268| | */ 269| 8.16k| return br; 270| 8.16k|} FLAC__bitreader_delete: 273| 8.16k|{ 274| 8.16k| FLAC__ASSERT(0 != br); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 275| | 276| 8.16k| FLAC__bitreader_free(br); 277| 8.16k| free(br); 278| 8.16k|} FLAC__bitreader_init: 287| 8.16k|{ 288| 8.16k| FLAC__ASSERT(0 != br); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 289| | 290| 8.16k| br->words = br->bytes = 0; 291| 8.16k| br->consumed_words = br->consumed_bits = 0; 292| 8.16k| br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY; 293| 8.16k| br->buffer = malloc(sizeof(brword) * br->capacity); 294| 8.16k| if(br->buffer == 0) ------------------ | Branch (294:5): [True: 0, False: 8.16k] ------------------ 295| 0| return false; 296| 8.16k| br->read_callback = rcb; 297| 8.16k| br->client_data = cd; 298| 8.16k| br->read_limit_set = false; 299| 8.16k| br->read_limit = -1; 300| 8.16k| br->last_seen_framesync = -1; 301| | 302| | return true; 303| 8.16k|} FLAC__bitreader_free: 306| 16.3k|{ 307| 16.3k| FLAC__ASSERT(0 != br); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 308| | 309| 16.3k| if(0 != br->buffer) ------------------ | Branch (309:5): [True: 8.16k, False: 8.16k] ------------------ 310| 8.16k| free(br->buffer); 311| 16.3k| br->buffer = 0; 312| 16.3k| br->capacity = 0; 313| 16.3k| br->words = br->bytes = 0; 314| 16.3k| br->consumed_words = br->consumed_bits = 0; 315| 16.3k| br->read_callback = 0; 316| 16.3k| br->client_data = 0; 317| | br->read_limit_set = false; 318| 16.3k| br->read_limit = -1; 319| 16.3k| br->last_seen_framesync = -1; 320| 16.3k|} FLAC__bitreader_clear: 323| 8.16k|{ 324| 8.16k| br->words = br->bytes = 0; 325| 8.16k| br->consumed_words = br->consumed_bits = 0; 326| 8.16k| br->read_limit_set = false; 327| 8.16k| br->read_limit = -1; 328| 8.16k| br->last_seen_framesync = -1; 329| | return true; 330| 8.16k|} FLAC__bitreader_set_framesync_location: 333| 203k|{ 334| 203k| br->last_seen_framesync = br->consumed_words * FLAC__BYTES_PER_WORD + br->consumed_bits / 8; ------------------ | | 72| 203k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 335| 203k|} FLAC__bitreader_reset_read_crc16: 351| 203k|{ 352| 203k| FLAC__ASSERT(0 != br); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 353| 203k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 354| 203k| FLAC__ASSERT((br->consumed_bits & 7) == 0); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 355| | 356| 203k| br->read_crc16 = (uint32_t)seed; 357| 203k| br->crc16_offset = br->consumed_words; 358| 203k| br->crc16_align = br->consumed_bits; 359| 203k|} FLAC__bitreader_get_read_crc16: 362| 203k|{ 363| 203k| FLAC__ASSERT(0 != br); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 364| 203k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 365| | 366| | /* CRC consumed words up to here */ 367| 203k| crc16_update_block_(br); 368| | 369| 203k| FLAC__ASSERT((br->consumed_bits & 7) == 0); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 370| 203k| FLAC__ASSERT(br->crc16_align <= br->consumed_bits); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 371| | 372| | /* CRC any tail bytes in a partially-consumed word */ 373| 203k| if(br->consumed_bits) { ------------------ | Branch (373:5): [True: 178k, False: 25.3k] ------------------ 374| 178k| const brword tail = br->buffer[br->consumed_words]; 375| 885k| for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8) ------------------ | Branch (375:10): [True: 707k, False: 178k] ------------------ 376| 707k| br->read_crc16 = FLAC__CRC16_UPDATE((uint32_t)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16); ------------------ | | 50| 707k|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) ------------------ 377| 178k| } 378| 203k| return br->read_crc16; 379| 203k|} FLAC__bitreader_is_consumed_byte_aligned: 382| 667k|{ 383| 667k| return ((br->consumed_bits & 7) == 0); 384| 667k|} FLAC__bitreader_bits_left_for_byte_alignment: 387| 99.0k|{ 388| 99.0k| return 8 - (br->consumed_bits & 7); 389| 99.0k|} FLAC__bitreader_read_raw_uint32: 419| 11.5M|{ 420| 11.5M| FLAC__ASSERT(0 != br); ------------------ | | 38| 11.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5M] | | ------------------ ------------------ 421| 11.5M| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 11.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5M] | | ------------------ ------------------ 422| | 423| 11.5M| FLAC__ASSERT(bits <= 32); ------------------ | | 38| 11.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5M] | | ------------------ ------------------ 424| 11.5M| FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits); ------------------ | | 38| 11.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5M] | | ------------------ ------------------ 425| 11.5M| FLAC__ASSERT(br->consumed_words <= br->words); ------------------ | | 38| 11.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5M] | | ------------------ ------------------ 426| | 427| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 428| 11.5M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 11.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 11.5M] | | ------------------ ------------------ 429| | 430| 11.5M| if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */ ------------------ | Branch (430:5): [True: 0, False: 11.5M] ------------------ 431| 0| *val = 0; 432| 0| return true; 433| 0| } 434| | 435| 11.5M| if(br->read_limit_set && br->read_limit < (uint32_t)-1){ ------------------ | Branch (435:5): [True: 0, False: 11.5M] | Branch (435:27): [True: 0, False: 0] ------------------ 436| 0| if(br->read_limit < bits) { ------------------ | Branch (436:6): [True: 0, False: 0] ------------------ 437| 0| br->read_limit = -1; 438| 0| return false; 439| 0| } 440| 0| else 441| 0| br->read_limit -= bits; 442| 0| } 443| | 444| 11.7M| while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) { ------------------ | | 73| 11.7M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (444:8): [True: 235k, False: 11.5M] ------------------ 445| 235k| if(!bitreader_read_from_client_(br)) ------------------ | Branch (445:6): [True: 0, False: 235k] ------------------ 446| 0| return false; 447| 235k| } 448| 11.5M| if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */ ------------------ | Branch (448:5): [True: 11.0M, False: 486k] ------------------ 449| | /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */ 450| 11.0M| if(br->consumed_bits) { ------------------ | Branch (450:6): [True: 10.2M, False: 810k] ------------------ 451| | /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */ 452| 10.2M| const uint32_t n = FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 10.2M|#define FLAC__BITS_PER_WORD 64 ------------------ 453| 10.2M| const brword word = br->buffer[br->consumed_words]; 454| 10.2M| const brword mask = br->consumed_bits < FLAC__BITS_PER_WORD ? FLAC__WORD_ALL_ONES >> br->consumed_bits : 0; ------------------ | | 73| 10.2M|#define FLAC__BITS_PER_WORD 64 ------------------ const brword mask = br->consumed_bits < FLAC__BITS_PER_WORD ? FLAC__WORD_ALL_ONES >> br->consumed_bits : 0; ------------------ | | 74| 10.2M|#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff)) | | ------------------ | | | | 102| 10.2M|#define FLAC__U64L(x) x##ULL | | ------------------ ------------------ | Branch (454:24): [True: 10.2M, False: 0] ------------------ 455| 10.2M| if(bits < n) { ------------------ | Branch (455:7): [True: 7.25M, False: 2.97M] ------------------ 456| 7.25M| uint32_t shift = n - bits; 457| 7.25M| *val = shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)((word & mask) >> shift) : 0; /* The result has <= 32 non-zero bits */ ------------------ | | 73| 7.25M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (457:12): [True: 7.25M, False: 0] ------------------ 458| 7.25M| br->consumed_bits += bits; 459| 7.25M| return true; 460| 7.25M| } 461| | /* (FLAC__BITS_PER_WORD - br->consumed_bits <= bits) ==> (FLAC__WORD_ALL_ONES >> br->consumed_bits) has no more than 'bits' non-zero bits */ 462| 2.97M| *val = (FLAC__uint32)(word & mask); 463| 2.97M| bits -= n; 464| 2.97M| br->consumed_words++; 465| 2.97M| br->consumed_bits = 0; 466| 2.97M| if(bits) { /* if there are still bits left to read, there have to be less than 32 so they will all be in the next word */ ------------------ | Branch (466:7): [True: 2.10M, False: 872k] ------------------ 467| 2.10M| uint32_t shift = FLAC__BITS_PER_WORD - bits; ------------------ | | 73| 2.10M|#define FLAC__BITS_PER_WORD 64 ------------------ 468| 2.10M| *val = bits < 32 ? *val << bits : 0; ------------------ | Branch (468:12): [True: 2.10M, False: 0] ------------------ 469| 2.10M| *val |= shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)(br->buffer[br->consumed_words] >> shift) : 0; ------------------ | | 73| 2.10M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (469:13): [True: 2.10M, False: 0] ------------------ 470| 2.10M| br->consumed_bits = bits; 471| 2.10M| } 472| 2.97M| return true; 473| 10.2M| } 474| 810k| else { /* br->consumed_bits == 0 */ 475| 810k| const brword word = br->buffer[br->consumed_words]; 476| 810k| if(bits < FLAC__BITS_PER_WORD) { ------------------ | | 73| 810k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (476:7): [True: 810k, False: 0] ------------------ 477| 810k| *val = (FLAC__uint32)(word >> (FLAC__BITS_PER_WORD-bits)); ------------------ | | 73| 810k|#define FLAC__BITS_PER_WORD 64 ------------------ 478| 810k| br->consumed_bits = bits; 479| 810k| return true; 480| 810k| } 481| | /* at this point bits == FLAC__BITS_PER_WORD == 32; because of previous assertions, it can't be larger */ 482| 0| *val = (FLAC__uint32)word; 483| 0| br->consumed_words++; 484| 0| return true; 485| 810k| } 486| 11.0M| } 487| 486k| else { 488| | /* in this case we're starting our read at a partial tail word; 489| | * the reader has guaranteed that we have at least 'bits' bits 490| | * available to read, which makes this case simpler. 491| | */ 492| | /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */ 493| 486k| if(br->consumed_bits) { ------------------ | Branch (493:6): [True: 380k, False: 105k] ------------------ 494| | /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */ 495| 380k| FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8); ------------------ | | 38| 380k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 380k] | | ------------------ ------------------ 496| 380k| *val = (FLAC__uint32)((br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits)); ------------------ | | 74| 380k|#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff)) | | ------------------ | | | | 102| 380k|#define FLAC__U64L(x) x##ULL | | ------------------ ------------------ *val = (FLAC__uint32)((br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits)); ------------------ | | 73| 380k|#define FLAC__BITS_PER_WORD 64 ------------------ 497| 380k| br->consumed_bits += bits; 498| 380k| return true; 499| 380k| } 500| 105k| else { 501| 105k| *val = (FLAC__uint32)(br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits)); ------------------ | | 73| 105k|#define FLAC__BITS_PER_WORD 64 ------------------ 502| 105k| br->consumed_bits += bits; 503| | return true; 504| 105k| } 505| 486k| } 506| 11.5M|} FLAC__bitreader_read_raw_int32: 509| 3.46M|{ 510| 3.46M| FLAC__uint32 uval, mask; 511| | /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */ 512| 3.46M| if (bits < 1 || ! FLAC__bitreader_read_raw_uint32(br, &uval, bits)) ------------------ | Branch (512:6): [True: 0, False: 3.46M] | Branch (512:18): [True: 0, False: 3.46M] ------------------ 513| 0| return false; 514| | /* sign-extend *val assuming it is currently bits wide. */ 515| | /* From: https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend */ 516| 3.46M| mask = bits >= 33 ? 0 : 1lu << (bits - 1); ------------------ | Branch (516:9): [True: 0, False: 3.46M] ------------------ 517| 3.46M| *val = (uval ^ mask) - mask; 518| | return true; 519| 3.46M|} FLAC__bitreader_read_raw_uint64: 522| 1.91M|{ 523| 1.91M| FLAC__uint32 hi, lo; 524| | 525| 1.91M| if(bits > 32) { ------------------ | Branch (525:5): [True: 1.64M, False: 267k] ------------------ 526| 1.64M| if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32)) ------------------ | Branch (526:6): [True: 0, False: 1.64M] ------------------ 527| 0| return false; 528| 1.64M| if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32)) ------------------ | Branch (528:6): [True: 0, False: 1.64M] ------------------ 529| 0| return false; 530| 1.64M| *val = hi; 531| 1.64M| *val <<= 32; 532| 1.64M| *val |= lo; 533| 1.64M| } 534| 267k| else { 535| 267k| if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits)) ------------------ | Branch (535:6): [True: 0, False: 267k] ------------------ 536| 0| return false; 537| 267k| *val = lo; 538| 267k| } 539| 1.91M| return true; 540| 1.91M|} FLAC__bitreader_read_raw_int64: 543| 1.90M|{ 544| 1.90M| FLAC__uint64 uval, mask; 545| | /* OPT: inline raw uint64 code here, or make into a macro if possible in the .h file */ 546| 1.90M| if (bits < 1 || ! FLAC__bitreader_read_raw_uint64(br, &uval, bits)) ------------------ | Branch (546:6): [True: 0, False: 1.90M] | Branch (546:18): [True: 0, False: 1.90M] ------------------ 547| 0| return false; 548| | /* sign-extend *val assuming it is currently bits wide. */ 549| | /* From: https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend */ 550| 1.90M| mask = bits >= 65 ? 0 : 1llu << (bits - 1); ------------------ | Branch (550:9): [True: 0, False: 1.90M] ------------------ 551| 1.90M| *val = (uval ^ mask) - mask; 552| | return true; 553| 1.90M|} FLAC__bitreader_skip_byte_block_aligned_no_crc: 616| 16.3k|{ 617| 16.3k| FLAC__uint32 x; 618| | 619| 16.3k| FLAC__ASSERT(0 != br); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 620| 16.3k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 621| 16.3k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br)); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 622| | 623| 16.3k| if(br->read_limit_set && br->read_limit < (uint32_t)-1){ ------------------ | Branch (623:5): [True: 0, False: 16.3k] | Branch (623:27): [True: 0, False: 0] ------------------ 624| 0| if(br->read_limit < nvals*8){ ------------------ | Branch (624:6): [True: 0, False: 0] ------------------ 625| 0| br->read_limit = -1; 626| 0| return false; 627| 0| } 628| 0| } 629| | 630| | /* step 1: skip over partial head word to get word aligned */ 631| 32.6k| while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */ ------------------ | Branch (631:8): [True: 24.4k, False: 8.16k] | Branch (631:17): [True: 16.3k, False: 8.16k] ------------------ 632| 16.3k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (632:6): [True: 0, False: 16.3k] ------------------ 633| 0| return false; 634| 16.3k| nvals--; 635| 16.3k| } 636| 16.3k| if(0 == nvals) ------------------ | Branch (636:5): [True: 8.16k, False: 8.16k] ------------------ 637| 8.16k| return true; 638| | 639| | /* step 2: skip whole words in chunks */ 640| 48.9k| while(nvals >= FLAC__BYTES_PER_WORD) { ------------------ | | 72| 48.9k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ | Branch (640:8): [True: 40.8k, False: 8.16k] ------------------ 641| 40.8k| if(br->consumed_words < br->words) { ------------------ | Branch (641:6): [True: 40.8k, False: 0] ------------------ 642| 40.8k| br->consumed_words++; 643| 40.8k| nvals -= FLAC__BYTES_PER_WORD; ------------------ | | 72| 40.8k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 644| 40.8k| if(br->read_limit_set) ------------------ | Branch (644:7): [True: 0, False: 40.8k] ------------------ 645| 0| br->read_limit -= FLAC__BITS_PER_WORD; ------------------ | | 73| 0|#define FLAC__BITS_PER_WORD 64 ------------------ 646| 40.8k| } 647| 0| else if(!bitreader_read_from_client_(br)) ------------------ | Branch (647:11): [True: 0, False: 0] ------------------ 648| 0| return false; 649| 40.8k| } 650| | /* step 3: skip any remainder from partial tail bytes */ 651| 48.9k| while(nvals) { ------------------ | Branch (651:8): [True: 40.8k, False: 8.16k] ------------------ 652| 40.8k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (652:6): [True: 0, False: 40.8k] ------------------ 653| 0| return false; 654| 40.8k| nvals--; 655| 40.8k| } 656| | 657| 8.16k| return true; 658| 8.16k|} FLAC__bitreader_read_byte_block_aligned_no_crc: 661| 8.16k|{ 662| 8.16k| FLAC__uint32 x; 663| | 664| 8.16k| FLAC__ASSERT(0 != br); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 665| 8.16k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 666| 8.16k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br)); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 667| | 668| 8.16k| if(br->read_limit_set && br->read_limit < (uint32_t)-1){ ------------------ | Branch (668:5): [True: 0, False: 8.16k] | Branch (668:27): [True: 0, False: 0] ------------------ 669| 0| if(br->read_limit < nvals*8){ ------------------ | Branch (669:6): [True: 0, False: 0] ------------------ 670| 0| br->read_limit = -1; 671| 0| return false; 672| 0| } 673| 0| } 674| | 675| | /* step 1: read from partial head word to get word aligned */ 676| 57.1k| while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */ ------------------ | Branch (676:8): [True: 57.1k, False: 0] | Branch (676:17): [True: 48.9k, False: 8.16k] ------------------ 677| 48.9k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (677:6): [True: 0, False: 48.9k] ------------------ 678| 0| return false; 679| 48.9k| *val++ = (FLAC__byte)x; 680| 48.9k| nvals--; 681| 48.9k| } 682| 8.16k| if(0 == nvals) ------------------ | Branch (682:5): [True: 0, False: 8.16k] ------------------ 683| 0| return true; 684| | /* step 2: read whole words in chunks */ 685| 16.3k| while(nvals >= FLAC__BYTES_PER_WORD) { ------------------ | | 72| 16.3k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ | Branch (685:8): [True: 8.16k, False: 8.16k] ------------------ 686| 8.16k| if(br->consumed_words < br->words) { ------------------ | Branch (686:6): [True: 8.16k, False: 0] ------------------ 687| 8.16k| const brword word = br->buffer[br->consumed_words++]; 688| |#if FLAC__BYTES_PER_WORD == 4 689| | val[0] = (FLAC__byte)(word >> 24); 690| | val[1] = (FLAC__byte)(word >> 16); 691| | val[2] = (FLAC__byte)(word >> 8); 692| | val[3] = (FLAC__byte)word; 693| |#elif FLAC__BYTES_PER_WORD == 8 694| | val[0] = (FLAC__byte)(word >> 56); 695| 8.16k| val[1] = (FLAC__byte)(word >> 48); 696| 8.16k| val[2] = (FLAC__byte)(word >> 40); 697| 8.16k| val[3] = (FLAC__byte)(word >> 32); 698| 8.16k| val[4] = (FLAC__byte)(word >> 24); 699| 8.16k| val[5] = (FLAC__byte)(word >> 16); 700| 8.16k| val[6] = (FLAC__byte)(word >> 8); 701| 8.16k| val[7] = (FLAC__byte)word; 702| |#else 703| | for(x = 0; x < FLAC__BYTES_PER_WORD; x++) 704| | val[x] = (FLAC__byte)(word >> (8*(FLAC__BYTES_PER_WORD-x-1))); 705| |#endif 706| 8.16k| val += FLAC__BYTES_PER_WORD; ------------------ | | 72| 8.16k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 707| 8.16k| nvals -= FLAC__BYTES_PER_WORD; ------------------ | | 72| 8.16k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 708| 8.16k| if(br->read_limit_set) ------------------ | Branch (708:7): [True: 0, False: 8.16k] ------------------ 709| 0| br->read_limit -= FLAC__BITS_PER_WORD; ------------------ | | 73| 0|#define FLAC__BITS_PER_WORD 64 ------------------ 710| 8.16k| } 711| 0| else if(!bitreader_read_from_client_(br)) ------------------ | Branch (711:11): [True: 0, False: 0] ------------------ 712| 0| return false; 713| 8.16k| } 714| | /* step 3: read any remainder from partial tail bytes */ 715| 24.4k| while(nvals) { ------------------ | Branch (715:8): [True: 16.3k, False: 8.16k] ------------------ 716| 16.3k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (716:6): [True: 0, False: 16.3k] ------------------ 717| 0| return false; 718| 16.3k| *val++ = (FLAC__byte)x; 719| 16.3k| nvals--; 720| 16.3k| } 721| | 722| 8.16k| return true; 723| 8.16k|} FLAC__bitreader_read_unary_unsigned: 745| 3.43M|{ 746| 3.43M| uint32_t i; 747| | 748| 3.43M| FLAC__ASSERT(0 != br); ------------------ | | 38| 3.43M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.43M] | | ------------------ ------------------ 749| 3.43M| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 3.43M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.43M] | | ------------------ ------------------ 750| | 751| 3.43M| *val = 0; 752| 3.43M| while(1) { ------------------ | Branch (752:8): [True: 3.43M, Folded] ------------------ 753| 3.44M| while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */ ------------------ | Branch (753:9): [True: 3.23M, False: 208k] ------------------ 754| 3.23M| brword b = br->consumed_bits < FLAC__BITS_PER_WORD ? br->buffer[br->consumed_words] << br->consumed_bits : 0; ------------------ | | 73| 3.23M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (754:15): [True: 3.23M, False: 0] ------------------ 755| 3.23M| if(b) { ------------------ | Branch (755:7): [True: 3.22M, False: 13.6k] ------------------ 756| 3.22M| i = COUNT_ZERO_MSBS(b); ------------------ | | 82| 3.22M|#define COUNT_ZERO_MSBS(word) FLAC__clz_uint64(word) ------------------ 757| 3.22M| *val += i; 758| 3.22M| i++; 759| 3.22M| br->consumed_bits += i; 760| 3.22M| if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */ ------------------ | | 73| 3.22M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (760:8): [True: 53.7k, False: 3.16M] ------------------ 761| 53.7k| br->consumed_words++; 762| 53.7k| br->consumed_bits = 0; 763| 53.7k| } 764| 3.22M| return true; 765| 3.22M| } 766| 13.6k| else { 767| 13.6k| *val += FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 13.6k|#define FLAC__BITS_PER_WORD 64 ------------------ 768| 13.6k| br->consumed_words++; 769| 13.6k| br->consumed_bits = 0; 770| | /* didn't find stop bit yet, have to keep going... */ 771| 13.6k| } 772| 3.23M| } 773| | /* at this point we've eaten up all the whole words; have to try 774| | * reading through any tail bytes before calling the read callback. 775| | * this is a repeat of the above logic adjusted for the fact we 776| | * don't have a whole word. note though if the client is feeding 777| | * us data a byte at a time (unlikely), br->consumed_bits may not 778| | * be zero. 779| | */ 780| 208k| if(br->bytes*8 > br->consumed_bits) { ------------------ | Branch (780:6): [True: 207k, False: 533] ------------------ 781| 207k| const uint32_t end = br->bytes * 8; 782| 207k| brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits; ------------------ | | 74| 207k|#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff)) | | ------------------ | | | | 102| 207k|#define FLAC__U64L(x) x##ULL | | ------------------ ------------------ brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits; ------------------ | | 73| 207k|#define FLAC__BITS_PER_WORD 64 ------------------ 783| 207k| if(b) { ------------------ | Branch (783:7): [True: 207k, False: 0] ------------------ 784| 207k| i = COUNT_ZERO_MSBS(b); ------------------ | | 82| 207k|#define COUNT_ZERO_MSBS(word) FLAC__clz_uint64(word) ------------------ 785| 207k| *val += i; 786| 207k| i++; 787| 207k| br->consumed_bits += i; 788| 207k| FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD); ------------------ | | 38| 207k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 207k] | | ------------------ ------------------ 789| 207k| return true; 790| 207k| } 791| 0| else { 792| 0| *val += end - br->consumed_bits; 793| 0| br->consumed_bits = end; 794| 0| FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 795| | /* didn't find stop bit yet, have to keep going... */ 796| 0| } 797| 207k| } 798| 533| if(!bitreader_read_from_client_(br)) ------------------ | Branch (798:6): [True: 0, False: 533] ------------------ 799| 0| return false; 800| 533| } 801| 3.43M|} FLAC__bitreader_read_utf8_uint32: 929| 203k|{ 930| 203k| FLAC__uint32 v = 0; 931| 203k| FLAC__uint32 x; 932| 203k| uint32_t i; 933| | 934| 203k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (934:5): [True: 0, False: 203k] ------------------ 935| 0| return false; 936| 203k| if(raw) ------------------ | Branch (936:5): [True: 203k, False: 0] ------------------ 937| 203k| raw[(*rawlen)++] = (FLAC__byte)x; 938| 203k| if(!(x & 0x80)) { /* 0xxxxxxx */ ------------------ | Branch (938:5): [True: 73.5k, False: 129k] ------------------ 939| 73.5k| v = x; 940| 73.5k| i = 0; 941| 73.5k| } 942| 129k| else if((x & 0xE0) == 0xC0) { /* 110xxxxx */ ------------------ | Branch (942:10): [True: 108k, False: 21.1k] ------------------ 943| 108k| v = x & 0x1F; 944| 108k| i = 1; 945| 108k| } 946| 21.1k| else if((x & 0xF0) == 0xE0) { /* 1110xxxx */ ------------------ | Branch (946:10): [True: 21.1k, False: 0] ------------------ 947| 21.1k| v = x & 0x0F; 948| 21.1k| i = 2; 949| 21.1k| } 950| 0| else if((x & 0xF8) == 0xF0) { /* 11110xxx */ ------------------ | Branch (950:10): [True: 0, False: 0] ------------------ 951| 0| v = x & 0x07; 952| 0| i = 3; 953| 0| } 954| 0| else if((x & 0xFC) == 0xF8) { /* 111110xx */ ------------------ | Branch (954:10): [True: 0, False: 0] ------------------ 955| 0| v = x & 0x03; 956| 0| i = 4; 957| 0| } 958| 0| else if((x & 0xFE) == 0xFC) { /* 1111110x */ ------------------ | Branch (958:10): [True: 0, False: 0] ------------------ 959| 0| v = x & 0x01; 960| 0| i = 5; 961| 0| } 962| 0| else { 963| 0| *val = 0xffffffff; 964| 0| return true; 965| 0| } 966| 354k| for( ; i; i--) { ------------------ | Branch (966:9): [True: 151k, False: 203k] ------------------ 967| 151k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (967:6): [True: 0, False: 151k] ------------------ 968| 0| return false; 969| 151k| if(raw) ------------------ | Branch (969:6): [True: 151k, False: 0] ------------------ 970| 151k| raw[(*rawlen)++] = (FLAC__byte)x; 971| 151k| if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */ ------------------ | Branch (971:6): [True: 0, False: 151k] | Branch (971:21): [True: 0, False: 151k] ------------------ 972| 0| *val = 0xffffffff; 973| 0| return true; 974| 0| } 975| 151k| v <<= 6; 976| 151k| v |= (x & 0x3F); 977| 151k| } 978| 203k| *val = v; 979| | return true; 980| 203k|} bitreader.c:crc16_update_block_: 136| 423k|{ 137| 423k| if(br->consumed_words > br->crc16_offset && br->crc16_align) ------------------ | Branch (137:5): [True: 422k, False: 208] | Branch (137:46): [True: 352k, False: 70.3k] ------------------ 138| 352k| crc16_update_word_(br, br->buffer[br->crc16_offset++]); 139| | 140| | /* Prevent OOB read due to wrap-around. */ 141| 423k| if (br->consumed_words > br->crc16_offset) { ------------------ | Branch (141:6): [True: 387k, False: 35.3k] ------------------ 142| |#if FLAC__BYTES_PER_WORD == 4 143| | br->read_crc16 = FLAC__crc16_update_words32(br->buffer + br->crc16_offset, br->consumed_words - br->crc16_offset, br->read_crc16); 144| |#elif FLAC__BYTES_PER_WORD == 8 145| | br->read_crc16 = FLAC__crc16_update_words64(br->buffer + br->crc16_offset, br->consumed_words - br->crc16_offset, br->read_crc16); 146| |#else 147| | unsigned i; 148| | 149| | for (i = br->crc16_offset; i < br->consumed_words; i++) 150| | crc16_update_word_(br, br->buffer[i]); 151| |#endif 152| 387k| } 153| | 154| 423k| br->crc16_offset = 0; 155| 423k|} bitreader.c:crc16_update_word_: 123| 352k|{ 124| 352k| register uint32_t crc = br->read_crc16; 125| | 126| 1.73M| for ( ; br->crc16_align < FLAC__BITS_PER_WORD ; br->crc16_align += 8) { ------------------ | | 73| 1.73M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (126:10): [True: 1.38M, False: 352k] ------------------ 127| 1.38M| uint32_t shift = FLAC__BITS_PER_WORD - 8 - br->crc16_align ; ------------------ | | 73| 1.38M|#define FLAC__BITS_PER_WORD 64 ------------------ 128| 1.38M| crc = FLAC__CRC16_UPDATE ((uint32_t) (shift < FLAC__BITS_PER_WORD ? (word >> shift) & 0xff : 0), crc); ------------------ | | 50| 2.76M|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) | | ------------------ | | | Branch (50:99): [True: 1.38M, False: 0] | | ------------------ ------------------ 129| 1.38M| } 130| | 131| 352k| br->read_crc16 = crc; 132| 352k| br->crc16_align = 0; 133| 352k|} bitreader.c:bitreader_read_from_client_: 158| 235k|{ 159| 235k| uint32_t start, end; 160| 235k| size_t bytes; 161| 235k| FLAC__byte *target; 162| |#if WORDS_BIGENDIAN 163| |#else 164| 235k| brword preswap_backup; 165| 235k|#endif 166| | 167| | /* first shift the unconsumed buffer data toward the front as much as possible */ 168| 235k| if(br->consumed_words > 0) { ------------------ | Branch (168:5): [True: 219k, False: 16.4k] ------------------ 169| | /* invalidate last seen framesync */ 170| 219k| br->last_seen_framesync = -1; 171| | 172| 219k| crc16_update_block_(br); /* CRC consumed words */ 173| | 174| 219k| start = br->consumed_words; 175| 219k| end = br->words + (br->bytes? 1:0); ------------------ | Branch (175:22): [True: 188k, False: 31.3k] ------------------ 176| 219k| memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start)); ------------------ | | 72| 219k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 177| | 178| 219k| br->words -= start; 179| 219k| br->consumed_words = 0; 180| 219k| } 181| | 182| | /* 183| | * set the target for reading, taking into account word alignment and endianness 184| | */ 185| 235k| bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes; ------------------ | | 72| 235k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 186| 235k| if(bytes == 0) ------------------ | Branch (186:5): [True: 0, False: 235k] ------------------ 187| 0| return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY */ 188| 235k| target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes; 189| | 190| | /* before reading, if the existing reader looks like this (say brword is 32 bits wide) 191| | * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 (partial tail word is left-justified) 192| | * buffer[BE]: 11 22 33 44 55 ?? ?? ?? (shown laid out as bytes sequentially in memory) 193| | * buffer[LE]: 44 33 22 11 ?? ?? ?? 55 (?? being don't-care) 194| | * ^^-------target, bytes=3 195| | * on LE machines, have to byteswap the odd tail word so nothing is 196| | * overwritten: 197| | */ 198| |#if WORDS_BIGENDIAN 199| |#else 200| 235k| preswap_backup = br->buffer[br->words]; 201| 235k| if(br->bytes) ------------------ | Branch (201:5): [True: 196k, False: 39.5k] ------------------ 202| 196k| br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]); ------------------ | | 79| 196k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 196k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 203| 235k|#endif 204| | 205| | /* now it looks like: 206| | * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 207| | * buffer[BE]: 11 22 33 44 55 ?? ?? ?? 208| | * buffer[LE]: 44 33 22 11 55 ?? ?? ?? 209| | * ^^-------target, bytes=3 210| | */ 211| | 212| | /* read in the data; note that the callback may return a smaller number of bytes */ 213| 235k| if(!br->read_callback(target, &bytes, br->client_data)){ ------------------ | Branch (213:5): [True: 0, False: 235k] ------------------ 214| | /* Despite the read callback failing, the data in the target 215| | * might be used later, when the buffer is rewound. Therefore 216| | * we revert the swap that was just done */ 217| |#if WORDS_BIGENDIAN 218| |#else 219| 0| br->buffer[br->words] = preswap_backup; 220| 0|#endif 221| 0| return false; 222| 0| } 223| | 224| | /* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client: 225| | * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF 226| | * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ?? 227| | * buffer[LE]: 44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ?? 228| | * now have to byteswap on LE machines: 229| | */ 230| |#if WORDS_BIGENDIAN 231| |#else 232| 235k| end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD; ------------------ | | 72| 235k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD; ------------------ | | 72| 235k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD; ------------------ | | 72| 235k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 233| 10.8M| for(start = br->words; start < end; start++) ------------------ | Branch (233:25): [True: 10.6M, False: 235k] ------------------ 234| 10.6M| br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]); ------------------ | | 79| 10.6M|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 10.8M|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 235| 235k|#endif 236| | 237| | /* now it looks like: 238| | * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF 239| | * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ?? 240| | * buffer[LE]: 44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD 241| | * finally we'll update the reader values: 242| | */ 243| 235k| end = br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes; ------------------ | | 72| 235k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 244| 235k| br->words = end / FLAC__BYTES_PER_WORD; ------------------ | | 72| 235k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 245| 235k| br->bytes = end % FLAC__BYTES_PER_WORD; ------------------ | | 72| 235k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 246| | 247| | return true; 248| 235k|} FLAC__bitwriter_new: 161| 24.1k|{ 162| 24.1k| FLAC__BitWriter *bw = calloc(1, sizeof(FLAC__BitWriter)); 163| | /* note that calloc() sets all members to 0 for us */ 164| 24.1k| return bw; 165| 24.1k|} FLAC__bitwriter_delete: 168| 24.1k|{ 169| 24.1k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 24.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 24.1k] | | ------------------ ------------------ 170| | 171| 24.1k| FLAC__bitwriter_free(bw); 172| 24.1k| free(bw); 173| 24.1k|} FLAC__bitwriter_init: 182| 21.9k|{ 183| 21.9k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 184| | 185| 21.9k| bw->words = bw->bits = 0; 186| 21.9k| bw->capacity = FLAC__BITWRITER_DEFAULT_CAPACITY; 187| 21.9k| bw->buffer = malloc(sizeof(bwword) * bw->capacity); 188| 21.9k| if(bw->buffer == 0) ------------------ | Branch (188:5): [True: 0, False: 21.9k] ------------------ 189| 0| return false; 190| | 191| 21.9k| return true; 192| 21.9k|} FLAC__bitwriter_free: 195| 24.1k|{ 196| 24.1k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 24.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 24.1k] | | ------------------ ------------------ 197| | 198| 24.1k| if(0 != bw->buffer) ------------------ | Branch (198:5): [True: 21.9k, False: 2.20k] ------------------ 199| 21.9k| free(bw->buffer); 200| 24.1k| bw->buffer = 0; 201| 24.1k| bw->capacity = 0; 202| 24.1k| bw->words = bw->bits = 0; 203| 24.1k|} FLAC__bitwriter_clear: 206| 273k|{ 207| 273k| bw->words = bw->bits = 0; 208| 273k|} FLAC__bitwriter_get_write_crc16: 211| 242k|{ 212| 242k| const FLAC__byte *buffer; 213| 242k| size_t bytes; 214| | 215| 242k| FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */ ------------------ | | 38| 242k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 242k] | | ------------------ ------------------ 216| | 217| 242k| if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes)) ------------------ | Branch (217:5): [True: 0, False: 242k] ------------------ 218| 0| return false; 219| | 220| 242k| *crc = (FLAC__uint16)FLAC__crc16(buffer, bytes); 221| 242k| FLAC__bitwriter_release_buffer(bw); 222| | return true; 223| 242k|} FLAC__bitwriter_get_write_crc8: 226| 242k|{ 227| 242k| const FLAC__byte *buffer; 228| 242k| size_t bytes; 229| | 230| 242k| FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */ ------------------ | | 38| 242k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 242k] | | ------------------ ------------------ 231| | 232| 242k| if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes)) ------------------ | Branch (232:5): [True: 0, False: 242k] ------------------ 233| 0| return false; 234| | 235| 242k| *crc = FLAC__crc8(buffer, bytes); 236| 242k| FLAC__bitwriter_release_buffer(bw); 237| | return true; 238| 242k|} FLAC__bitwriter_is_byte_aligned: 241| 789k|{ 242| 789k| return ((bw->bits & 7) == 0); 243| 789k|} FLAC__bitwriter_get_input_bits_unconsumed: 246| 37.5k|{ 247| 37.5k| return FLAC__TOTAL_BITS(bw); ------------------ | | 96| 37.5k|#define FLAC__TOTAL_BITS(bw) (FLAC__WORDS_TO_BITS((bw)->words) + (bw)->bits) | | ------------------ | | | | 95| 37.5k|#define FLAC__WORDS_TO_BITS(words) ((words) * FLAC__BITS_PER_WORD) | | | | ------------------ | | | | | | 73| 37.5k|#define FLAC__BITS_PER_WORD 64 | | | | ------------------ | | ------------------ ------------------ 248| 37.5k|} FLAC__bitwriter_get_buffer: 251| 749k|{ 252| 749k| FLAC__ASSERT((bw->bits & 7) == 0); ------------------ | | 38| 749k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 749k] | | ------------------ ------------------ 253| | /* double protection */ 254| 749k| if(bw->bits & 7) ------------------ | Branch (254:5): [True: 0, False: 749k] ------------------ 255| 0| return false; 256| | /* if we have bits in the accumulator we have to flush those to the buffer first */ 257| 749k| if(bw->bits) { ------------------ | Branch (257:5): [True: 624k, False: 124k] ------------------ 258| 624k| FLAC__ASSERT(bw->words <= bw->capacity); ------------------ | | 38| 624k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 624k] | | ------------------ ------------------ 259| 624k| if(bw->words == bw->capacity && !bitwriter_grow_(bw, FLAC__BITS_PER_WORD)) ------------------ | | 73| 0|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (259:6): [True: 0, False: 624k] | Branch (259:35): [True: 0, False: 0] ------------------ 260| 0| return false; 261| | /* append bits as complete word to buffer, but don't change bw->accum or bw->bits */ 262| 624k| bw->buffer[bw->words] = SWAP_BE_WORD_TO_HOST(bw->accum << (FLAC__BITS_PER_WORD-bw->bits)); ------------------ | | 80| 624k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 624k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 263| 624k| } 264| | /* now we can just return what we have */ 265| 749k| *buffer = (FLAC__byte*)bw->buffer; 266| 749k| *bytes = (FLAC__BYTES_PER_WORD * bw->words) + (bw->bits >> 3); ------------------ | | 72| 749k|#define FLAC__BYTES_PER_WORD 8 /* sizeof bwword */ ------------------ 267| | return true; 268| 749k|} FLAC__bitwriter_release_buffer: 271| 749k|{ 272| | /* nothing to do. in the future, strict checking of a 'writer-is-in- 273| | * get-mode' flag could be added everywhere and then cleared here 274| | */ 275| 749k| (void)bw; 276| 749k|} FLAC__bitwriter_write_zeroes: 279| 125k|{ 280| 125k| uint32_t n; 281| | 282| 125k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 125k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 125k] | | ------------------ ------------------ 283| 125k| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 125k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 125k] | | ------------------ ------------------ 284| | 285| 125k| if(bits == 0) ------------------ | Branch (285:5): [True: 0, False: 125k] ------------------ 286| 0| return true; 287| | /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+bits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */ 288| 125k| if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits)) ------------------ | Branch (288:5): [True: 23, False: 125k] | Branch (288:41): [True: 0, False: 23] ------------------ 289| 0| return false; 290| | /* first part gets to word alignment */ 291| 125k| if(bw->bits) { ------------------ | Branch (291:5): [True: 125k, False: 12] ------------------ 292| 125k| n = flac_min(FLAC__BITS_PER_WORD - bw->bits, bits); ------------------ | | 56| 125k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (292:7): [True: 0, False: 125k] ------------------ 293| 125k| bw->accum <<= n; 294| 125k| bits -= n; 295| 125k| bw->bits += n; 296| 125k| if(bw->bits == FLAC__BITS_PER_WORD) { ------------------ | | 73| 125k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (296:6): [True: 9.90k, False: 115k] ------------------ 297| 9.90k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); ------------------ | | 80| 9.90k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 9.90k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 298| 9.90k| bw->bits = 0; 299| 9.90k| } 300| 115k| else 301| 115k| return true; 302| 125k| } 303| | /* do whole words */ 304| 9.92k| while(bits >= FLAC__BITS_PER_WORD) { ------------------ | | 73| 9.92k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (304:8): [True: 0, False: 9.92k] ------------------ 305| 0| bw->buffer[bw->words++] = 0; 306| 0| bits -= FLAC__BITS_PER_WORD; ------------------ | | 73| 0|#define FLAC__BITS_PER_WORD 64 ------------------ 307| 0| } 308| | /* do any leftovers */ 309| 9.92k| if(bits > 0) { ------------------ | Branch (309:5): [True: 0, False: 9.92k] ------------------ 310| 0| bw->accum = 0; 311| 0| bw->bits = bits; 312| 0| } 313| | return true; 314| 125k|} FLAC__bitwriter_write_raw_uint32: 358| 6.96M|{ 359| | /* check that unused bits are unset */ 360| 6.96M| if((bits < 32) && (val>>bits != 0)) ------------------ | Branch (360:5): [True: 6.75M, False: 218k] | Branch (360:20): [True: 0, False: 6.75M] ------------------ 361| 0| return false; 362| | 363| 6.96M| return FLAC__bitwriter_write_raw_uint32_nocheck(bw, val, bits); 364| 6.96M|} FLAC__bitwriter_write_raw_int32: 367| 3.50M|{ 368| | /* zero-out unused bits */ 369| 3.50M| if(bits < 32) ------------------ | Branch (369:5): [True: 832k, False: 2.66M] ------------------ 370| 832k| val &= (~(0xffffffff << bits)); 371| | 372| 3.50M| return FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, bits); 373| 3.50M|} FLAC__bitwriter_write_raw_uint64: 376| 1.95M|{ 377| | /* this could be a little faster but it's not used for much */ 378| 1.95M| if(bits > 32) { ------------------ | Branch (378:5): [True: 1.64M, False: 305k] ------------------ 379| 1.64M| return 380| 1.64M| FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)(val>>32), bits-32) && ------------------ | Branch (380:4): [True: 1.64M, False: 0] ------------------ 381| 1.64M| FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, 32); ------------------ | Branch (381:4): [True: 1.64M, False: 0] ------------------ 382| 1.64M| } 383| 305k| else 384| 305k| return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, bits); 385| 1.95M|} FLAC__bitwriter_write_raw_int64: 388| 1.94M|{ 389| 1.94M| FLAC__uint64 uval = val; 390| | /* zero-out unused bits */ 391| 1.94M| if(bits < 64) ------------------ | Branch (391:5): [True: 1.94M, False: 5] ------------------ 392| 1.94M| uval &= (~(UINT64_MAX << bits)); 393| 1.94M| return FLAC__bitwriter_write_raw_uint64(bw, uval, bits); 394| 1.94M|} FLAC__bitwriter_write_raw_uint32_little_endian: 397| 18.7k|{ 398| | /* this doesn't need to be that fast as currently it is only used for vorbis comments */ 399| | 400| 18.7k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, val & 0xff, 8)) ------------------ | Branch (400:5): [True: 0, False: 18.7k] ------------------ 401| 0| return false; 402| 18.7k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (val>>8) & 0xff, 8)) ------------------ | Branch (402:5): [True: 0, False: 18.7k] ------------------ 403| 0| return false; 404| 18.7k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (val>>16) & 0xff, 8)) ------------------ | Branch (404:5): [True: 0, False: 18.7k] ------------------ 405| 0| return false; 406| 18.7k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, val>>24, 8)) ------------------ | Branch (406:5): [True: 0, False: 18.7k] ------------------ 407| 0| return false; 408| | 409| 18.7k| return true; 410| 18.7k|} FLAC__bitwriter_write_byte_block: 413| 18.7k|{ 414| 18.7k| uint32_t i; 415| | 416| | /* grow capacity upfront to prevent constant reallocation during writes */ 417| 18.7k| if(bw->capacity <= bw->words + nvals / (FLAC__BITS_PER_WORD / 8) + 1 && !bitwriter_grow_(bw, nvals * 8)) ------------------ | | 73| 18.7k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (417:5): [True: 0, False: 18.7k] | Branch (417:74): [True: 0, False: 0] ------------------ 418| 0| return false; 419| | 420| | /* this could be faster but currently we don't need it to be since it's only used for writing metadata */ 421| 534k| for(i = 0; i < nvals; i++) { ------------------ | Branch (421:13): [True: 515k, False: 18.7k] ------------------ 422| 515k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)(vals[i]), 8)) ------------------ | Branch (422:6): [True: 0, False: 515k] ------------------ 423| 0| return false; 424| 515k| } 425| | 426| 18.7k| return true; 427| 18.7k|} FLAC__bitwriter_write_unary_unsigned: 430| 31.9k|{ 431| 31.9k| if(val < 32) ------------------ | Branch (431:5): [True: 31.9k, False: 0] ------------------ 432| 31.9k| return FLAC__bitwriter_write_raw_uint32_nocheck(bw, 1, ++val); 433| 0| else 434| 0| return 435| 0| FLAC__bitwriter_write_zeroes(bw, val) && ------------------ | Branch (435:4): [True: 0, False: 0] ------------------ 436| 0| FLAC__bitwriter_write_raw_uint32_nocheck(bw, 1, 1); ------------------ | Branch (436:4): [True: 0, False: 0] ------------------ 437| 31.9k|} FLAC__bitwriter_write_rice_signed_block: 576| 1.42M|{ 577| 1.42M| const FLAC__uint32 mask1 = (FLAC__uint32)0xffffffff << parameter; /* we val|=mask1 to set the stop bit above it... */ 578| 1.42M| const FLAC__uint32 mask2 = (FLAC__uint32)0xffffffff >> (31-parameter); /* ...then mask off the bits above the stop bit with val&=mask2 */ 579| 1.42M| FLAC__uint32 uval; 580| 1.42M| const uint32_t lsbits = 1 + parameter; 581| 1.42M| uint32_t msbits, total_bits; 582| 1.42M| FLAC__bwtemp wide_accum = 0; 583| 1.42M| FLAC__uint32 bitpointer = FLAC__TEMP_BITS; ------------------ | | 74| 1.42M|#define FLAC__TEMP_BITS 64 ------------------ 584| | 585| 1.42M| FLAC__ASSERT(0 != bw); ------------------ | | 38| 1.42M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.42M] | | ------------------ ------------------ 586| 1.42M| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 1.42M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.42M] | | ------------------ ------------------ 587| 1.42M| FLAC__ASSERT(parameter < 31); ------------------ | | 38| 1.42M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.42M] | | ------------------ ------------------ 588| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 589| 1.42M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 1.42M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 1.42M] | | ------------------ ------------------ 590| |#if (ENABLE_64_BIT_WORDS == 0) 591| | if(bw->bits > 0) { 592| | bitpointer -= bw->bits; 593| | wide_accum = (FLAC__bwtemp)(bw->accum) << bitpointer; 594| | bw->bits = 0; 595| | } 596| |#else 597| 1.42M| if(bw->bits > 0 && bw->bits < FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 1.40M|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (597:5): [True: 1.40M, False: 18.4k] | Branch (597:21): [True: 697k, False: 709k] ------------------ 598| 697k| bitpointer -= bw->bits; 599| 697k| wide_accum = bw->accum << bitpointer; 600| 697k| bw->bits = 0; 601| 697k| } 602| 727k| else if(bw->bits > FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 727k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (602:10): [True: 698k, False: 29.3k] ------------------ 603| 698k| bitpointer -= (bw->bits - FLAC__HALF_TEMP_BITS); ------------------ | | 75| 698k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 604| 698k| wide_accum = bw->accum << bitpointer; 605| 698k| bw->accum >>= (bw->bits - FLAC__HALF_TEMP_BITS); ------------------ | | 75| 698k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 606| 698k| bw->bits = FLAC__HALF_TEMP_BITS; ------------------ | | 75| 698k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 607| 698k| } 608| 1.42M|#endif 609| | 610| | /* Reserve one FLAC__TEMP_BITS per symbol, so checks for space are only necessary when very large symbols are encountered 611| | * this might be considered wasteful, but is only at most 8kB more than necessary for a blocksize of 4096 */ 612| 1.42M| if(bw->capacity * FLAC__BITS_PER_WORD <= bw->words * FLAC__BITS_PER_WORD + nvals * FLAC__TEMP_BITS + bw->bits && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS)) ------------------ | | 73| 1.42M|#define FLAC__BITS_PER_WORD 64 ------------------ if(bw->capacity * FLAC__BITS_PER_WORD <= bw->words * FLAC__BITS_PER_WORD + nvals * FLAC__TEMP_BITS + bw->bits && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS)) ------------------ | | 73| 1.42M|#define FLAC__BITS_PER_WORD 64 ------------------ if(bw->capacity * FLAC__BITS_PER_WORD <= bw->words * FLAC__BITS_PER_WORD + nvals * FLAC__TEMP_BITS + bw->bits && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS)) ------------------ | | 74| 1.42M|#define FLAC__TEMP_BITS 64 ------------------ if(bw->capacity * FLAC__BITS_PER_WORD <= bw->words * FLAC__BITS_PER_WORD + nvals * FLAC__TEMP_BITS + bw->bits && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS)) ------------------ | | 74| 1.27k|#define FLAC__TEMP_BITS 64 ------------------ | Branch (612:5): [True: 1.27k, False: 1.42M] | Branch (612:115): [True: 0, False: 1.27k] ------------------ 613| 0| return false; 614| | 615| 23.2M| while(nvals) { ------------------ | Branch (615:8): [True: 21.7M, False: 1.42M] ------------------ 616| | /* fold signed to uint32_t; actual formula is: negative(v)? -2v-1 : 2v */ 617| 21.7M| uval = *vals; 618| 21.7M| uval <<= 1; 619| 21.7M| uval ^= (*vals>>31); 620| | 621| 21.7M| msbits = uval >> parameter; 622| 21.7M| total_bits = lsbits + msbits; 623| | 624| 21.7M| uval |= mask1; /* set stop bit */ 625| 21.7M| uval &= mask2; /* mask off unused top bits */ 626| | 627| | 628| 21.7M| if(total_bits <= bitpointer) { ------------------ | Branch (628:6): [True: 21.6M, False: 96.9k] ------------------ 629| | /* There is room enough to store the symbol whole at once */ 630| 21.6M| wide_accum |= (FLAC__bwtemp)(uval) << (bitpointer - total_bits); 631| 21.6M| bitpointer -= total_bits; 632| 21.6M| if(bitpointer <= FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 21.6M|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (632:7): [True: 14.4M, False: 7.23M] ------------------ 633| | /* A word is finished, copy the upper 32 bits of the wide_accum */ 634| 14.4M| WIDE_ACCUM_TO_BW ------------------ | | 556| 14.4M|#define WIDE_ACCUM_TO_BW { \ | | 557| 14.4M| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 14.4M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 14.4M] | | | | ------------------ | | ------------------ | | 558| 14.4M| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 7.20M, False: 7.25M] | | ------------------ | | 559| 7.20M| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 7.20M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 7.20M| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 7.20M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 7.20M| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 7.20M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 7.20M| } \ | | 563| 14.4M| else { \ | | 564| 7.25M| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 7.25M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 7.25M| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 7.25M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 7.25M| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 7.25M|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 7.25M|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 7.25M| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 7.25M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 7.25M| bw->bits = 0; \ | | 569| 7.25M| } \ | | 570| 14.4M| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.4M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 14.4M|} ------------------ 635| 14.4M| } 636| 21.6M| } 637| 96.9k| else { 638| | /* The symbol needs to be split. This code isn't used often */ 639| | /* First check for space in the bitwriter */ 640| 96.9k| if(total_bits > FLAC__TEMP_BITS) { ------------------ | | 74| 96.9k|#define FLAC__TEMP_BITS 64 ------------------ | Branch (640:7): [True: 32.7k, False: 64.1k] ------------------ 641| 32.7k| FLAC__uint32 oversize_in_bits = total_bits - FLAC__TEMP_BITS; ------------------ | | 74| 32.7k|#define FLAC__TEMP_BITS 64 ------------------ 642| 32.7k| FLAC__uint32 capacity_needed = bw->words * FLAC__BITS_PER_WORD + bw->bits + nvals * FLAC__TEMP_BITS + oversize_in_bits; ------------------ | | 73| 32.7k|#define FLAC__BITS_PER_WORD 64 ------------------ FLAC__uint32 capacity_needed = bw->words * FLAC__BITS_PER_WORD + bw->bits + nvals * FLAC__TEMP_BITS + oversize_in_bits; ------------------ | | 74| 32.7k|#define FLAC__TEMP_BITS 64 ------------------ 643| 32.7k| if(bw->capacity * FLAC__BITS_PER_WORD <= capacity_needed && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS + oversize_in_bits)) ------------------ | | 73| 32.7k|#define FLAC__BITS_PER_WORD 64 ------------------ if(bw->capacity * FLAC__BITS_PER_WORD <= capacity_needed && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS + oversize_in_bits)) ------------------ | | 74| 164|#define FLAC__TEMP_BITS 64 ------------------ | Branch (643:8): [True: 164, False: 32.6k] | Branch (643:65): [True: 0, False: 164] ------------------ 644| 0| return false; 645| 32.7k| } 646| 96.9k| if(msbits > bitpointer) { ------------------ | Branch (646:7): [True: 31.0k, False: 65.8k] ------------------ 647| | /* We have a lot of 0 bits to write, first align with bitwriter word */ 648| 31.0k| msbits -= bitpointer - FLAC__HALF_TEMP_BITS; ------------------ | | 75| 31.0k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 649| 31.0k| bitpointer = FLAC__HALF_TEMP_BITS; ------------------ | | 75| 31.0k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 650| 31.0k| WIDE_ACCUM_TO_BW ------------------ | | 556| 31.0k|#define WIDE_ACCUM_TO_BW { \ | | 557| 31.0k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 31.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 31.0k] | | | | ------------------ | | ------------------ | | 558| 31.0k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 15.5k, False: 15.4k] | | ------------------ | | 559| 15.5k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.5k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 15.5k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.5k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 15.5k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.5k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 15.5k| } \ | | 563| 31.0k| else { \ | | 564| 15.4k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 15.4k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 15.4k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 15.4k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 15.4k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 15.4k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 15.4k| bw->bits = 0; \ | | 569| 15.4k| } \ | | 570| 31.0k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 31.0k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 31.0k|} ------------------ 651| 260k| while(msbits > bitpointer) { ------------------ | Branch (651:11): [True: 229k, False: 31.0k] ------------------ 652| | /* As the accumulator is already zero, we only need to 653| | * assign zeroes to the bitbuffer */ 654| 229k| WIDE_ACCUM_TO_BW ------------------ | | 556| 229k|#define WIDE_ACCUM_TO_BW { \ | | 557| 229k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 229k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 229k] | | | | ------------------ | | ------------------ | | 558| 229k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 114k, False: 114k] | | ------------------ | | 559| 114k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 114k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 114k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 114k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 114k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 114k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 114k| } \ | | 563| 229k| else { \ | | 564| 114k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 114k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 114k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 114k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 114k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 114k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 114k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 114k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 114k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 114k| bw->bits = 0; \ | | 569| 114k| } \ | | 570| 229k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 229k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 229k|} ------------------ 655| 229k| bitpointer -= FLAC__HALF_TEMP_BITS; ------------------ | | 75| 229k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 656| 229k| msbits -= FLAC__HALF_TEMP_BITS; ------------------ | | 75| 229k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 657| 229k| } 658| | /* The remaining bits are zero, and the accumulator already is zero, 659| | * so just subtract the number of bits from bitpointer. When storing, 660| | * we can also just store 0 */ 661| 31.0k| bitpointer -= msbits; 662| 31.0k| if(bitpointer <= FLAC__HALF_TEMP_BITS) ------------------ | | 75| 31.0k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (662:8): [True: 31.0k, False: 0] ------------------ 663| 31.0k| WIDE_ACCUM_TO_BW ------------------ | | 556| 31.0k|#define WIDE_ACCUM_TO_BW { \ | | 557| 31.0k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 31.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 31.0k] | | | | ------------------ | | ------------------ | | 558| 31.0k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 15.6k, False: 15.3k] | | ------------------ | | 559| 15.6k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 15.6k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 15.6k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 15.6k| } \ | | 563| 31.0k| else { \ | | 564| 15.3k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.3k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 15.3k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.3k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 15.3k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 15.3k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 15.3k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 15.3k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 15.3k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 15.3k| bw->bits = 0; \ | | 569| 15.3k| } \ | | 570| 31.0k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 31.0k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 31.0k|} ------------------ 664| 31.0k| } 665| 65.8k| else { 666| 65.8k| bitpointer -= msbits; 667| 65.8k| if(bitpointer <= FLAC__HALF_TEMP_BITS) ------------------ | | 75| 65.8k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (667:8): [True: 66.4k, False: 18.4E] ------------------ 668| 66.4k| WIDE_ACCUM_TO_BW ------------------ | | 556| 66.4k|#define WIDE_ACCUM_TO_BW { \ | | 557| 66.4k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 66.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 66.4k] | | | | ------------------ | | ------------------ | | 558| 66.4k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 33.7k, False: 32.7k] | | ------------------ | | 559| 33.7k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 33.7k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 33.7k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 33.7k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 33.7k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 33.7k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 33.7k| } \ | | 563| 66.4k| else { \ | | 564| 32.7k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 32.7k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 32.7k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 32.7k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 32.7k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 32.7k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 32.7k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 32.7k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 32.7k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 32.7k| bw->bits = 0; \ | | 569| 32.7k| } \ | | 570| 66.4k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 66.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 66.4k|} ------------------ 669| 65.8k| } 670| | /* The lsbs + stop bit always fit 32 bit, so this code mirrors the code above */ 671| 96.9k| wide_accum |= (FLAC__bwtemp)(uval) << (bitpointer - lsbits); 672| 96.9k| bitpointer -= lsbits; 673| 96.9k| if(bitpointer <= FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 96.9k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (673:28): [True: 86.0k, False: 10.8k] ------------------ 674| | /* A word is finished, copy the upper 32 bits of the wide_accum */ 675| 86.0k| WIDE_ACCUM_TO_BW ------------------ | | 556| 86.0k|#define WIDE_ACCUM_TO_BW { \ | | 557| 86.0k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 86.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 86.0k] | | | | ------------------ | | ------------------ | | 558| 86.0k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 42.4k, False: 43.6k] | | ------------------ | | 559| 42.4k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 42.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 42.4k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 42.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 42.4k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 42.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 42.4k| } \ | | 563| 86.0k| else { \ | | 564| 43.6k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 43.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 43.6k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 43.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 43.6k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 43.6k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 43.6k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 43.6k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 43.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 43.6k| bw->bits = 0; \ | | 569| 43.6k| } \ | | 570| 86.0k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 86.0k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 86.0k|} ------------------ 676| 86.0k| } 677| 96.9k| } 678| 21.7M| vals++; 679| 21.7M| nvals--; 680| 21.7M| } 681| | /* Now fixup remainder of wide_accum */ 682| |#if (ENABLE_64_BIT_WORDS == 0) 683| | if(bitpointer < FLAC__TEMP_BITS) { 684| | bw->accum = wide_accum >> bitpointer; 685| | bw->bits = FLAC__TEMP_BITS - bitpointer; 686| | } 687| |#else 688| 1.42M| if(bitpointer < FLAC__TEMP_BITS) { ------------------ | | 74| 1.42M|#define FLAC__TEMP_BITS 64 ------------------ | Branch (688:5): [True: 1.39M, False: 28.8k] ------------------ 689| 1.39M| if(bw->bits == 0) { ------------------ | Branch (689:6): [True: 744k, False: 651k] ------------------ 690| 744k| bw->accum = wide_accum >> bitpointer; 691| 744k| bw->bits = FLAC__TEMP_BITS - bitpointer; ------------------ | | 74| 744k|#define FLAC__TEMP_BITS 64 ------------------ 692| 744k| } 693| 657k| else if (bw->bits == FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 651k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (693:12): [True: 657k, False: 18.4E] ------------------ 694| 657k| bw->accum <<= FLAC__TEMP_BITS - bitpointer; ------------------ | | 74| 657k|#define FLAC__TEMP_BITS 64 ------------------ 695| 657k| bw->accum |= (wide_accum >> bitpointer); 696| 657k| bw->bits = FLAC__HALF_TEMP_BITS + FLAC__TEMP_BITS - bitpointer; ------------------ | | 75| 657k|#define FLAC__HALF_TEMP_BITS 32 ------------------ bw->bits = FLAC__HALF_TEMP_BITS + FLAC__TEMP_BITS - bitpointer; ------------------ | | 74| 657k|#define FLAC__TEMP_BITS 64 ------------------ 697| 657k| } 698| 18.4E| else { 699| 18.4E| FLAC__ASSERT(0); ------------------ | | 38| 18.4E|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 700| 18.4E| } 701| 1.39M| } 702| 1.42M|#endif 703| | 704| | 705| 1.42M| return true; 706| 1.42M|} FLAC__bitwriter_write_utf8_uint32: 833| 242k|{ 834| 242k| FLAC__bool ok = 1; 835| | 836| 242k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 242k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 242k] | | ------------------ ------------------ 837| 242k| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 242k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 242k] | | ------------------ ------------------ 838| | 839| 242k| if((val & 0x80000000) != 0) /* this version only handles 31 bits */ ------------------ | Branch (839:5): [True: 0, False: 242k] ------------------ 840| 0| return false; 841| | 842| 242k| if(val < 0x80) { ------------------ | Branch (842:5): [True: 80.8k, False: 161k] ------------------ 843| 80.8k| return FLAC__bitwriter_write_raw_uint32_nocheck(bw, val, 8); 844| 80.8k| } 845| 161k| else if(val < 0x800) { ------------------ | Branch (845:10): [True: 132k, False: 29.6k] ------------------ 846| 132k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xC0 | (val>>6), 8); 847| 132k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 848| 132k| } 849| 29.6k| else if(val < 0x10000) { ------------------ | Branch (849:10): [True: 29.6k, False: 18.4E] ------------------ 850| 29.6k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xE0 | (val>>12), 8); 851| 29.6k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8); 852| 29.6k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 853| 29.6k| } 854| 18.4E| else if(val < 0x200000) { ------------------ | Branch (854:10): [True: 0, False: 18.4E] ------------------ 855| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xF0 | (val>>18), 8); 856| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>12)&0x3F), 8); 857| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8); 858| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 859| 0| } 860| 18.4E| else if(val < 0x4000000) { ------------------ | Branch (860:10): [True: 0, False: 18.4E] ------------------ 861| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xF8 | (val>>24), 8); 862| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>18)&0x3F), 8); 863| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>12)&0x3F), 8); 864| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8); 865| 0| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 866| 0| } 867| 18.4E| else { 868| 18.4E| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xFC | (val>>30), 8); 869| 18.4E| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>24)&0x3F), 8); 870| 18.4E| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>18)&0x3F), 8); 871| 18.4E| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>12)&0x3F), 8); 872| 18.4E| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8); 873| 18.4E| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 874| 18.4E| } 875| | 876| 161k| return ok; 877| 242k|} FLAC__bitwriter_zero_pad_to_byte_boundary: 936| 243k|{ 937| | /* 0-pad to byte boundary */ 938| 243k| if(bw->bits & 7u) ------------------ | Branch (938:5): [True: 125k, False: 117k] ------------------ 939| 125k| return FLAC__bitwriter_write_zeroes(bw, 8 - (bw->bits & 7u)); 940| 117k| else 941| 117k| return true; 942| 243k|} bitwriter.c:bitwriter_grow_: 111| 26.5k|{ 112| 26.5k| uint32_t new_capacity; 113| 26.5k| bwword *new_buffer; 114| | 115| | /* Refuse to allocate more words than this amount, based on largest possible metadata chunk size */ 116| 26.5k| const uint32_t max_capacity = (((1u << FLAC__STREAM_METADATA_LENGTH_LEN) - 1) * 8 + FLAC__STREAM_METADATA_LENGTH_LEN + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD; ------------------ | | 73| 26.5k|#define FLAC__BITS_PER_WORD 64 ------------------ const uint32_t max_capacity = (((1u << FLAC__STREAM_METADATA_LENGTH_LEN) - 1) * 8 + FLAC__STREAM_METADATA_LENGTH_LEN + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD; ------------------ | | 73| 26.5k|#define FLAC__BITS_PER_WORD 64 ------------------ 117| | 118| 26.5k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 26.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 26.5k] | | ------------------ ------------------ 119| 26.5k| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 26.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 26.5k] | | ------------------ ------------------ 120| | 121| | /* calculate total words needed to store 'bits_to_add' additional bits */ 122| 26.5k| new_capacity = bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD); ------------------ | | 73| 26.5k|#define FLAC__BITS_PER_WORD 64 ------------------ new_capacity = bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD); ------------------ | | 73| 26.5k|#define FLAC__BITS_PER_WORD 64 ------------------ 123| | 124| | /* it's possible (due to pessimism in the growth estimation that 125| | * leads to this call) that we don't actually need to grow 126| | */ 127| 26.5k| if(bw->capacity >= new_capacity) ------------------ | Branch (127:5): [True: 24.8k, False: 1.68k] ------------------ 128| 24.8k| return true; 129| | 130| 1.68k| if(new_capacity > max_capacity) ------------------ | Branch (130:5): [True: 0, False: 1.68k] ------------------ 131| | /* Requested new capacity is larger than the largest possible metadata block, 132| | * which is also larger than the largest sane framesize. That means something 133| | * went very wrong somewhere and previous checks failed. 134| | * To prevent chrashing, give up */ 135| 0| return false; 136| | 137| | /* As reallocation can be quite expensive, grow exponentially */ 138| 1.68k| if((new_capacity - bw->capacity) < (bw->capacity >> FLAC__BITWRITER_DEFAULT_GROW_FRACTION)) ------------------ | Branch (138:5): [True: 975, False: 708] ------------------ 139| 975| new_capacity = bw->capacity + (bw->capacity >> FLAC__BITWRITER_DEFAULT_GROW_FRACTION); 140| | 141| | /* make sure we got everything right */ 142| 1.68k| FLAC__ASSERT(new_capacity > bw->capacity); ------------------ | | 38| 1.68k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.68k] | | ------------------ ------------------ 143| 1.68k| FLAC__ASSERT(new_capacity >= bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD)); ------------------ | | 38| 1.68k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.68k] | | ------------------ ------------------ 144| | 145| 1.68k| new_buffer = safe_realloc_nofree_mul_2op_(bw->buffer, sizeof(bwword), /*times*/new_capacity); 146| 1.68k| if(new_buffer == 0) ------------------ | Branch (146:5): [True: 0, False: 1.68k] ------------------ 147| 0| return false; 148| 1.68k| bw->buffer = new_buffer; 149| 1.68k| bw->capacity = new_capacity; 150| | return true; 151| 1.68k|} bitwriter.c:FLAC__bitwriter_write_raw_uint32_nocheck: 317| 13.1M|{ 318| 13.1M| register uint32_t left; 319| | 320| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 321| 13.1M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 13.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 13.1M] | | ------------------ ------------------ 322| | 323| 13.1M| if(bw == 0 || bw->buffer == 0) ------------------ | Branch (323:5): [True: 18.4E, False: 13.1M] | Branch (323:16): [True: 18.4E, False: 13.1M] ------------------ 324| 0| return false; 325| | 326| 13.1M| if (bits > 32) ------------------ | Branch (326:6): [True: 0, False: 13.1M] ------------------ 327| 0| return false; 328| | 329| 13.1M| if(bits == 0) ------------------ | Branch (329:5): [True: 0, False: 13.1M] ------------------ 330| 0| return true; 331| | 332| 13.1M| FLAC__ASSERT((bits == 32) || (val>>bits == 0)); ------------------ | | 38| 21.7M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 4.52M, False: 8.63M] | | | Branch (38:30): [True: 8.63M, False: 0] | | ------------------ ------------------ 333| | 334| | /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+bits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */ 335| 13.1M| if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits)) ------------------ | Branch (335:5): [True: 25.0k, False: 13.1M] | Branch (335:41): [True: 0, False: 25.0k] ------------------ 336| 0| return false; 337| | 338| 13.1M| left = FLAC__BITS_PER_WORD - bw->bits; ------------------ | | 73| 13.1M|#define FLAC__BITS_PER_WORD 64 ------------------ 339| 13.1M| if(bits < left) { ------------------ | Branch (339:5): [True: 10.1M, False: 2.97M] ------------------ 340| 10.1M| bw->accum <<= bits; 341| 10.1M| bw->accum |= val; 342| 10.1M| bw->bits += bits; 343| 10.1M| } 344| 2.99M| else if(bw->bits) { /* WATCHOUT: if bw->bits == 0, left==FLAC__BITS_PER_WORD and bw->accum<<=left is a NOP instead of setting to 0 */ ------------------ | Branch (344:10): [True: 2.99M, False: 18.4E] ------------------ 345| 2.99M| bw->accum <<= left; 346| 2.99M| bw->accum |= val >> (bw->bits = bits - left); 347| 2.99M| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); ------------------ | | 80| 2.99M|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 2.99M|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 348| 2.99M| bw->accum = val; /* unused top bits can contain garbage */ 349| 2.99M| } 350| 18.4E| else { /* at this point bits == FLAC__BITS_PER_WORD == 32 and bw->bits == 0 */ 351| 18.4E| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST((bwword)val); ------------------ | | 80| 18.4E|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 18.4E|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 352| 18.4E| } 353| | 354| | return true; 355| 13.1M|} FLAC__cpu_info: 203| 17.5k|{ 204| 17.5k| memset(info, 0, sizeof(*info)); 205| | 206| |#ifdef FLAC__CPU_IA32 207| | info->type = FLAC__CPUINFO_TYPE_IA32; 208| |#elif defined FLAC__CPU_X86_64 209| | info->type = FLAC__CPUINFO_TYPE_X86_64; 210| |#else 211| | info->type = FLAC__CPUINFO_TYPE_UNKNOWN; 212| |#endif 213| | 214| 17.5k| switch (info->type) { 215| 0| case FLAC__CPUINFO_TYPE_IA32: /* fallthrough */ ------------------ | Branch (215:2): [True: 0, False: 17.5k] ------------------ 216| 17.5k| case FLAC__CPUINFO_TYPE_X86_64: ------------------ | Branch (216:2): [True: 17.5k, False: 0] ------------------ 217| 17.5k| x86_cpu_info (info); 218| 17.5k| break; 219| 0| default: ------------------ | Branch (219:2): [True: 0, False: 17.5k] ------------------ 220| | info->use_asm = false; 221| 0| break; 222| 17.5k| } 223| 17.5k|} cpu.c:x86_cpu_info: 153| 17.5k|{ 154| 17.5k|#if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN && !defined FLAC__NO_ASM 155| 17.5k| FLAC__bool x86_osxsave = false; 156| 17.5k| FLAC__bool os_avx = false; 157| 17.5k| FLAC__uint32 flags_eax, flags_ebx, flags_ecx, flags_edx; 158| | 159| 17.5k| info->use_asm = true; /* we assume a minimum of 80386 */ 160| 17.5k| if (!cpu_have_cpuid()) ------------------ | Branch (160:6): [True: 0, False: 17.5k] ------------------ 161| 0| return; 162| | 163| 17.5k| cpuinfo_x86(0, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx); 164| 17.5k| info->x86.intel = (flags_ebx == 0x756E6547 && flags_edx == 0x49656E69 && flags_ecx == 0x6C65746E) ? true : false; /* GenuineIntel */ ------------------ | Branch (164:21): [True: 17.5k, False: 0] | Branch (164:48): [True: 17.5k, False: 0] | Branch (164:75): [True: 17.5k, False: 0] ------------------ 165| 17.5k| cpuinfo_x86(1, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx); 166| | 167| 17.5k| info->x86.cmov = (flags_edx & FLAC__CPUINFO_X86_CPUID_CMOV ) ? true : false; ------------------ | Branch (167:20): [True: 17.5k, False: 0] ------------------ 168| 17.5k| info->x86.mmx = (flags_edx & FLAC__CPUINFO_X86_CPUID_MMX ) ? true : false; ------------------ | Branch (168:20): [True: 17.5k, False: 0] ------------------ 169| 17.5k| info->x86.sse = (flags_edx & FLAC__CPUINFO_X86_CPUID_SSE ) ? true : false; ------------------ | Branch (169:20): [True: 17.5k, False: 0] ------------------ 170| 17.5k| info->x86.sse2 = (flags_edx & FLAC__CPUINFO_X86_CPUID_SSE2 ) ? true : false; ------------------ | Branch (170:20): [True: 17.5k, False: 0] ------------------ 171| 17.5k| info->x86.sse3 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE3 ) ? true : false; ------------------ | Branch (171:20): [True: 17.5k, False: 0] ------------------ 172| 17.5k| info->x86.ssse3 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSSE3) ? true : false; ------------------ | Branch (172:20): [True: 17.5k, False: 0] ------------------ 173| 17.5k| info->x86.sse41 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE41) ? true : false; ------------------ | Branch (173:20): [True: 17.5k, False: 0] ------------------ 174| 17.5k| info->x86.sse42 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE42) ? true : false; ------------------ | Branch (174:20): [True: 17.5k, False: 0] ------------------ 175| | 176| 17.5k| if (FLAC__AVX_SUPPORTED) { ------------------ | | 90| 17.5k| #define FLAC__AVX_SUPPORTED 1 | | ------------------ | | | Branch (90:33): [True: 17.5k, Folded] | | ------------------ ------------------ 177| 17.5k| x86_osxsave = (flags_ecx & FLAC__CPUINFO_X86_CPUID_OSXSAVE) ? true : false; ------------------ | Branch (177:21): [True: 17.5k, False: 0] ------------------ 178| 17.5k| info->x86.avx = (flags_ecx & FLAC__CPUINFO_X86_CPUID_AVX ) ? true : false; ------------------ | Branch (178:21): [True: 17.5k, False: 0] ------------------ 179| 17.5k| info->x86.fma = (flags_ecx & FLAC__CPUINFO_X86_CPUID_FMA ) ? true : false; ------------------ | Branch (179:21): [True: 17.5k, False: 0] ------------------ 180| 17.5k| cpuinfo_x86(7, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx); 181| 17.5k| info->x86.avx2 = (flags_ebx & FLAC__CPUINFO_X86_CPUID_AVX2 ) ? true : false; ------------------ | Branch (181:21): [True: 17.5k, False: 0] ------------------ 182| 17.5k| info->x86.bmi2 = (flags_ebx & FLAC__CPUINFO_X86_CPUID_BMI2 ) ? true : false; ------------------ | Branch (182:21): [True: 17.5k, False: 0] ------------------ 183| 17.5k| } 184| | 185| | /* 186| | * now have to check for OS support of AVX instructions 187| | */ 188| 17.5k| if (FLAC__AVX_SUPPORTED && info->x86.avx && x86_osxsave && (cpu_xgetbv_x86() & 0x6) == 0x6) { ------------------ | | 90| 35.0k| #define FLAC__AVX_SUPPORTED 1 | | ------------------ | | | Branch (90:33): [True: 17.5k, Folded] | | ------------------ ------------------ | Branch (188:29): [True: 17.5k, False: 0] | Branch (188:46): [True: 17.5k, False: 0] | Branch (188:61): [True: 17.5k, False: 0] ------------------ 189| 17.5k| os_avx = true; 190| 17.5k| } 191| 17.5k| if (!os_avx) { ------------------ | Branch (191:6): [True: 0, False: 17.5k] ------------------ 192| | /* no OS AVX support */ 193| 0| info->x86.avx = false; 194| 0| info->x86.avx2 = false; 195| 0| info->x86.fma = false; 196| 0| } 197| |#else 198| | info->use_asm = false; 199| |#endif 200| 17.5k|} cpu.c:cpu_have_cpuid: 89| 17.5k|{ 90| 17.5k|#if defined FLAC__CPU_X86_64 || defined __i686__ || defined __SSE__ || (defined _M_IX86_FP && _M_IX86_FP > 0) 91| | /* target CPU does have CPUID instruction */ 92| 17.5k| return 1; 93| |#elif defined __GNUC__ && defined HAVE_CPUID_H 94| | if (__get_cpuid_max(0, 0) != 0) 95| | return 1; 96| | else 97| | return 0; 98| |#elif defined _MSC_VER 99| | FLAC__uint32 flags1, flags2; 100| | __asm { 101| | pushfd 102| | pushfd 103| | pop eax 104| | mov flags1, eax 105| | xor eax, 0x200000 106| | push eax 107| | popfd 108| | pushfd 109| | pop eax 110| | mov flags2, eax 111| | popfd 112| | } 113| | if (((flags1^flags2) & 0x200000) != 0) 114| | return 1; 115| | else 116| | return 0; 117| |#else 118| | return 0; 119| |#endif 120| 17.5k|} cpu.c:cpuinfo_x86: 124| 52.6k|{ 125| |#if defined _MSC_VER 126| | int cpuinfo[4]; 127| | int ext = level & 0x80000000; 128| | __cpuid(cpuinfo, ext); 129| | if ((uint32_t)cpuinfo[0] >= level) { 130| |#if FLAC__AVX_SUPPORTED 131| | __cpuidex(cpuinfo, level, 0); /* for AVX2 detection */ 132| |#else 133| | __cpuid(cpuinfo, level); /* some old compilers don't support __cpuidex */ 134| |#endif 135| | *eax = cpuinfo[0]; *ebx = cpuinfo[1]; *ecx = cpuinfo[2]; *edx = cpuinfo[3]; 136| | return; 137| | } 138| |#elif defined __GNUC__ && defined HAVE_CPUID_H 139| | FLAC__uint32 ext = level & 0x80000000; 140| 52.6k| __cpuid(ext, *eax, *ebx, *ecx, *edx); 141| 52.6k| if (*eax >= level) { ------------------ | Branch (141:6): [True: 52.6k, False: 0] ------------------ 142| 52.6k| __cpuid_count(level, 0, *eax, *ebx, *ecx, *edx); 143| 52.6k| return; 144| 52.6k| } 145| 0|#endif 146| 0| *eax = *ebx = *ecx = *edx = 0; 147| 0|} cpu.c:cpu_xgetbv_x86: 75| 17.5k|{ 76| |#if (defined _MSC_VER || defined __INTEL_COMPILER) && FLAC__AVX_SUPPORTED 77| | return (uint32_t)_xgetbv(0); 78| |#elif defined __GNUC__ 79| | uint32_t lo, hi; 80| 17.5k| __asm__ volatile (".byte 0x0f, 0x01, 0xd0" : "=a"(lo), "=d"(hi) : "c" (0)); 81| 17.5k| return lo; 82| |#else 83| | return 0; 84| |#endif 85| 17.5k|} FLAC__crc8: 367| 242k|{ 368| 242k| FLAC__uint8 crc = 0; 369| | 370| 2.18M| while(len--) ------------------ | Branch (370:8): [True: 1.94M, False: 242k] ------------------ 371| 1.94M| crc = FLAC__crc8_table[crc ^ *data++]; 372| | 373| 242k| return crc; 374| 242k|} FLAC__crc16: 377| 242k|{ 378| 242k| FLAC__uint16 crc = 0; 379| | 380| 10.5M| while(len >= 8){ ------------------ | Branch (380:8): [True: 10.3M, False: 242k] ------------------ 381| 10.3M| crc ^= data[0] << 8 | data[1]; 382| | 383| 10.3M| crc = FLAC__crc16_table[7][crc >> 8] ^ FLAC__crc16_table[6][crc & 0xFF] ^ 384| 10.3M| FLAC__crc16_table[5][data[2] ] ^ FLAC__crc16_table[4][data[3] ] ^ 385| 10.3M| FLAC__crc16_table[3][data[4] ] ^ FLAC__crc16_table[2][data[5] ] ^ 386| 10.3M| FLAC__crc16_table[1][data[6] ] ^ FLAC__crc16_table[0][data[7] ]; 387| | 388| 10.3M| data += 8; 389| 10.3M| len -= 8; 390| 10.3M| } 391| | 392| 1.23M| while(len--) ------------------ | Branch (392:8): [True: 996k, False: 242k] ------------------ 393| 996k| crc = (crc<<8) ^ FLAC__crc16_table[0][(crc>>8) ^ *data++]; 394| | 395| 242k| return crc; 396| 242k|} FLAC__crc16_update_words64: 423| 387k|{ 424| 11.9M| while (len--) { ------------------ | Branch (424:9): [True: 11.5M, False: 387k] ------------------ 425| 11.5M| crc ^= words[0] >> 48; 426| | 427| 11.5M| crc = FLAC__crc16_table[7][crc >> 8 ] ^ FLAC__crc16_table[6][crc & 0xFF ] ^ 428| 11.5M| FLAC__crc16_table[5][(words[0] >> 40) & 0xFF] ^ FLAC__crc16_table[4][(words[0] >> 32) & 0xFF] ^ 429| 11.5M| FLAC__crc16_table[3][(words[0] >> 24) & 0xFF] ^ FLAC__crc16_table[2][(words[0] >> 16) & 0xFF] ^ 430| 11.5M| FLAC__crc16_table[1][(words[0] >> 8) & 0xFF] ^ FLAC__crc16_table[0][ words[0] & 0xFF]; 431| | 432| 11.5M| words++; 433| 11.5M| } 434| | 435| 387k| return crc; 436| 387k|} FLAC__bitreader_read_rice_signed_block_bmi2: 1| 1.39M|{ 2| | /* try and get br->consumed_words and br->consumed_bits into register; 3| | * must remember to flush them back to *br before calling other 4| | * bitreader functions that use them, and before returning */ 5| 1.39M| uint32_t cwords, words, lsbs, msbs, x, y, limit; 6| 1.39M| uint32_t ucbits; /* keep track of the number of unconsumed bits in word */ 7| 1.39M| brword b; 8| 1.39M| int *val, *end; 9| | 10| 1.39M| FLAC__ASSERT(0 != br); ------------------ | | 38| 1.39M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.39M] | | ------------------ ------------------ 11| 1.39M| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 1.39M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.39M] | | ------------------ ------------------ 12| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 13| 1.39M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 1.39M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 1.39M] | | ------------------ ------------------ 14| 1.39M| FLAC__ASSERT(parameter < 32); ------------------ | | 38| 1.39M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.39M] | | ------------------ ------------------ 15| | /* the above two asserts also guarantee that the binary part never straddles more than 2 words, so we don't have to loop to read it */ 16| | 17| 1.39M| limit = UINT32_MAX >> parameter; /* Maximal msbs that can occur with residual bounded to int32_t */ 18| | 19| 1.39M| val = vals; 20| 1.39M| end = vals + nvals; 21| | 22| 1.39M| if(parameter == 0) { ------------------ | Branch (22:5): [True: 670k, False: 723k] ------------------ 23| 4.03M| while(val < end) { ------------------ | Branch (23:9): [True: 3.36M, False: 670k] ------------------ 24| | /* read the unary MSBs and end bit */ 25| 3.36M| if(!FLAC__bitreader_read_unary_unsigned(br, &msbs)) ------------------ | Branch (25:7): [True: 0, False: 3.36M] ------------------ 26| 0| return false; 27| | /* Checking limit here would be overzealous: coding UINT32_MAX 28| | * with parameter == 0 would take 4GiB */ 29| 3.36M| *val++ = (int)(msbs >> 1) ^ -(int)(msbs & 1); 30| 3.36M| } 31| | 32| 670k| return true; 33| 670k| } 34| | 35| 723k| FLAC__ASSERT(parameter > 0); ------------------ | | 38| 723k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 723k] | | ------------------ ------------------ 36| | 37| 723k| cwords = br->consumed_words; 38| 723k| words = br->words; 39| | 40| | /* if we've not consumed up to a partial tail word... */ 41| 723k| if(cwords >= words) { ------------------ | Branch (41:5): [True: 2.68k, False: 720k] ------------------ 42| 2.68k| x = 0; 43| 2.68k| goto process_tail; 44| 2.68k| } 45| | 46| 720k| ucbits = FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 720k|#define FLAC__BITS_PER_WORD 64 ------------------ 47| 720k| b = br->buffer[cwords] << br->consumed_bits; /* keep unconsumed bits aligned to left */ 48| | 49| 18.5M| while(val < end) { ------------------ | Branch (49:8): [True: 17.8M, False: 723k] ------------------ 50| | /* read the unary MSBs and end bit */ 51| 17.8M| x = y = COUNT_ZERO_MSBS2(b); ------------------ | | 83| 17.8M|#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint64(word) ------------------ 52| 17.8M| if(x == FLAC__BITS_PER_WORD) { ------------------ | | 73| 17.8M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (52:6): [True: 540k, False: 17.2M] ------------------ 53| 540k| x = ucbits; 54| 647k| do { 55| | /* didn't find stop bit yet, have to keep going... */ 56| 647k| cwords++; 57| 647k| if (cwords >= words) ------------------ | Branch (57:9): [True: 4.81k, False: 642k] ------------------ 58| 4.81k| goto incomplete_msbs; 59| 642k| b = br->buffer[cwords]; 60| 642k| y = COUNT_ZERO_MSBS2(b); ------------------ | | 83| 642k|#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint64(word) ------------------ 61| 642k| x += y; 62| 642k| } while(y == FLAC__BITS_PER_WORD); ------------------ | | 73| 642k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (62:12): [True: 106k, False: 536k] ------------------ 63| 540k| } 64| 17.8M| b <<= y; 65| 17.8M| b <<= 1; /* account for stop bit */ 66| 17.8M| ucbits = (ucbits - x - 1) % FLAC__BITS_PER_WORD; ------------------ | | 73| 17.8M|#define FLAC__BITS_PER_WORD 64 ------------------ 67| 17.8M| msbs = x; 68| | 69| 17.8M| if(x > limit) ------------------ | Branch (69:6): [True: 0, False: 17.8M] ------------------ 70| 0| return false; 71| | 72| | /* read the binary LSBs */ 73| 17.8M| x = (FLAC__uint32)(b >> (FLAC__BITS_PER_WORD - parameter)); /* parameter < 32, so we can cast to 32-bit uint32_t */ ------------------ | | 73| 17.8M|#define FLAC__BITS_PER_WORD 64 ------------------ 74| 17.8M| if(parameter <= ucbits) { ------------------ | Branch (74:6): [True: 11.1M, False: 6.65M] ------------------ 75| 11.1M| ucbits -= parameter; 76| 11.1M| b <<= parameter; 77| 11.1M| } else { 78| | /* there are still bits left to read, they will all be in the next word */ 79| 6.65M| cwords++; 80| 6.65M| if (cwords >= words) ------------------ | Branch (80:8): [True: 37.7k, False: 6.61M] ------------------ 81| 37.7k| goto incomplete_lsbs; 82| 6.61M| b = br->buffer[cwords]; 83| 6.61M| ucbits += FLAC__BITS_PER_WORD - parameter; ------------------ | | 73| 6.61M|#define FLAC__BITS_PER_WORD 64 ------------------ 84| 6.61M| x |= (FLAC__uint32)(b >> ucbits); 85| 6.61M| b <<= FLAC__BITS_PER_WORD - ucbits; ------------------ | | 73| 6.61M|#define FLAC__BITS_PER_WORD 64 ------------------ 86| 6.61M| } 87| 17.7M| lsbs = x; 88| | 89| | /* compose the value */ 90| 17.7M| x = (msbs << parameter) | lsbs; 91| 17.7M| *val++ = (int)(x >> 1) ^ -(int)(x & 1); 92| | 93| 17.7M| continue; 94| | 95| | /* at this point we've eaten up all the whole words */ 96| 2.68k|process_tail: 97| 26.6k| do { 98| 26.6k| if(0) { ------------------ | Branch (98:7): [Folded, False: 26.6k] ------------------ 99| 4.81k|incomplete_msbs: 100| 4.81k| br->consumed_bits = 0; 101| 4.81k| br->consumed_words = cwords; 102| 4.81k| } 103| | 104| | /* read the unary MSBs and end bit */ 105| 31.4k| if(!FLAC__bitreader_read_unary_unsigned(br, &msbs)) ------------------ | Branch (105:7): [True: 0, False: 31.4k] ------------------ 106| 0| return false; 107| 31.4k| msbs += x; 108| 31.4k| x = ucbits = 0; 109| | 110| 31.4k| if(0) { ------------------ | Branch (110:7): [Folded, False: 31.4k] ------------------ 111| 37.7k|incomplete_lsbs: 112| 37.7k| br->consumed_bits = 0; 113| 37.7k| br->consumed_words = cwords; 114| 37.7k| } 115| | 116| | /* read the binary LSBs */ 117| 69.2k| if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter - ucbits)) ------------------ | Branch (117:7): [True: 0, False: 69.2k] ------------------ 118| 0| return false; 119| 69.2k| lsbs = x | lsbs; 120| | 121| | /* compose the value */ 122| 69.2k| x = (msbs << parameter) | lsbs; 123| 69.2k| *val++ = (int)(x >> 1) ^ -(int)(x & 1); 124| 69.2k| x = 0; 125| | 126| 69.2k| cwords = br->consumed_words; 127| 69.2k| words = br->words; 128| 69.2k| ucbits = FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 69.2k|#define FLAC__BITS_PER_WORD 64 ------------------ 129| 69.2k| b = cwords < br->capacity ? br->buffer[cwords] << br->consumed_bits : 0; ------------------ | Branch (129:8): [True: 69.2k, False: 0] ------------------ 130| 69.2k| } while(cwords >= words && val < end); ------------------ | Branch (130:11): [True: 63.3k, False: 5.85k] | Branch (130:30): [True: 23.9k, False: 39.3k] ------------------ 131| 2.68k| } 132| | 133| 723k| if(ucbits == 0 && cwords < words) { ------------------ | Branch (133:5): [True: 9.90k, False: 713k] | Branch (133:20): [True: 9.90k, False: 0] ------------------ 134| | /* don't leave the head word with no unconsumed bits */ 135| 9.90k| cwords++; 136| 9.90k| ucbits = FLAC__BITS_PER_WORD; ------------------ | | 73| 9.90k|#define FLAC__BITS_PER_WORD 64 ------------------ 137| 9.90k| } 138| | 139| 723k| br->consumed_bits = FLAC__BITS_PER_WORD - ucbits; ------------------ | | 73| 723k|#define FLAC__BITS_PER_WORD 64 ------------------ 140| 723k| br->consumed_words = cwords; 141| | 142| | return true; 143| 720k|} FLAC__fixed_compute_best_predictor_limit_residual_33bit: 428| 13.0k|{ 429| 13.0k| FLAC__uint64 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0, smallest_error = UINT64_MAX; 430| 13.0k| FLAC__uint64 error_0, error_1, error_2, error_3, error_4; 431| 13.0k| FLAC__bool order_0_is_valid = true, order_1_is_valid = true, order_2_is_valid = true, order_3_is_valid = true, order_4_is_valid = true; 432| 13.0k| uint32_t order = 0; 433| 13.0k| int i; 434| | 435| 3.55M| for(i = -4; i < (int)data_len; i++) { ------------------ | Branch (435:14): [True: 3.53M, False: 13.0k] ------------------ 436| 3.53M| error_0 = local_abs64(data[i]); ------------------ | | 53| 3.53M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 401k, False: 3.13M] | | ------------------ ------------------ 437| 3.53M| error_1 = (i > -4) ? local_abs64(data[i] - data[i-1]) : 0 ; ------------------ | | 53| 3.52M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 586k, False: 2.94M] | | ------------------ ------------------ | Branch (437:13): [True: 3.52M, False: 13.0k] ------------------ 438| 3.53M| error_2 = (i > -3) ? local_abs64(data[i] - 2 * data[i-1] + data[i-2]) : 0; ------------------ | | 53| 3.51M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 631k, False: 2.88M] | | ------------------ ------------------ | Branch (438:13): [True: 3.51M, False: 26.0k] ------------------ 439| 3.53M| error_3 = (i > -2) ? local_abs64(data[i] - 3 * data[i-1] + 3 * data[i-2] - data[i-3]) : 0; ------------------ | | 53| 3.50M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 606k, False: 2.89M] | | ------------------ ------------------ | Branch (439:13): [True: 3.50M, False: 39.1k] ------------------ 440| 3.53M| error_4 = (i > -1) ? local_abs64(data[i] - 4 * data[i-1] + 6 * data[i-2] - 4 * data[i-3] + data[i-4]) : 0; ------------------ | | 53| 3.48M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 583k, False: 2.90M] | | ------------------ ------------------ | Branch (440:13): [True: 3.48M, False: 52.1k] ------------------ 441| | 442| 3.53M| total_error_0 += error_0; 443| 3.53M| total_error_1 += error_1; 444| 3.53M| total_error_2 += error_2; 445| 3.53M| total_error_3 += error_3; 446| 3.53M| total_error_4 += error_4; 447| | 448| | /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */ 449| 3.53M| if(error_0 > INT32_MAX) ------------------ | Branch (449:6): [True: 84.6k, False: 3.45M] ------------------ 450| 84.6k| order_0_is_valid = false; 451| 3.53M| if(error_1 > INT32_MAX) ------------------ | Branch (451:6): [True: 96.1k, False: 3.44M] ------------------ 452| 96.1k| order_1_is_valid = false; 453| 3.53M| if(error_2 > INT32_MAX) ------------------ | Branch (453:6): [True: 346k, False: 3.19M] ------------------ 454| 346k| order_2_is_valid = false; 455| 3.53M| if(error_3 > INT32_MAX) ------------------ | Branch (455:6): [True: 559k, False: 2.97M] ------------------ 456| 559k| order_3_is_valid = false; 457| 3.53M| if(error_4 > INT32_MAX) ------------------ | Branch (457:6): [True: 749k, False: 2.79M] ------------------ 458| 749k| order_4_is_valid = false; 459| 3.53M| } 460| | 461| 13.0k| CHECK_ORDER_IS_VALID(0); ------------------ | | 356| 13.0k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 26.0k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 9.03k, False: 4.01k] | | | Branch (357:38): [True: 9.03k, False: 0] | | ------------------ | | 358| 9.03k| order = macro_order; \ | | 359| 9.03k| smallest_error = total_error_##macro_order ; \ | | 360| 9.03k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (360:52): [True: 9.03k, False: 0] | | ------------------ | | 361| 9.03k|} \ | | 362| 13.0k|else \ | | 363| 13.0k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 462| 13.0k| CHECK_ORDER_IS_VALID(1); ------------------ | | 356| 13.0k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 26.0k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 8.79k, False: 4.24k] | | | Branch (357:38): [True: 3.81k, False: 4.97k] | | ------------------ | | 358| 3.81k| order = macro_order; \ | | 359| 3.81k| smallest_error = total_error_##macro_order ; \ | | 360| 3.81k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (360:52): [True: 2.90k, False: 916] | | ------------------ | | 361| 3.81k|} \ | | 362| 13.0k|else \ | | 363| 13.0k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 463| 13.0k| CHECK_ORDER_IS_VALID(2); ------------------ | | 356| 13.0k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 26.0k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 6.17k, False: 6.87k] | | | Branch (357:38): [True: 1.39k, False: 4.77k] | | ------------------ | | 358| 1.39k| order = macro_order; \ | | 359| 1.39k| smallest_error = total_error_##macro_order ; \ | | 360| 1.39k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (360:52): [True: 1.39k, False: 0] | | ------------------ | | 361| 1.39k|} \ | | 362| 13.0k|else \ | | 363| 13.0k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 464| 13.0k| CHECK_ORDER_IS_VALID(3); ------------------ | | 356| 13.0k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 26.0k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 4.40k, False: 8.64k] | | | Branch (357:38): [True: 1.16k, False: 3.24k] | | ------------------ | | 358| 1.16k| order = macro_order; \ | | 359| 1.16k| smallest_error = total_error_##macro_order ; \ | | 360| 1.16k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (360:52): [True: 1.16k, False: 1] | | ------------------ | | 361| 1.16k|} \ | | 362| 13.0k|else \ | | 363| 13.0k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 465| 13.0k| CHECK_ORDER_IS_VALID(4); ------------------ | | 356| 13.0k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 26.0k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 3.95k, False: 9.09k] | | | Branch (357:38): [True: 960, False: 2.99k] | | ------------------ | | 358| 960| order = macro_order; \ | | 359| 960| smallest_error = total_error_##macro_order ; \ | | 360| 960| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (360:52): [True: 959, False: 1] | | ------------------ | | 361| 960|} \ | | 362| 13.0k|else \ | | 363| 13.0k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 466| | 467| 13.0k| return order; 468| 13.0k|} FLAC__fixed_compute_residual: 471| 463k|{ 472| 463k| const int idata_len = (int)data_len; 473| 463k| int i; 474| | 475| 463k| switch(order) { 476| 217k| case 0: ------------------ | Branch (476:3): [True: 217k, False: 245k] ------------------ 477| 217k| FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0])); ------------------ | | 38| 217k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 217k] | | ------------------ ------------------ 478| 217k| memcpy(residual, data, sizeof(residual[0])*data_len); 479| 217k| break; 480| 69.3k| case 1: ------------------ | Branch (480:3): [True: 69.3k, False: 393k] ------------------ 481| 6.89M| for(i = 0; i < idata_len; i++) ------------------ | Branch (481:15): [True: 6.82M, False: 69.3k] ------------------ 482| 6.82M| residual[i] = data[i] - data[i-1]; 483| 69.3k| break; 484| 60.9k| case 2: ------------------ | Branch (484:3): [True: 60.9k, False: 402k] ------------------ 485| 4.86M| for(i = 0; i < idata_len; i++) ------------------ | Branch (485:15): [True: 4.80M, False: 60.9k] ------------------ 486| 4.80M| residual[i] = data[i] - 2*data[i-1] + data[i-2]; 487| 60.9k| break; 488| 59.0k| case 3: ------------------ | Branch (488:3): [True: 59.0k, False: 403k] ------------------ 489| 4.76M| for(i = 0; i < idata_len; i++) ------------------ | Branch (489:15): [True: 4.70M, False: 59.0k] ------------------ 490| 4.70M| residual[i] = data[i] - 3*data[i-1] + 3*data[i-2] - data[i-3]; 491| 59.0k| break; 492| 56.7k| case 4: ------------------ | Branch (492:3): [True: 56.7k, False: 406k] ------------------ 493| 4.66M| for(i = 0; i < idata_len; i++) ------------------ | Branch (493:15): [True: 4.61M, False: 56.7k] ------------------ 494| 4.61M| residual[i] = data[i] - 4*data[i-1] + 6*data[i-2] - 4*data[i-3] + data[i-4]; 495| 56.7k| break; 496| 0| default: ------------------ | Branch (496:3): [True: 0, False: 463k] ------------------ 497| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 498| 463k| } 499| 463k|} FLAC__fixed_compute_residual_wide: 502| 314k|{ 503| 314k| const int idata_len = (int)data_len; 504| 314k| int i; 505| | 506| 314k| switch(order) { 507| 0| case 0: ------------------ | Branch (507:3): [True: 0, False: 314k] ------------------ 508| 0| FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0])); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 0] | | ------------------ ------------------ 509| 0| memcpy(residual, data, sizeof(residual[0])*data_len); 510| 0| break; 511| 133k| case 1: ------------------ | Branch (511:3): [True: 133k, False: 181k] ------------------ 512| 8.55M| for(i = 0; i < idata_len; i++) ------------------ | Branch (512:15): [True: 8.42M, False: 133k] ------------------ 513| 8.42M| residual[i] = (FLAC__int64)data[i] - data[i-1]; 514| 133k| break; 515| 72.1k| case 2: ------------------ | Branch (515:3): [True: 72.1k, False: 242k] ------------------ 516| 2.42M| for(i = 0; i < idata_len; i++) ------------------ | Branch (516:15): [True: 2.35M, False: 72.1k] ------------------ 517| 2.35M| residual[i] = (FLAC__int64)data[i] - 2*(FLAC__int64)data[i-1] + data[i-2]; 518| 72.1k| break; 519| 60.7k| case 3: ------------------ | Branch (519:3): [True: 60.7k, False: 253k] ------------------ 520| 1.86M| for(i = 0; i < idata_len; i++) ------------------ | Branch (520:15): [True: 1.80M, False: 60.7k] ------------------ 521| 1.80M| residual[i] = (FLAC__int64)data[i] - 3*(FLAC__int64)data[i-1] + 3*(FLAC__int64)data[i-2] - data[i-3]; 522| 60.7k| break; 523| 51.2k| case 4: ------------------ | Branch (523:3): [True: 51.2k, False: 263k] ------------------ 524| 1.06M| for(i = 0; i < idata_len; i++) ------------------ | Branch (524:15): [True: 1.01M, False: 51.2k] ------------------ 525| 1.01M| residual[i] = (FLAC__int64)data[i] - 4*(FLAC__int64)data[i-1] + 6*(FLAC__int64)data[i-2] - 4*(FLAC__int64)data[i-3] + data[i-4]; 526| 51.2k| break; 527| 0| default: ------------------ | Branch (527:3): [True: 0, False: 314k] ------------------ 528| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 529| 314k| } 530| 314k|} FLAC__fixed_compute_residual_wide_33bit: 533| 12.9k|{ 534| 12.9k| const int idata_len = (int)data_len; 535| 12.9k| int i; 536| | 537| 12.9k| switch(order) { 538| 7.19k| case 0: ------------------ | Branch (538:3): [True: 7.19k, False: 5.74k] ------------------ 539| 449k| for(i = 0; i < idata_len; i++) ------------------ | Branch (539:15): [True: 442k, False: 7.19k] ------------------ 540| 442k| residual[i] = data[i]; 541| 7.19k| break; 542| 2.46k| case 1: ------------------ | Branch (542:3): [True: 2.46k, False: 10.4k] ------------------ 543| 346k| for(i = 0; i < idata_len; i++) ------------------ | Branch (543:15): [True: 343k, False: 2.46k] ------------------ 544| 343k| residual[i] = data[i] - data[i-1]; 545| 2.46k| break; 546| 1.30k| case 2: ------------------ | Branch (546:3): [True: 1.30k, False: 11.6k] ------------------ 547| 207k| for(i = 0; i < idata_len; i++) ------------------ | Branch (547:15): [True: 206k, False: 1.30k] ------------------ 548| 206k| residual[i] = data[i] - 2*data[i-1] + data[i-2]; 549| 1.30k| break; 550| 1.02k| case 3: ------------------ | Branch (550:3): [True: 1.02k, False: 11.9k] ------------------ 551| 46.1k| for(i = 0; i < idata_len; i++) ------------------ | Branch (551:15): [True: 45.1k, False: 1.02k] ------------------ 552| 45.1k| residual[i] = data[i] - 3*data[i-1] + 3*data[i-2] - data[i-3]; 553| 1.02k| break; 554| 960| case 4: ------------------ | Branch (554:3): [True: 960, False: 11.9k] ------------------ 555| 18.8k| for(i = 0; i < idata_len; i++) ------------------ | Branch (555:15): [True: 17.8k, False: 960] ------------------ 556| 17.8k| residual[i] = data[i] - 4*data[i-1] + 6*data[i-2] - 4*data[i-3] + data[i-4]; 557| 960| break; 558| 0| default: ------------------ | Branch (558:3): [True: 0, False: 12.9k] ------------------ 559| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 560| 12.9k| } 561| 12.9k|} FLAC__fixed_restore_signal: 572| 71.6k|{ 573| 71.6k| int i, idata_len = (int)data_len; 574| | 575| 71.6k| switch(order) { 576| 47.8k| case 0: ------------------ | Branch (576:3): [True: 47.8k, False: 23.8k] ------------------ 577| 47.8k| FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0])); ------------------ | | 38| 47.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 47.8k] | | ------------------ ------------------ 578| 47.8k| memcpy(data, residual, sizeof(residual[0])*data_len); 579| 47.8k| break; 580| 19.9k| case 1: ------------------ | Branch (580:3): [True: 19.9k, False: 51.7k] ------------------ 581| 1.22M| for(i = 0; i < idata_len; i++) ------------------ | Branch (581:15): [True: 1.20M, False: 19.9k] ------------------ 582| 1.20M| data[i] = residual[i] + data[i-1]; 583| 19.9k| break; 584| 1.81k| case 2: ------------------ | Branch (584:3): [True: 1.81k, False: 69.8k] ------------------ 585| 45.3k| for(i = 0; i < idata_len; i++) ------------------ | Branch (585:15): [True: 43.5k, False: 1.81k] ------------------ 586| 43.5k| data[i] = residual[i] + 2*data[i-1] - data[i-2]; 587| 1.81k| break; 588| 328| case 3: ------------------ | Branch (588:3): [True: 328, False: 71.3k] ------------------ 589| 19.4k| for(i = 0; i < idata_len; i++) ------------------ | Branch (589:15): [True: 19.1k, False: 328] ------------------ 590| 19.1k| data[i] = residual[i] + 3*data[i-1] - 3*data[i-2] + data[i-3]; 591| 328| break; 592| 1.73k| case 4: ------------------ | Branch (592:3): [True: 1.73k, False: 69.9k] ------------------ 593| 33.7k| for(i = 0; i < idata_len; i++) ------------------ | Branch (593:15): [True: 32.0k, False: 1.73k] ------------------ 594| 32.0k| data[i] = residual[i] + 4*data[i-1] - 6*data[i-2] + 4*data[i-3] - data[i-4]; 595| 1.73k| break; 596| 0| default: ------------------ | Branch (596:3): [True: 0, False: 71.6k] ------------------ 597| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 598| 71.6k| } 599| 71.6k|} FLAC__fixed_restore_signal_wide: 602| 48.3k|{ 603| 48.3k| int i, idata_len = (int)data_len; 604| | 605| 48.3k| switch(order) { 606| 0| case 0: ------------------ | Branch (606:3): [True: 0, False: 48.3k] ------------------ 607| 0| FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0])); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 0] | | ------------------ ------------------ 608| 0| memcpy(data, residual, sizeof(residual[0])*data_len); 609| 0| break; 610| 46.5k| case 1: ------------------ | Branch (610:3): [True: 46.5k, False: 1.79k] ------------------ 611| 4.38M| for(i = 0; i < idata_len; i++) ------------------ | Branch (611:15): [True: 4.33M, False: 46.5k] ------------------ 612| 4.33M| data[i] = (FLAC__int64)residual[i] + (FLAC__int64)data[i-1]; 613| 46.5k| break; 614| 676| case 2: ------------------ | Branch (614:3): [True: 676, False: 47.6k] ------------------ 615| 35.6k| for(i = 0; i < idata_len; i++) ------------------ | Branch (615:15): [True: 35.0k, False: 676] ------------------ 616| 35.0k| data[i] = (FLAC__int64)residual[i] + 2*(FLAC__int64)data[i-1] - (FLAC__int64)data[i-2]; 617| 676| break; 618| 725| case 3: ------------------ | Branch (618:3): [True: 725, False: 47.6k] ------------------ 619| 469k| for(i = 0; i < idata_len; i++) ------------------ | Branch (619:15): [True: 469k, False: 725] ------------------ 620| 469k| data[i] = (FLAC__int64)residual[i] + 3*(FLAC__int64)data[i-1] - 3*(FLAC__int64)data[i-2] + (FLAC__int64)data[i-3]; 621| 725| break; 622| 392| case 4: ------------------ | Branch (622:3): [True: 392, False: 47.9k] ------------------ 623| 82.7k| for(i = 0; i < idata_len; i++) ------------------ | Branch (623:15): [True: 82.3k, False: 392] ------------------ 624| 82.3k| data[i] = (FLAC__int64)residual[i] + 4*(FLAC__int64)data[i-1] - 6*(FLAC__int64)data[i-2] + 4*(FLAC__int64)data[i-3] - (FLAC__int64)data[i-4]; 625| 392| break; 626| 0| default: ------------------ | Branch (626:3): [True: 0, False: 48.3k] ------------------ 627| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 628| 48.3k| } 629| 48.3k|} FLAC__fixed_restore_signal_wide_33bit: 640| 4.96k|{ 641| 4.96k| int i, idata_len = (int)data_len; 642| | 643| 4.96k| switch(order) { 644| 3.24k| case 0: ------------------ | Branch (644:3): [True: 3.24k, False: 1.71k] ------------------ 645| 117k| for(i = 0; i < idata_len; i++) ------------------ | Branch (645:15): [True: 114k, False: 3.24k] ------------------ 646| 114k| data[i] = residual[i]; 647| 3.24k| break; 648| 899| case 1: ------------------ | Branch (648:3): [True: 899, False: 4.06k] ------------------ 649| 59.2k| for(i = 0; i < idata_len; i++) ------------------ | Branch (649:15): [True: 58.3k, False: 899] ------------------ 650| 58.3k| data[i] = (FLAC__int64)residual[i] + data[i-1]; 651| 899| break; 652| 533| case 2: ------------------ | Branch (652:3): [True: 533, False: 4.43k] ------------------ 653| 121k| for(i = 0; i < idata_len; i++) ------------------ | Branch (653:15): [True: 121k, False: 533] ------------------ 654| 121k| data[i] = (FLAC__int64)residual[i] + 2*data[i-1] - data[i-2]; 655| 533| break; 656| 139| case 3: ------------------ | Branch (656:3): [True: 139, False: 4.82k] ------------------ 657| 32.7k| for(i = 0; i < idata_len; i++) ------------------ | Branch (657:15): [True: 32.6k, False: 139] ------------------ 658| 32.6k| data[i] = (FLAC__int64)residual[i] + 3*data[i-1] - 3*data[i-2] + data[i-3]; 659| 139| break; 660| 144| case 4: ------------------ | Branch (660:3): [True: 144, False: 4.81k] ------------------ 661| 8.86k| for(i = 0; i < idata_len; i++) ------------------ | Branch (661:15): [True: 8.72k, False: 144] ------------------ 662| 8.72k| data[i] = (FLAC__int64)residual[i] + 4*data[i-1] - 6*data[i-2] + 4*data[i-3] - data[i-4]; 663| 144| break; 664| 0| default: ------------------ | Branch (664:3): [True: 0, False: 4.96k] ------------------ 665| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 666| 4.96k| } 667| 4.96k|} FLAC__fixed_compute_best_predictor_wide_intrin_avx2: 58| 30.5k|{ 59| 30.5k| FLAC__uint64 total_error_0, total_error_1, total_error_2, total_error_3, total_error_4; 60| 30.5k| FLAC__int32 i, data_len_int; 61| 30.5k| uint32_t order; 62| 30.5k| __m256i total_err0, total_err1, total_err2, total_err3, total_err4; 63| 30.5k| __m256i prev_err0, prev_err1, prev_err2, prev_err3; 64| 30.5k| __m256i tempA, tempB, bitmask; 65| 30.5k| FLAC__int64 data_scalar[4]; 66| 30.5k| FLAC__int64 prev_err0_scalar[4]; 67| 30.5k| FLAC__int64 prev_err1_scalar[4]; 68| 30.5k| FLAC__int64 prev_err2_scalar[4]; 69| 30.5k| FLAC__int64 prev_err3_scalar[4]; 70| 30.5k| total_err0 = _mm256_setzero_si256(); 71| 30.5k| total_err1 = _mm256_setzero_si256(); 72| 30.5k| total_err2 = _mm256_setzero_si256(); 73| 30.5k| total_err3 = _mm256_setzero_si256(); 74| 30.5k| total_err4 = _mm256_setzero_si256(); 75| 30.5k| data_len_int = data_len; 76| | 77| 152k| for(i = 0; i < 4; i++){ ------------------ | Branch (77:13): [True: 122k, False: 30.5k] ------------------ 78| 122k| prev_err0_scalar[i] = data[-1+i*(data_len_int/4)]; 79| 122k| prev_err1_scalar[i] = data[-1+i*(data_len_int/4)] - data[-2+i*(data_len_int/4)]; 80| 122k| prev_err2_scalar[i] = prev_err1_scalar[i] - (data[-2+i*(data_len_int/4)] - data[-3+i*(data_len_int/4)]); 81| 122k| prev_err3_scalar[i] = prev_err2_scalar[i] - (data[-2+i*(data_len_int/4)] - 2*data[-3+i*(data_len_int/4)] + data[-4+i*(data_len_int/4)]); 82| 122k| } 83| 30.5k| prev_err0 = _mm256_loadu_si256((const __m256i*)(void*)prev_err0_scalar); 84| 30.5k| prev_err1 = _mm256_loadu_si256((const __m256i*)(void*)prev_err1_scalar); 85| 30.5k| prev_err2 = _mm256_loadu_si256((const __m256i*)(void*)prev_err2_scalar); 86| 30.5k| prev_err3 = _mm256_loadu_si256((const __m256i*)(void*)prev_err3_scalar); 87| 1.21M| for(i = 0; i < data_len_int / 4; i++){ ------------------ | Branch (87:13): [True: 1.18M, False: 30.5k] ------------------ 88| 1.18M| data_scalar[0] = data[i]; 89| 1.18M| data_scalar[1] = data[i+data_len/4]; 90| 1.18M| data_scalar[2] = data[i+2*data_len/4]; 91| 1.18M| data_scalar[3] = data[i+3*data_len/4]; 92| 1.18M| tempA = _mm256_loadu_si256((const __m256i*)(void*)data_scalar); 93| | /* Next three intrinsics calculate tempB as abs of tempA */ 94| 1.18M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 95| 1.18M| tempB = _mm256_xor_si256(tempA, bitmask); 96| 1.18M| tempB = _mm256_sub_epi64(tempB, bitmask); 97| 1.18M| total_err0 = _mm256_add_epi64(total_err0,tempB); 98| 1.18M| tempB = _mm256_sub_epi64(tempA,prev_err0); 99| 1.18M| prev_err0 = tempA; 100| | /* Next three intrinsics calculate tempA as abs of tempB */ 101| 1.18M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 102| 1.18M| tempA = _mm256_xor_si256(tempB, bitmask); 103| 1.18M| tempA = _mm256_sub_epi64(tempA, bitmask); 104| 1.18M| total_err1 = _mm256_add_epi64(total_err1,tempA); 105| 1.18M| tempA = _mm256_sub_epi64(tempB,prev_err1); 106| 1.18M| prev_err1 = tempB; 107| | /* Next three intrinsics calculate tempB as abs of tempA */ 108| 1.18M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 109| 1.18M| tempB = _mm256_xor_si256(tempA, bitmask); 110| 1.18M| tempB = _mm256_sub_epi64(tempB, bitmask); 111| 1.18M| total_err2 = _mm256_add_epi64(total_err2,tempB); 112| 1.18M| tempB = _mm256_sub_epi64(tempA,prev_err2); 113| 1.18M| prev_err2 = tempA; 114| | /* Next three intrinsics calculate tempA as abs of tempB */ 115| 1.18M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 116| 1.18M| tempA = _mm256_xor_si256(tempB, bitmask); 117| 1.18M| tempA = _mm256_sub_epi64(tempA, bitmask); 118| 1.18M| total_err3 = _mm256_add_epi64(total_err3,tempA); 119| 1.18M| tempA = _mm256_sub_epi64(tempB,prev_err3); 120| 1.18M| prev_err3 = tempB; 121| | /* Next three intrinsics calculate tempB as abs of tempA */ 122| 1.18M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 123| 1.18M| tempB = _mm256_xor_si256(tempA, bitmask); 124| 1.18M| tempB = _mm256_sub_epi64(tempB, bitmask); 125| 1.18M| total_err4 = _mm256_add_epi64(total_err4,tempB); 126| 1.18M| } 127| 30.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err0); 128| 30.5k| total_error_0 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 129| 30.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err1); 130| 30.5k| total_error_1 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 131| 30.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err2); 132| 30.5k| total_error_2 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 133| 30.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err3); 134| 30.5k| total_error_3 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 135| 30.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err4); 136| 30.5k| total_error_4 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 137| | 138| | /* Ignore the remainder, we're ignore the first few samples too */ 139| | 140| | /* prefer lower order */ 141| 30.5k| if(total_error_0 <= flac_min(flac_min(flac_min(total_error_1, total_error_2), total_error_3), total_error_4)) ------------------ | | 56| 30.5k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (141:5): [True: 9.48k, False: 21.0k] | Branch (141:22): [True: 22.8k, False: 7.71k] | Branch (141:22): [True: 22.7k, False: 1.45k] | Branch (141:22): [True: 24.1k, False: 6.40k] | Branch (141:22): [True: 22.8k, False: 2.55k] | Branch (141:22): [True: 22.7k, False: 1.42k] | Branch (141:22): [True: 24.1k, False: 1.26k] | Branch (141:22): [True: 25.3k, False: 5.18k] ------------------ 142| 9.48k| order = 0; 143| 21.0k| else if(total_error_1 <= flac_min(flac_min(total_error_2, total_error_3), total_error_4)) ------------------ | | 56| 21.0k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (143:10): [True: 19.7k, False: 1.36k] | Branch (143:27): [True: 15.8k, False: 5.23k] | Branch (143:27): [True: 15.8k, False: 1.63k] | Branch (143:27): [True: 17.4k, False: 3.64k] ------------------ 144| 19.7k| order = 1; 145| 1.36k| else if(total_error_2 <= flac_min(total_error_3, total_error_4)) ------------------ | | 56| 1.36k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (145:10): [True: 565, False: 804] | Branch (145:27): [True: 1.22k, False: 147] ------------------ 146| 565| order = 2; 147| 804| else if(total_error_3 <= total_error_4) ------------------ | Branch (147:10): [True: 658, False: 146] ------------------ 148| 658| order = 3; 149| 146| else 150| 146| order = 4; 151| | 152| | /* Estimate the expected number of bits per residual signal sample. */ 153| | /* 'total_error*' is linearly related to the variance of the residual */ 154| | /* signal, so we use it directly to compute E(|x|) */ 155| 30.5k| FLAC__ASSERT(data_len > 0 || total_error_0 == 0); ------------------ | | 38| 30.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 30.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 156| 30.5k| FLAC__ASSERT(data_len > 0 || total_error_1 == 0); ------------------ | | 38| 30.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 30.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 157| 30.5k| FLAC__ASSERT(data_len > 0 || total_error_2 == 0); ------------------ | | 38| 30.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 30.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 158| 30.5k| FLAC__ASSERT(data_len > 0 || total_error_3 == 0); ------------------ | | 38| 30.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 30.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 159| 30.5k| FLAC__ASSERT(data_len > 0 || total_error_4 == 0); ------------------ | | 38| 30.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 30.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 160| | 161| 30.5k| residual_bits_per_sample[0] = (float)((total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (161:40): [True: 28.6k, False: 1.90k] ------------------ 162| 30.5k| residual_bits_per_sample[1] = (float)((total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (162:40): [True: 24.6k, False: 5.98k] ------------------ 163| 30.5k| residual_bits_per_sample[2] = (float)((total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (163:40): [True: 24.9k, False: 5.62k] ------------------ 164| 30.5k| residual_bits_per_sample[3] = (float)((total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (164:40): [True: 25.5k, False: 5.02k] ------------------ 165| 30.5k| residual_bits_per_sample[4] = (float)((total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (165:40): [True: 26.0k, False: 4.51k] ------------------ 166| | 167| 30.5k| return order; 168| 30.5k|} FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2: 188| 292k|{ 189| 292k| FLAC__uint64 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0, smallest_error = UINT64_MAX; 190| 292k| FLAC__uint64 shadow_error_0 = 0, shadow_error_1 = 0, shadow_error_2 = 0, shadow_error_3 = 0, shadow_error_4 = 0; 191| 292k| FLAC__uint64 error_0, error_1, error_2, error_3, error_4; 192| 292k| FLAC__int32 i, data_len_int; 193| 292k| uint32_t order = 0; 194| 292k| __m256i total_err0, total_err1, total_err2, total_err3, total_err4; 195| 292k| __m256i shadow_err0, shadow_err1, shadow_err2, shadow_err3, shadow_err4; 196| 292k| __m256i prev_err0, prev_err1, prev_err2, prev_err3; 197| 292k| __m256i tempA, tempB, bitmask; 198| 292k| FLAC__int64 data_scalar[4]; 199| 292k| FLAC__int64 prev_err0_scalar[4]; 200| 292k| FLAC__int64 prev_err1_scalar[4]; 201| 292k| FLAC__int64 prev_err2_scalar[4]; 202| 292k| FLAC__int64 prev_err3_scalar[4]; 203| 292k| total_err0 = _mm256_setzero_si256(); 204| 292k| total_err1 = _mm256_setzero_si256(); 205| 292k| total_err2 = _mm256_setzero_si256(); 206| 292k| total_err3 = _mm256_setzero_si256(); 207| 292k| total_err4 = _mm256_setzero_si256(); 208| 292k| shadow_err0 = _mm256_setzero_si256(); 209| 292k| shadow_err1 = _mm256_setzero_si256(); 210| 292k| shadow_err2 = _mm256_setzero_si256(); 211| 292k| shadow_err3 = _mm256_setzero_si256(); 212| 292k| shadow_err4 = _mm256_setzero_si256(); 213| 292k| data_len_int = data_len; 214| | 215| | /* First take care of preceding samples */ 216| 1.46M| for(i = -4; i < 0; i++) { ------------------ | Branch (216:14): [True: 1.16M, False: 292k] ------------------ 217| 1.16M| error_0 = local_abs64((FLAC__int64)data[i]); ------------------ | | 173| 1.16M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 600k, False: 567k] | | ------------------ ------------------ 218| 1.16M| error_1 = (i > -4) ? local_abs64((FLAC__int64)data[i] - data[i-1]) : 0 ; ------------------ | | 173| 876k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 151k, False: 724k] | | ------------------ ------------------ | Branch (218:13): [True: 876k, False: 292k] ------------------ 219| 1.16M| error_2 = (i > -3) ? local_abs64((FLAC__int64)data[i] - 2 * (FLAC__int64)data[i-1] + data[i-2]) : 0; ------------------ | | 173| 584k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 114k, False: 469k] | | ------------------ ------------------ | Branch (219:13): [True: 584k, False: 584k] ------------------ 220| 1.16M| error_3 = (i > -2) ? local_abs64((FLAC__int64)data[i] - 3 * (FLAC__int64)data[i-1] + 3 * (FLAC__int64)data[i-2] - data[i-3]) : 0; ------------------ | | 173| 291k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 58.9k, False: 233k] | | ------------------ ------------------ | Branch (220:13): [True: 291k, False: 876k] ------------------ 221| | 222| 1.16M| total_error_0 += error_0; 223| 1.16M| total_error_1 += error_1; 224| 1.16M| total_error_2 += error_2; 225| 1.16M| total_error_3 += error_3; 226| | 227| 1.16M| shadow_error_0 |= error_0; 228| 1.16M| shadow_error_1 |= error_1; 229| 1.16M| shadow_error_2 |= error_2; 230| 1.16M| shadow_error_3 |= error_3; 231| 1.16M| } 232| | 233| 1.46M| for(i = 0; i < 4; i++){ ------------------ | Branch (233:13): [True: 1.16M, False: 292k] ------------------ 234| 1.16M| prev_err0_scalar[i] = data[-1+i*(data_len_int/4)]; 235| 1.16M| prev_err1_scalar[i] = (FLAC__int64)(data[-1+i*(data_len_int/4)]) - data[-2+i*(data_len_int/4)]; 236| 1.16M| prev_err2_scalar[i] = prev_err1_scalar[i] - ((FLAC__int64)(data[-2+i*(data_len_int/4)]) - data[-3+i*(data_len_int/4)]); 237| 1.16M| prev_err3_scalar[i] = prev_err2_scalar[i] - ((FLAC__int64)(data[-2+i*(data_len_int/4)]) - 2*(FLAC__int64)(data[-3+i*(data_len_int/4)]) + data[-4+i*(data_len_int/4)]); 238| 1.16M| } 239| 292k| prev_err0 = _mm256_loadu_si256((const __m256i*)(void*)prev_err0_scalar); 240| 292k| prev_err1 = _mm256_loadu_si256((const __m256i*)(void*)prev_err1_scalar); 241| 292k| prev_err2 = _mm256_loadu_si256((const __m256i*)(void*)prev_err2_scalar); 242| 292k| prev_err3 = _mm256_loadu_si256((const __m256i*)(void*)prev_err3_scalar); 243| 6.07M| for(i = 0; i < data_len_int / 4; i++){ ------------------ | Branch (243:13): [True: 5.78M, False: 292k] ------------------ 244| 5.78M| data_scalar[0] = data[i]; 245| 5.78M| data_scalar[1] = data[i+data_len/4]; 246| 5.78M| data_scalar[2] = data[i+2*data_len/4]; 247| 5.78M| data_scalar[3] = data[i+3*data_len/4]; 248| 5.78M| tempA = _mm256_loadu_si256((const __m256i*)(void*)data_scalar); 249| | /* Next three intrinsics calculate tempB as abs of tempA */ 250| 5.78M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 251| 5.78M| tempB = _mm256_xor_si256(tempA, bitmask); 252| 5.78M| tempB = _mm256_sub_epi64(tempB, bitmask); 253| 5.78M| total_err0 = _mm256_add_epi64(total_err0,tempB); 254| 5.78M| shadow_err0 = _mm256_or_si256(shadow_err0,tempB); 255| 5.78M| tempB = _mm256_sub_epi64(tempA,prev_err0); 256| 5.78M| prev_err0 = tempA; 257| | /* Next three intrinsics calculate tempA as abs of tempB */ 258| 5.78M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 259| 5.78M| tempA = _mm256_xor_si256(tempB, bitmask); 260| 5.78M| tempA = _mm256_sub_epi64(tempA, bitmask); 261| 5.78M| total_err1 = _mm256_add_epi64(total_err1,tempA); 262| 5.78M| shadow_err1 = _mm256_or_si256(shadow_err1,tempA); 263| 5.78M| tempA = _mm256_sub_epi64(tempB,prev_err1); 264| 5.78M| prev_err1 = tempB; 265| | /* Next three intrinsics calculate tempB as abs of tempA */ 266| 5.78M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 267| 5.78M| tempB = _mm256_xor_si256(tempA, bitmask); 268| 5.78M| tempB = _mm256_sub_epi64(tempB, bitmask); 269| 5.78M| total_err2 = _mm256_add_epi64(total_err2,tempB); 270| 5.78M| shadow_err2 = _mm256_or_si256(shadow_err2,tempB); 271| 5.78M| tempB = _mm256_sub_epi64(tempA,prev_err2); 272| 5.78M| prev_err2 = tempA; 273| | /* Next three intrinsics calculate tempA as abs of tempB */ 274| 5.78M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 275| 5.78M| tempA = _mm256_xor_si256(tempB, bitmask); 276| 5.78M| tempA = _mm256_sub_epi64(tempA, bitmask); 277| 5.78M| total_err3 = _mm256_add_epi64(total_err3,tempA); 278| 5.78M| shadow_err3 = _mm256_or_si256(shadow_err3,tempA); 279| 5.78M| tempA = _mm256_sub_epi64(tempB,prev_err3); 280| 5.78M| prev_err3 = tempB; 281| | /* Next three intrinsics calculate tempB as abs of tempA */ 282| 5.78M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 283| 5.78M| tempB = _mm256_xor_si256(tempA, bitmask); 284| 5.78M| tempB = _mm256_sub_epi64(tempB, bitmask); 285| 5.78M| total_err4 = _mm256_add_epi64(total_err4,tempB); 286| 5.78M| shadow_err4 = _mm256_or_si256(shadow_err4,tempB); 287| 5.78M| } 288| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err0); 289| 292k| total_error_0 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 290| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err1); 291| 292k| total_error_1 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 292| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err2); 293| 292k| total_error_2 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 294| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err3); 295| 292k| total_error_3 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 296| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err4); 297| 292k| total_error_4 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 298| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err0); 299| 292k| shadow_error_0 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 300| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err1); 301| 292k| shadow_error_1 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 302| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err2); 303| 292k| shadow_error_2 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 304| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err3); 305| 292k| shadow_error_3 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 306| 292k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err4); 307| 292k| shadow_error_4 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 308| | 309| | /* Take care of remaining sample */ 310| 383k| for(i = (data_len/4)*4; i < data_len_int; i++) { ------------------ | Branch (310:26): [True: 91.2k, False: 292k] ------------------ 311| 91.2k| error_0 = local_abs64((FLAC__int64)data[i]); ------------------ | | 173| 91.2k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 34.4k, False: 56.7k] | | ------------------ ------------------ 312| 91.2k| error_1 = local_abs64((FLAC__int64)data[i] - data[i-1]); ------------------ | | 173| 91.2k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 24.8k, False: 66.4k] | | ------------------ ------------------ 313| 91.2k| error_2 = local_abs64((FLAC__int64)data[i] - 2 * (FLAC__int64)data[i-1] + data[i-2]); ------------------ | | 173| 91.2k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 29.5k, False: 61.6k] | | ------------------ ------------------ 314| 91.2k| error_3 = local_abs64((FLAC__int64)data[i] - 3 * (FLAC__int64)data[i-1] + 3 * (FLAC__int64)data[i-2] - data[i-3]); ------------------ | | 173| 91.2k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 32.3k, False: 58.8k] | | ------------------ ------------------ 315| 91.2k| error_4 = local_abs64((FLAC__int64)data[i] - 4 * (FLAC__int64)data[i-1] + 6 * (FLAC__int64)data[i-2] - 4 * (FLAC__int64)data[i-3] + data[i-4]); ------------------ | | 173| 91.2k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 36.3k, False: 54.9k] | | ------------------ ------------------ 316| | 317| 91.2k| total_error_0 += error_0; 318| 91.2k| total_error_1 += error_1; 319| 91.2k| total_error_2 += error_2; 320| 91.2k| total_error_3 += error_3; 321| 91.2k| total_error_4 += error_4; 322| | 323| 91.2k| shadow_error_0 |= error_0; 324| 91.2k| shadow_error_1 |= error_1; 325| 91.2k| shadow_error_2 |= error_2; 326| 91.2k| shadow_error_3 |= error_3; 327| 91.2k| shadow_error_4 |= error_4; 328| 91.2k| } 329| | 330| | 331| 292k| CHECK_ORDER_IS_VALID(0); ------------------ | | 175| 292k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 292k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 291k, False: 1.07k] | | ------------------ | | 177| 291k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 291k, False: 18.4E] | | ------------------ | | 178| 291k| order = macro_order; \ | | 179| 291k| smallest_error = total_error_##macro_order ; \ | | 180| 291k| } \ | | 181| 291k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (181:52): [True: 289k, False: 1.88k] | | ------------------ | | 182| 291k|} \ | | 183| 292k|else \ | | 184| 292k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 332| 292k| CHECK_ORDER_IS_VALID(1); ------------------ | | 175| 292k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 292k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 235k, False: 56.5k] | | ------------------ | | 177| 235k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 196k, False: 38.7k] | | ------------------ | | 178| 196k| order = macro_order; \ | | 179| 196k| smallest_error = total_error_##macro_order ; \ | | 180| 196k| } \ | | 181| 235k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (181:52): [True: 97.3k, False: 138k] | | ------------------ | | 182| 235k|} \ | | 183| 292k|else \ | | 184| 292k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 333| 292k| CHECK_ORDER_IS_VALID(2); ------------------ | | 175| 292k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 292k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 212k, False: 79.9k] | | ------------------ | | 177| 212k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 1.70k, False: 210k] | | ------------------ | | 178| 1.70k| order = macro_order; \ | | 179| 1.70k| smallest_error = total_error_##macro_order ; \ | | 180| 1.70k| } \ | | 181| 212k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (181:52): [True: 74.0k, False: 138k] | | ------------------ | | 182| 212k|} \ | | 183| 292k|else \ | | 184| 292k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 334| 292k| CHECK_ORDER_IS_VALID(3); ------------------ | | 175| 292k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 292k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 194k, False: 97.2k] | | ------------------ | | 177| 194k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 1.90k, False: 192k] | | ------------------ | | 178| 1.90k| order = macro_order; \ | | 179| 1.90k| smallest_error = total_error_##macro_order ; \ | | 180| 1.90k| } \ | | 181| 194k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (181:52): [True: 56.8k, False: 138k] | | ------------------ | | 182| 194k|} \ | | 183| 292k|else \ | | 184| 292k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 335| 292k| CHECK_ORDER_IS_VALID(4); ------------------ | | 175| 292k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 292k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 180k, False: 111k] | | ------------------ | | 177| 180k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 1.28k, False: 179k] | | ------------------ | | 178| 1.28k| order = macro_order; \ | | 179| 1.28k| smallest_error = total_error_##macro_order ; \ | | 180| 1.28k| } \ | | 181| 180k| residual_bits_per_sample[ macro_order ] = (float)((total_error_##macro_order > 0) ? log(M_LN2 * (double)total_error_##macro_order / (double)data_len) / M_LN2 : 0.0); \ | | ------------------ | | | Branch (181:52): [True: 42.7k, False: 138k] | | ------------------ | | 182| 180k|} \ | | 183| 292k|else \ | | 184| 292k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 336| | 337| 292k| return order; 338| 292k|} FLAC__fixed_compute_best_predictor_intrin_ssse3: 64| 55.7k|{ 65| 55.7k| FLAC__uint32 total_error_0, total_error_1, total_error_2, total_error_3, total_error_4; 66| 55.7k| FLAC__int32 i, data_len_int; 67| 55.7k| uint32_t order; 68| 55.7k| __m128i total_err0, total_err1, total_err2, total_err3, total_err4; 69| 55.7k| __m128i prev_err0, prev_err1, prev_err2, prev_err3; 70| 55.7k| __m128i tempA, tempB; 71| 55.7k| FLAC__int32 data_scalar[4]; 72| 55.7k| FLAC__int32 prev_err0_scalar[4]; 73| 55.7k| FLAC__int32 prev_err1_scalar[4]; 74| 55.7k| FLAC__int32 prev_err2_scalar[4]; 75| 55.7k| FLAC__int32 prev_err3_scalar[4]; 76| 55.7k| total_err0 = _mm_setzero_si128(); 77| 55.7k| total_err1 = _mm_setzero_si128(); 78| 55.7k| total_err2 = _mm_setzero_si128(); 79| 55.7k| total_err3 = _mm_setzero_si128(); 80| 55.7k| total_err4 = _mm_setzero_si128(); 81| 55.7k| data_len_int = data_len; 82| | 83| 278k| for(i = 0; i < 4; i++){ ------------------ | Branch (83:13): [True: 222k, False: 55.7k] ------------------ 84| 222k| prev_err0_scalar[i] = data[-1+i*(data_len_int/4)]; 85| 222k| prev_err1_scalar[i] = data[-1+i*(data_len_int/4)] - data[-2+i*(data_len_int/4)]; 86| 222k| prev_err2_scalar[i] = prev_err1_scalar[i] - (data[-2+i*(data_len_int/4)] - data[-3+i*(data_len_int/4)]); 87| 222k| prev_err3_scalar[i] = prev_err2_scalar[i] - (data[-2+i*(data_len_int/4)] - 2*data[-3+i*(data_len_int/4)] + data[-4+i*(data_len_int/4)]); 88| 222k| } 89| 55.7k| prev_err0 = _mm_loadu_si128((const __m128i*)prev_err0_scalar); 90| 55.7k| prev_err1 = _mm_loadu_si128((const __m128i*)prev_err1_scalar); 91| 55.7k| prev_err2 = _mm_loadu_si128((const __m128i*)prev_err2_scalar); 92| 55.7k| prev_err3 = _mm_loadu_si128((const __m128i*)prev_err3_scalar); 93| 557k| for(i = 0; i < data_len_int / 4; i++){ ------------------ | Branch (93:13): [True: 501k, False: 55.7k] ------------------ 94| 501k| data_scalar[0] = data[i]; 95| 501k| data_scalar[1] = data[i+data_len/4]; 96| 501k| data_scalar[2] = data[i+2*(data_len/4)]; 97| 501k| data_scalar[3] = data[i+3*(data_len/4)]; 98| 501k| tempA = _mm_loadu_si128((const __m128i*)data_scalar); 99| 501k| tempB = _mm_abs_epi32(tempA); 100| 501k| total_err0 = _mm_add_epi32(total_err0,tempB); 101| 501k| tempB = _mm_sub_epi32(tempA,prev_err0); 102| 501k| prev_err0 = tempA; 103| 501k| tempA = _mm_abs_epi32(tempB); 104| 501k| total_err1 = _mm_add_epi32(total_err1,tempA); 105| 501k| tempA = _mm_sub_epi32(tempB,prev_err1); 106| 501k| prev_err1 = tempB; 107| 501k| tempB = _mm_abs_epi32(tempA); 108| 501k| total_err2 = _mm_add_epi32(total_err2,tempB); 109| 501k| tempB = _mm_sub_epi32(tempA,prev_err2); 110| 501k| prev_err2 = tempA; 111| 501k| tempA = _mm_abs_epi32(tempB); 112| 501k| total_err3 = _mm_add_epi32(total_err3,tempA); 113| 501k| tempA = _mm_sub_epi32(tempB,prev_err3); 114| 501k| prev_err3 = tempB; 115| 501k| tempB = _mm_abs_epi32(tempA); 116| 501k| total_err4 = _mm_add_epi32(total_err4,tempB); 117| 501k| } 118| 55.7k| _mm_storeu_si128((__m128i*)data_scalar,total_err0); 119| 55.7k| total_error_0 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 120| 55.7k| _mm_storeu_si128((__m128i*)data_scalar,total_err1); 121| 55.7k| total_error_1 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 122| 55.7k| _mm_storeu_si128((__m128i*)data_scalar,total_err2); 123| 55.7k| total_error_2 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 124| 55.7k| _mm_storeu_si128((__m128i*)data_scalar,total_err3); 125| 55.7k| total_error_3 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 126| 55.7k| _mm_storeu_si128((__m128i*)data_scalar,total_err4); 127| 55.7k| total_error_4 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 128| | 129| | /* Now the remainder of samples needs to be processed */ 130| 55.7k| i *= 4; 131| 55.7k| if(data_len % 4 > 0){ ------------------ | Branch (131:5): [True: 33.7k, False: 21.9k] ------------------ 132| 33.7k| FLAC__int32 last_error_0 = data[i-1]; 133| 33.7k| FLAC__int32 last_error_1 = data[i-1] - data[i-2]; 134| 33.7k| FLAC__int32 last_error_2 = last_error_1 - (data[i-2] - data[i-3]); 135| 33.7k| FLAC__int32 last_error_3 = last_error_2 - (data[i-2] - 2*data[i-3] + data[i-4]); 136| 33.7k| FLAC__int32 error, save; 137| 76.2k| for(; i < data_len_int; i++) { ------------------ | Branch (137:9): [True: 42.5k, False: 33.7k] ------------------ 138| 42.5k| error = data[i] ; total_error_0 += local_abs(error); save = error; ------------------ | | 60| 42.5k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 5.80k, False: 36.7k] | | ------------------ ------------------ 139| 42.5k| error -= last_error_0; total_error_1 += local_abs(error); last_error_0 = save; save = error; ------------------ | | 60| 42.5k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 9.67k, False: 32.8k] | | ------------------ ------------------ 140| 42.5k| error -= last_error_1; total_error_2 += local_abs(error); last_error_1 = save; save = error; ------------------ | | 60| 42.5k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 11.5k, False: 31.0k] | | ------------------ ------------------ 141| 42.5k| error -= last_error_2; total_error_3 += local_abs(error); last_error_2 = save; save = error; ------------------ | | 60| 42.5k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 12.5k, False: 29.9k] | | ------------------ ------------------ 142| 42.5k| error -= last_error_3; total_error_4 += local_abs(error); last_error_3 = save; ------------------ | | 60| 42.5k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 15.5k, False: 27.0k] | | ------------------ ------------------ 143| 42.5k| } 144| 33.7k| } 145| | 146| | /* prefer lower order */ 147| 55.7k| if(total_error_0 <= flac_min(flac_min(flac_min(total_error_1, total_error_2), total_error_3), total_error_4)) ------------------ | | 56| 55.7k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (147:5): [True: 12.7k, False: 42.9k] | Branch (147:22): [True: 33.0k, False: 22.6k] | Branch (147:22): [True: 32.5k, False: 3.68k] | Branch (147:22): [True: 36.2k, False: 19.4k] | Branch (147:22): [True: 32.7k, False: 5.38k] | Branch (147:22): [True: 32.3k, False: 3.64k] | Branch (147:22): [True: 35.9k, False: 2.18k] | Branch (147:22): [True: 38.1k, False: 17.5k] ------------------ 148| 12.7k| order = 0; 149| 42.9k| else if(total_error_1 <= flac_min(flac_min(total_error_2, total_error_3), total_error_4)) ------------------ | | 56| 42.9k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (149:10): [True: 40.6k, False: 2.39k] | Branch (149:27): [True: 24.7k, False: 18.2k] | Branch (149:27): [True: 24.5k, False: 2.74k] | Branch (149:27): [True: 27.2k, False: 15.7k] ------------------ 150| 40.6k| order = 1; 151| 2.39k| else if(total_error_2 <= flac_min(total_error_3, total_error_4)) ------------------ | | 56| 2.39k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (151:10): [True: 1.02k, False: 1.37k] | Branch (151:27): [True: 2.03k, False: 363] ------------------ 152| 1.02k| order = 2; 153| 1.37k| else if(total_error_3 <= total_error_4) ------------------ | Branch (153:10): [True: 1.01k, False: 360] ------------------ 154| 1.01k| order = 3; 155| 360| else 156| 360| order = 4; 157| | 158| | /* Estimate the expected number of bits per residual signal sample. */ 159| | /* 'total_error*' is linearly related to the variance of the residual */ 160| | /* signal, so we use it directly to compute E(|x|) */ 161| 55.7k| FLAC__ASSERT(data_len > 0 || total_error_0 == 0); ------------------ | | 38| 55.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 55.7k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 162| 55.7k| FLAC__ASSERT(data_len > 0 || total_error_1 == 0); ------------------ | | 38| 55.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 55.7k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 163| 55.7k| FLAC__ASSERT(data_len > 0 || total_error_2 == 0); ------------------ | | 38| 55.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 55.7k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 164| 55.7k| FLAC__ASSERT(data_len > 0 || total_error_3 == 0); ------------------ | | 38| 55.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 55.7k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 165| 55.7k| FLAC__ASSERT(data_len > 0 || total_error_4 == 0); ------------------ | | 38| 55.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 55.7k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 166| | 167| 55.7k| residual_bits_per_sample[0] = (float)((total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (167:40): [True: 53.3k, False: 2.40k] ------------------ 168| 55.7k| residual_bits_per_sample[1] = (float)((total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (168:40): [True: 37.0k, False: 18.6k] ------------------ 169| 55.7k| residual_bits_per_sample[2] = (float)((total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (169:40): [True: 37.7k, False: 18.0k] ------------------ 170| 55.7k| residual_bits_per_sample[3] = (float)((total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (170:40): [True: 38.5k, False: 17.1k] ------------------ 171| 55.7k| residual_bits_per_sample[4] = (float)((total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double)data_len) / M_LN2 : 0.0); ------------------ | Branch (171:40): [True: 39.2k, False: 16.4k] ------------------ 172| | 173| 55.7k| return order; 174| 55.7k|} FLAC__format_sample_rate_is_valid: 210| 261k|{ 211| 261k| if(sample_rate > FLAC__MAX_SAMPLE_RATE) { ------------------ | | 125| 261k|#define FLAC__MAX_SAMPLE_RATE (1048575u) ------------------ | Branch (211:5): [True: 47, False: 261k] ------------------ 212| 47| return false; 213| 47| } 214| 261k| else 215| 261k| return true; 216| 261k|} FLAC__format_blocksize_is_subset: 219| 668|{ 220| 668| if(blocksize > 16384) ------------------ | Branch (220:5): [True: 5, False: 663] ------------------ 221| 5| return false; 222| 663| else if(sample_rate <= 48000 && blocksize > 4608) ------------------ | Branch (222:10): [True: 298, False: 365] | Branch (222:34): [True: 9, False: 289] ------------------ 223| 9| return false; 224| 654| else 225| 654| return true; 226| 668|} FLAC__format_sample_rate_is_subset: 229| 654|{ 230| 654| if( // sample rate is not subset if 231| 654| !FLAC__format_sample_rate_is_valid(sample_rate) || // sample rate is invalid or ------------------ | Branch (231:3): [True: 0, False: 654] ------------------ 232| 654| sample_rate >= ((1u << 16) * 10) || // sample rate is larger then or equal to 655360 or ------------------ | Branch (232:3): [True: 22, False: 632] ------------------ 233| 632| (sample_rate >= (1u << 16) && sample_rate % 10 != 0) //sample rate is >= 65536 and not divisible by 10 ------------------ | Branch (233:4): [True: 253, False: 379] | Branch (233:33): [True: 23, False: 230] ------------------ 234| 654| ) { 235| 45| return false; 236| 45| } 237| 609| else 238| 609| return true; 239| 654|} FLAC__format_get_max_rice_partition_order_from_blocksize: 541| 244k|{ 542| 244k| uint32_t max_rice_partition_order = 0; 543| 1.08M| while(!(blocksize & 1)) { ------------------ | Branch (543:8): [True: 844k, False: 244k] ------------------ 544| 844k| max_rice_partition_order++; 545| 844k| blocksize >>= 1; 546| 844k| } 547| | return flac_min(FLAC__MAX_RICE_PARTITION_ORDER, max_rice_partition_order); ------------------ | | 56| 244k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (547:9): [True: 0, False: 244k] ------------------ 548| 244k|} FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order: 551| 17.9M|{ 552| 17.9M| uint32_t max_rice_partition_order = limit; 553| | 554| 26.4M| while(max_rice_partition_order > 0 && (blocksize >> max_rice_partition_order) <= predictor_order) ------------------ | Branch (554:8): [True: 10.9M, False: 15.4M] | Branch (554:40): [True: 8.47M, False: 2.52M] ------------------ 555| 8.47M| max_rice_partition_order--; 556| | 557| 17.9M| FLAC__ASSERT( ------------------ | | 38| 59.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 15.4M, False: 2.51M] | | | Branch (38:30): [True: 15.4M, False: 18.4E] | | | Branch (38:30): [True: 2.59M, False: 18.4E] | | | Branch (38:30): [True: 2.59M, False: 18.4E] | | ------------------ ------------------ 558| 17.9M| (max_rice_partition_order == 0 && blocksize >= predictor_order) || 559| 17.9M| (max_rice_partition_order > 0 && blocksize >> max_rice_partition_order > predictor_order) 560| 17.9M| ); 561| | 562| 17.9M| return max_rice_partition_order; 563| 17.9M|} FLAC__format_entropy_coding_method_partitioned_rice_contents_init: 566| 1.40M|{ 567| 1.40M| FLAC__ASSERT(0 != object); ------------------ | | 38| 1.40M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.40M] | | ------------------ ------------------ 568| | 569| 1.40M| object->parameters = 0; 570| 1.40M| object->raw_bits = 0; 571| 1.40M| object->capacity_by_order = 0; 572| 1.40M|} FLAC__format_entropy_coding_method_partitioned_rice_contents_clear: 575| 803k|{ 576| 803k| FLAC__ASSERT(0 != object); ------------------ | | 38| 803k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 803k] | | ------------------ ------------------ 577| | 578| 803k| if(0 != object->parameters) ------------------ | Branch (578:5): [True: 212k, False: 590k] ------------------ 579| 212k| free(object->parameters); 580| 803k| if(0 != object->raw_bits) ------------------ | Branch (580:5): [True: 212k, False: 590k] ------------------ 581| 212k| free(object->raw_bits); 582| 803k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(object); 583| 803k|} FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size: 591| 418k|{ 592| 418k| FLAC__ASSERT(0 != object); ------------------ | | 38| 418k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 418k] | | ------------------ ------------------ 593| | 594| 418k| if(object->capacity_by_order < max_partition_order || object->parameters == NULL || object->raw_bits == NULL) { ------------------ | Branch (594:5): [True: 138k, False: 280k] | Branch (594:56): [True: 74.4k, False: 205k] | Branch (594:86): [True: 0, False: 205k] ------------------ 595| 212k| if(0 == (object->parameters = safe_realloc_(object->parameters, sizeof(uint32_t)*(1 << max_partition_order)))) ------------------ | Branch (595:6): [True: 0, False: 212k] ------------------ 596| 0| return false; 597| 212k| if(0 == (object->raw_bits = safe_realloc_(object->raw_bits, sizeof(uint32_t)*(1 << max_partition_order)))) ------------------ | Branch (597:6): [True: 0, False: 212k] ------------------ 598| 0| return false; 599| 212k| memset(object->raw_bits, 0, sizeof(uint32_t)*(1 << max_partition_order)); 600| 212k| object->capacity_by_order = max_partition_order; 601| 212k| } 602| | 603| 418k| return true; 604| 418k|} stream_encoder.c:FLAC__bitmath_ilog2: 157| 25.6M|{ 158| 25.6M| FLAC__ASSERT(v > 0); ------------------ | | 38| 25.6M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 25.6M] | | ------------------ ------------------ 159| |#if defined(__INTEL_COMPILER) 160| | return _bit_scan_reverse(v); 161| |#elif defined(_MSC_VER) 162| | { 163| | unsigned long idx; 164| | _BitScanReverse(&idx, v); 165| | return idx; 166| | } 167| |#else 168| 25.6M| return FLAC__clz_uint32(v) ^ 31U; 169| 25.6M|#endif 170| 25.6M|} stream_encoder.c:FLAC__clz_uint32: 74| 25.6M|{ 75| |/* Never used with input 0 */ 76| 25.6M| FLAC__ASSERT(v > 0); ------------------ | | 38| 25.6M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 25.6M] | | ------------------ ------------------ 77| |#if defined(__INTEL_COMPILER) 78| | return _bit_scan_reverse(v) ^ 31U; 79| |#elif defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 80| |/* This will translate either to (bsr ^ 31U), clz , ctlz, cntlz, lzcnt depending on 81| | * -march= setting or to a software routine in exotic machines. */ 82| 25.6M| return __builtin_clz(v); 83| |#elif defined(_MSC_VER) 84| | { 85| | unsigned long idx; 86| | _BitScanReverse(&idx, v); 87| | return idx ^ 31U; 88| | } 89| |#else 90| | return FLAC__clz_soft_uint32(v); 91| |#endif 92| 25.6M|} stream_encoder.c:FLAC__bitmath_ilog2_wide: 173| 29.8M|{ 174| 29.8M| FLAC__ASSERT(v > 0); ------------------ | | 38| 29.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 29.8M] | | ------------------ ------------------ 175| 29.8M|#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 176| 29.8M| return __builtin_clzll(v) ^ 63U; 177| |/* Sorry, only supported in x64/Itanium.. and both have fast FPU which makes integer-only encoder pointless */ 178| |#elif (defined(__INTEL_COMPILER) || defined(_MSC_VER)) && (defined(_M_IA64) || defined(_M_X64)) 179| | { 180| | unsigned long idx; 181| | _BitScanReverse64(&idx, v); 182| | return idx; 183| | } 184| |#else 185| |/* Brain-damaged compilers will use the fastest possible way that is, 186| | de Bruijn sequences (http://supertech.csail.mit.edu/papers/debruijn.pdf) 187| | (C) Timothy B. Terriberry (tterribe@xiph.org) 2001-2009 CC0 (Public domain). 188| |*/ 189| | { 190| | static const uint8_t DEBRUIJN_IDX64[64]={ 191| | 0, 1, 2, 7, 3,13, 8,19, 4,25,14,28, 9,34,20,40, 192| | 5,17,26,38,15,46,29,48,10,31,35,54,21,50,41,57, 193| | 63, 6,12,18,24,27,33,39,16,37,45,47,30,53,49,56, 194| | 62,11,23,32,36,44,52,55,61,22,43,51,60,42,59,58 195| | }; 196| | v|= v>>1; 197| | v|= v>>2; 198| | v|= v>>4; 199| | v|= v>>8; 200| | v|= v>>16; 201| | v|= v>>32; 202| | v= (v>>1)+1; 203| | return DEBRUIJN_IDX64[v*FLAC__U64L(0x218A392CD3D5DBF)>>58&0x3F]; 204| | } 205| |#endif 206| 29.8M|} stream_encoder_intrin_avx2.c:FLAC__bitmath_ilog2: 157| 18.0M|{ 158| 18.0M| FLAC__ASSERT(v > 0); ------------------ | | 38| 18.0M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.0M] | | ------------------ ------------------ 159| |#if defined(__INTEL_COMPILER) 160| | return _bit_scan_reverse(v); 161| |#elif defined(_MSC_VER) 162| | { 163| | unsigned long idx; 164| | _BitScanReverse(&idx, v); 165| | return idx; 166| | } 167| |#else 168| 18.0M| return FLAC__clz_uint32(v) ^ 31U; 169| 18.0M|#endif 170| 18.0M|} stream_encoder_intrin_avx2.c:FLAC__clz_uint32: 74| 18.0M|{ 75| |/* Never used with input 0 */ 76| 18.0M| FLAC__ASSERT(v > 0); ------------------ | | 38| 18.0M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.0M] | | ------------------ ------------------ 77| |#if defined(__INTEL_COMPILER) 78| | return _bit_scan_reverse(v) ^ 31U; 79| |#elif defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 80| |/* This will translate either to (bsr ^ 31U), clz , ctlz, cntlz, lzcnt depending on 81| | * -march= setting or to a software routine in exotic machines. */ 82| 18.0M| return __builtin_clz(v); 83| |#elif defined(_MSC_VER) 84| | { 85| | unsigned long idx; 86| | _BitScanReverse(&idx, v); 87| | return idx ^ 31U; 88| | } 89| |#else 90| | return FLAC__clz_soft_uint32(v); 91| |#endif 92| 18.0M|} bitmath.c:FLAC__bitmath_ilog2_wide: 173| 26.2M|{ 174| 26.2M| FLAC__ASSERT(v > 0); ------------------ | | 38| 26.2M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 26.2M] | | ------------------ ------------------ 175| 26.2M|#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 176| 26.2M| return __builtin_clzll(v) ^ 63U; 177| |/* Sorry, only supported in x64/Itanium.. and both have fast FPU which makes integer-only encoder pointless */ 178| |#elif (defined(__INTEL_COMPILER) || defined(_MSC_VER)) && (defined(_M_IA64) || defined(_M_X64)) 179| | { 180| | unsigned long idx; 181| | _BitScanReverse64(&idx, v); 182| | return idx; 183| | } 184| |#else 185| |/* Brain-damaged compilers will use the fastest possible way that is, 186| | de Bruijn sequences (http://supertech.csail.mit.edu/papers/debruijn.pdf) 187| | (C) Timothy B. Terriberry (tterribe@xiph.org) 2001-2009 CC0 (Public domain). 188| |*/ 189| | { 190| | static const uint8_t DEBRUIJN_IDX64[64]={ 191| | 0, 1, 2, 7, 3,13, 8,19, 4,25,14,28, 9,34,20,40, 192| | 5,17,26,38,15,46,29,48,10,31,35,54,21,50,41,57, 193| | 63, 6,12,18,24,27,33,39,16,37,45,47,30,53,49,56, 194| | 62,11,23,32,36,44,52,55,61,22,43,51,60,42,59,58 195| | }; 196| | v|= v>>1; 197| | v|= v>>2; 198| | v|= v>>4; 199| | v|= v>>8; 200| | v|= v>>16; 201| | v|= v>>32; 202| | v= (v>>1)+1; 203| | return DEBRUIJN_IDX64[v*FLAC__U64L(0x218A392CD3D5DBF)>>58&0x3F]; 204| | } 205| |#endif 206| 26.2M|} bitreader.c:FLAC__clz_uint64: 102| 21.2M|{ 103| | /* Never used with input 0 */ 104| 21.2M| FLAC__ASSERT(v > 0); ------------------ | | 38| 21.2M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.2M] | | ------------------ ------------------ 105| 21.2M|#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 106| 21.2M| return __builtin_clzll(v); 107| |#elif (defined(__INTEL_COMPILER) || defined(_MSC_VER)) && (defined(_M_IA64) || defined(_M_X64)) 108| | { 109| | unsigned long idx; 110| | _BitScanReverse64(&idx, v); 111| | return idx ^ 63U; 112| | } 113| |#else 114| | return FLAC__clz_soft_uint64(v); 115| |#endif 116| 21.2M|} bitreader.c:FLAC__clz2_uint64: 127| 18.4M|{ 128| 18.4M| if (!v) ------------------ | Branch (128:6): [True: 647k, False: 17.8M] ------------------ 129| 647k| return 64; 130| 17.8M| return FLAC__clz_uint64(v); 131| 18.4M|} FLAC__lpc_window_data: 69| 237k|{ 70| 237k| uint32_t i; 71| 27.0M| for(i = 0; i < data_len; i++) ------------------ | Branch (71:13): [True: 26.8M, False: 237k] ------------------ 72| 26.8M| out[i] = in[i] * window[i]; 73| 237k|} FLAC__lpc_window_data_wide: 76| 14.4k|{ 77| 14.4k| uint32_t i; 78| 3.33M| for(i = 0; i < data_len; i++) ------------------ | Branch (78:13): [True: 3.32M, False: 14.4k] ------------------ 79| 3.32M| out[i] = in[i] * window[i]; 80| 14.4k|} FLAC__lpc_window_data_partial: 83| 47.3k|{ 84| 47.3k| uint32_t i, j; 85| 47.3k| if((part_size + data_shift) < data_len){ ------------------ | Branch (85:5): [True: 47.3k, False: 0] ------------------ 86| 1.47M| for(i = 0; i < part_size; i++) ------------------ | Branch (86:14): [True: 1.42M, False: 47.3k] ------------------ 87| 1.42M| out[i] = in[data_shift+i] * window[i]; 88| 47.3k| i = flac_min(i,data_len - part_size - data_shift); ------------------ | | 56| 47.3k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (88:7): [True: 45.0k, False: 2.25k] ------------------ 89| 1.47M| for(j = data_len - part_size; j < data_len; i++, j++) ------------------ | Branch (89:33): [True: 1.42M, False: 47.3k] ------------------ 90| 1.42M| out[i] = in[data_shift+i] * window[j]; 91| 47.3k| if(i < data_len) ------------------ | Branch (91:6): [True: 47.3k, False: 0] ------------------ 92| 47.3k| out[i] = 0.0f; 93| 47.3k| } 94| 47.3k|} FLAC__lpc_window_data_partial_wide: 97| 3.20k|{ 98| 3.20k| uint32_t i, j; 99| 3.20k| if((part_size + data_shift) < data_len){ ------------------ | Branch (99:5): [True: 3.20k, False: 0] ------------------ 100| 94.4k| for(i = 0; i < part_size; i++) ------------------ | Branch (100:14): [True: 91.2k, False: 3.20k] ------------------ 101| 91.2k| out[i] = in[data_shift+i] * window[i]; 102| 3.20k| i = flac_min(i,data_len - part_size - data_shift); ------------------ | | 56| 3.20k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (102:7): [True: 2.70k, False: 508] ------------------ 103| 94.4k| for(j = data_len - part_size; j < data_len; i++, j++) ------------------ | Branch (103:33): [True: 91.2k, False: 3.20k] ------------------ 104| 91.2k| out[i] = in[data_shift+i] * window[j]; 105| 3.20k| if(i < data_len) ------------------ | Branch (105:6): [True: 3.20k, False: 0] ------------------ 106| 3.20k| out[i] = 0.0f; 107| 3.20k| } 108| 3.20k|} FLAC__lpc_compute_autocorrelation: 111| 250k|{ 112| | /* a readable, but slower, version */ 113| |#if 0 114| | double d; 115| | uint32_t i; 116| | 117| | FLAC__ASSERT(lag > 0); 118| | FLAC__ASSERT(lag <= data_len); 119| | 120| | /* 121| | * Technically we should subtract the mean first like so: 122| | * for(i = 0; i < data_len; i++) 123| | * data[i] -= mean; 124| | * but it appears not to make enough of a difference to matter, and 125| | * most signals are already closely centered around zero 126| | */ 127| | while(lag--) { 128| | for(i = lag, d = 0.0; i < data_len; i++) 129| | d += data[i] * (double)data[i - lag]; 130| | autoc[lag] = d; 131| | } 132| |#endif 133| 250k| if (data_len < FLAC__MAX_LPC_ORDER || lag > 16) { ------------------ | | 128| 501k|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (133:6): [True: 223k, False: 26.8k] | Branch (133:40): [True: 14.2k, False: 12.6k] ------------------ 134| | /* 135| | * this version tends to run faster because of better data locality 136| | * ('data_len' is usually much larger than 'lag') 137| | */ 138| 237k| double d; 139| 237k| uint32_t sample, coeff; 140| 237k| const uint32_t limit = data_len - lag; 141| | 142| 237k| FLAC__ASSERT(lag > 0); ------------------ | | 38| 237k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 237k] | | ------------------ ------------------ 143| 237k| FLAC__ASSERT(lag <= data_len); ------------------ | | 38| 237k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 237k] | | ------------------ ------------------ 144| | 145| 3.35M| for(coeff = 0; coeff < lag; coeff++) ------------------ | Branch (145:18): [True: 3.12M, False: 237k] ------------------ 146| 3.12M| autoc[coeff] = 0.0; 147| 13.0M| for(sample = 0; sample <= limit; sample++) { ------------------ | Branch (147:19): [True: 12.8M, False: 237k] ------------------ 148| 12.8M| d = data[sample]; 149| 393M| for(coeff = 0; coeff < lag; coeff++) ------------------ | Branch (149:19): [True: 380M, False: 12.8M] ------------------ 150| 380M| autoc[coeff] += d * data[sample+coeff]; 151| 12.8M| } 152| 3.12M| for(; sample < data_len; sample++) { ------------------ | Branch (152:9): [True: 2.88M, False: 237k] ------------------ 153| 2.88M| d = data[sample]; 154| 25.9M| for(coeff = 0; coeff < data_len - sample; coeff++) ------------------ | Branch (154:19): [True: 23.0M, False: 2.88M] ------------------ 155| 23.0M| autoc[coeff] += d * data[sample+coeff]; 156| 2.88M| } 157| 237k| } 158| 12.6k| else if(lag <= 8) { ------------------ | Branch (158:10): [True: 826, False: 11.7k] ------------------ 159| 826| #undef MAX_LAG 160| 826| #define MAX_LAG 8 161| 826| #include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 826| int i, j; | | 2| 826| (void) lag; | | 3| 826| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 826|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 826] | | | | ------------------ | | ------------------ | | 4| | | | 5| 7.43k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 160| 7.43k| #define MAX_LAG 8 | | ------------------ | | | Branch (5:20): [True: 6.60k, False: 826] | | ------------------ | | 6| 6.60k| autoc[i] = 0.0; | | 7| | | | 8| 7.43k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 160| 7.43k| #define MAX_LAG 8 | | ------------------ | | | Branch (8:20): [True: 6.60k, False: 826] | | ------------------ | | 9| 36.3k| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 29.7k, False: 6.60k] | | ------------------ | | 10| 29.7k| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 20.6k| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 160| 826| #define MAX_LAG 8 | | ------------------ | | | Branch (12:26): [True: 19.8k, False: 826] | | ------------------ | | 13| 178k| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 160| 178k| #define MAX_LAG 8 | | ------------------ | | | Branch (13:14): [True: 158k, False: 19.8k] | | ------------------ | | 14| 158k| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 162| 826| } 163| 11.7k| else if(lag <= 12) { ------------------ | Branch (163:10): [True: 5.91k, False: 5.86k] ------------------ 164| 5.91k| #undef MAX_LAG 165| 5.91k| #define MAX_LAG 12 166| 5.91k| #include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 5.91k| int i, j; | | 2| 5.91k| (void) lag; | | 3| 5.91k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 5.91k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 5.91k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 76.8k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 165| 76.8k| #define MAX_LAG 12 | | ------------------ | | | Branch (5:20): [True: 70.9k, False: 5.91k] | | ------------------ | | 6| 70.9k| autoc[i] = 0.0; | | 7| | | | 8| 76.7k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 165| 76.7k| #define MAX_LAG 12 | | ------------------ | | | Branch (8:20): [True: 70.8k, False: 5.91k] | | ------------------ | | 9| 530k| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 459k, False: 70.8k] | | ------------------ | | 10| 459k| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 123k| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 165| 5.91k| #define MAX_LAG 12 | | ------------------ | | | Branch (12:26): [True: 117k, False: 5.91k] | | ------------------ | | 13| 1.52M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 165| 1.52M| #define MAX_LAG 12 | | ------------------ | | | Branch (13:14): [True: 1.40M, False: 117k] | | ------------------ | | 14| 1.40M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 167| 5.91k| } 168| 5.86k| else if(lag <= 16) { ------------------ | Branch (168:10): [True: 5.84k, False: 25] ------------------ 169| 5.84k| #undef MAX_LAG 170| 5.84k| #define MAX_LAG 16 171| 5.84k| #include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 5.84k| int i, j; | | 2| 5.84k| (void) lag; | | 3| 5.84k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 5.84k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 5.84k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 99.0k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 170| 99.0k| #define MAX_LAG 16 | | ------------------ | | | Branch (5:20): [True: 93.1k, False: 5.84k] | | ------------------ | | 6| 93.1k| autoc[i] = 0.0; | | 7| | | | 8| 96.1k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 170| 96.1k| #define MAX_LAG 16 | | ------------------ | | | Branch (8:20): [True: 90.2k, False: 5.84k] | | ------------------ | | 9| 845k| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 755k, False: 90.2k] | | ------------------ | | 10| 755k| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 80.6k| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 170| 5.84k| #define MAX_LAG 16 | | ------------------ | | | Branch (12:26): [True: 74.8k, False: 5.84k] | | ------------------ | | 13| 1.26M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 170| 1.26M| #define MAX_LAG 16 | | ------------------ | | | Branch (13:14): [True: 1.18M, False: 74.8k] | | ------------------ | | 14| 1.18M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 172| 5.84k| } 173| | 174| 250k|} FLAC__lpc_compute_lp_coefficients: 177| 344k|{ 178| 344k| uint32_t i, j; 179| 344k| double r, err, lpc[FLAC__MAX_LPC_ORDER]; 180| | 181| 344k| FLAC__ASSERT(0 != max_order); ------------------ | | 38| 344k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 344k] | | ------------------ ------------------ 182| 344k| FLAC__ASSERT(0 < *max_order); ------------------ | | 38| 344k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 344k] | | ------------------ ------------------ 183| 344k| FLAC__ASSERT(*max_order <= FLAC__MAX_LPC_ORDER); ------------------ | | 38| 344k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 344k] | | ------------------ ------------------ 184| 344k| FLAC__ASSERT(autoc[0] != 0.0); ------------------ | | 38| 344k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 344k] | | ------------------ ------------------ 185| | 186| 344k| err = autoc[0]; 187| | 188| 4.38M| for(i = 0; i < *max_order; i++) { ------------------ | Branch (188:13): [True: 4.04M, False: 344k] ------------------ 189| | /* Sum up this iteration's reflection coefficient. */ 190| 4.04M| r = -autoc[i+1]; 191| 30.9M| for(j = 0; j < i; j++) ------------------ | Branch (191:14): [True: 26.8M, False: 4.04M] ------------------ 192| 26.8M| r -= lpc[j] * autoc[i-j]; 193| 4.04M| r /= err; 194| | 195| | /* Update LPC coefficients and total error. */ 196| 4.04M| lpc[i]=r; 197| 16.4M| for(j = 0; j < (i>>1); j++) { ------------------ | Branch (197:14): [True: 12.4M, False: 4.04M] ------------------ 198| 12.4M| double tmp = lpc[j]; 199| 12.4M| lpc[j] += r * lpc[i-1-j]; 200| 12.4M| lpc[i-1-j] += r * tmp; 201| 12.4M| } 202| 4.04M| if(i & 1) ------------------ | Branch (202:6): [True: 1.97M, False: 2.06M] ------------------ 203| 1.97M| lpc[j] += lpc[j] * r; 204| | 205| 4.04M| err *= (1.0 - r * r); 206| | 207| | /* save this order */ 208| 34.9M| for(j = 0; j <= i; j++) ------------------ | Branch (208:14): [True: 30.9M, False: 4.04M] ------------------ 209| 30.9M| lp_coeff[i][j] = (FLAC__real)(-lpc[j]); /* negate FIR filter coeff to get predictor coeff */ 210| 4.04M| error[i] = err; 211| | 212| | /* see SF bug https://sourceforge.net/p/flac/bugs/234/ */ 213| 4.04M| if(err == 0.0) { ------------------ | Branch (213:6): [True: 222, False: 4.03M] ------------------ 214| 222| *max_order = i+1; 215| 222| return; 216| 222| } 217| 4.04M| } 218| 344k|} FLAC__lpc_quantize_coefficients: 221| 20.3M|{ 222| 20.3M| uint32_t i; 223| 20.3M| double cmax; 224| 20.3M| FLAC__int32 qmax, qmin; 225| | 226| 20.3M| FLAC__ASSERT(precision > 0); ------------------ | | 38| 20.3M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.3M] | | ------------------ ------------------ 227| 20.3M| FLAC__ASSERT(precision >= FLAC__MIN_QLP_COEFF_PRECISION); ------------------ | | 38| 20.3M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.3M] | | ------------------ ------------------ 228| | 229| | /* drop one bit for the sign; from here on out we consider only |lp_coeff[i]| */ 230| 20.3M| precision--; 231| 20.3M| qmax = 1 << precision; 232| 20.3M| qmin = -qmax; 233| 20.3M| qmax--; 234| | 235| | /* calc cmax = max( |lp_coeff[i]| ) */ 236| 20.3M| cmax = 0.0; 237| 186M| for(i = 0; i < order; i++) { ------------------ | Branch (237:13): [True: 166M, False: 20.3M] ------------------ 238| 166M| const double d = fabs(lp_coeff[i]); 239| 166M| if(d > cmax) ------------------ | Branch (239:6): [True: 31.4M, False: 134M] ------------------ 240| 31.4M| cmax = d; 241| 166M| } 242| | 243| 20.3M| if(cmax <= 0.0) { ------------------ | Branch (243:5): [True: 799k, False: 19.5M] ------------------ 244| | /* => coefficients are all 0, which means our constant-detect didn't work */ 245| 799k| return 2; 246| 799k| } 247| 19.5M| else { 248| 19.5M| const int max_shiftlimit = (1 << (FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN-1)) - 1; 249| 19.5M| const int min_shiftlimit = -max_shiftlimit - 1; 250| 19.5M| int log2cmax; 251| | 252| 19.5M| (void)frexp(cmax, &log2cmax); 253| 19.5M| log2cmax--; 254| 19.5M| *shift = (int)precision - log2cmax - 1; 255| | 256| 19.5M| if(*shift > max_shiftlimit) ------------------ | Branch (256:6): [True: 2.08M, False: 17.4M] ------------------ 257| 2.08M| *shift = max_shiftlimit; 258| 17.4M| else if(*shift < min_shiftlimit) ------------------ | Branch (258:11): [True: 2.17k, False: 17.4M] ------------------ 259| 2.17k| return 1; 260| 19.5M| } 261| | 262| 19.5M| if(*shift >= 0) { ------------------ | Branch (262:5): [True: 19.5M, False: 18.4E] ------------------ 263| 19.5M| double error = 0.0; 264| 19.5M| FLAC__int32 q; 265| 181M| for(i = 0; i < order; i++) { ------------------ | Branch (265:14): [True: 162M, False: 19.5M] ------------------ 266| 162M| error += lp_coeff[i] * (1 << *shift); 267| 162M| q = lround(error); 268| | 269| |#ifdef FLAC__OVERFLOW_DETECT 270| | if(q > qmax+1) /* we expect q==qmax+1 occasionally due to rounding */ 271| | flac_fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q>qmax %d>%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmax,*shift,cmax,precision+1,i,lp_coeff[i]); 272| | else if(q < qmin) 273| | flac_fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q qmax) ------------------ | Branch (275:7): [True: 227k, False: 161M] ------------------ 276| 227k| q = qmax; 277| 161M| else if(q < qmin) ------------------ | Branch (277:12): [True: 0, False: 161M] ------------------ 278| 0| q = qmin; 279| 162M| error -= q; 280| 162M| qlp_coeff[i] = q; 281| 162M| } 282| 19.5M| } 283| | /* negative shift is very rare but due to design flaw, negative shift is 284| | * not allowed in the decoder, so it must be handled specially by scaling 285| | * down coeffs 286| | */ 287| 18.4E| else { 288| 18.4E| const int nshift = -(*shift); 289| 18.4E| double error = 0.0; 290| 18.4E| FLAC__int32 q; 291| |#ifndef NDEBUG 292| | flac_fprintf(stderr,"FLAC__lpc_quantize_coefficients: negative shift=%d order=%u cmax=%f\n", *shift, order, cmax); 293| |#endif 294| 18.4E| for(i = 0; i < order; i++) { ------------------ | Branch (294:14): [True: 146k, False: 18.4E] ------------------ 295| 146k| error += lp_coeff[i] / (1 << nshift); 296| 146k| q = lround(error); 297| |#ifdef FLAC__OVERFLOW_DETECT 298| | if(q > qmax+1) /* we expect q==qmax+1 occasionally due to rounding */ 299| | flac_fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q>qmax %d>%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmax,*shift,cmax,precision+1,i,lp_coeff[i]); 300| | else if(q < qmin) 301| | flac_fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q qmax) ------------------ | Branch (303:7): [True: 272, False: 146k] ------------------ 304| 272| q = qmax; 305| 146k| else if(q < qmin) ------------------ | Branch (305:12): [True: 0, False: 146k] ------------------ 306| 0| q = qmin; 307| 146k| error -= q; 308| 146k| qlp_coeff[i] = q; 309| 146k| } 310| 18.4E| *shift = 0; 311| 18.4E| } 312| | 313| 19.5M| return 0; 314| 20.3M|} FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual: 833| 11.8M|{ 834| 11.8M| int i; 835| 11.8M| FLAC__int64 sum, residual_to_check; 836| | 837| 11.8M| FLAC__ASSERT(order > 0); ------------------ | | 38| 11.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.8M] | | ------------------ ------------------ 838| 11.8M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 11.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.8M] | | ------------------ ------------------ 839| | 840| 1.61G| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (840:13): [True: 1.60G, False: 10.5M] ------------------ 841| 1.60G| sum = 0; 842| 1.60G| switch(order) { ------------------ | Branch (842:10): [True: 1.61G, False: 18.4E] ------------------ 843| 22.1M| case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */ ------------------ | Branch (843:4): [True: 22.1M, False: 1.58G] ------------------ 844| 44.7M| case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */ ------------------ | Branch (844:4): [True: 22.5M, False: 1.58G] ------------------ 845| 67.9M| case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */ ------------------ | Branch (845:4): [True: 23.2M, False: 1.58G] ------------------ 846| 91.5M| case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */ ------------------ | Branch (846:4): [True: 23.6M, False: 1.58G] ------------------ 847| 115M| case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */ ------------------ | Branch (847:4): [True: 23.5M, False: 1.58G] ------------------ 848| 138M| case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */ ------------------ | Branch (848:4): [True: 23.4M, False: 1.58G] ------------------ 849| 162M| case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */ ------------------ | Branch (849:4): [True: 23.5M, False: 1.58G] ------------------ 850| 185M| case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */ ------------------ | Branch (850:4): [True: 23.5M, False: 1.58G] ------------------ 851| 209M| case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */ ------------------ | Branch (851:4): [True: 23.6M, False: 1.58G] ------------------ 852| 233M| case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */ ------------------ | Branch (852:4): [True: 23.7M, False: 1.58G] ------------------ 853| 256M| case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */ ------------------ | Branch (853:4): [True: 23.7M, False: 1.58G] ------------------ 854| 280M| case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */ ------------------ | Branch (854:4): [True: 23.9M, False: 1.58G] ------------------ 855| 305M| case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */ ------------------ | Branch (855:4): [True: 24.2M, False: 1.58G] ------------------ 856| 329M| case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */ ------------------ | Branch (856:4): [True: 24.2M, False: 1.58G] ------------------ 857| 353M| case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */ ------------------ | Branch (857:4): [True: 24.3M, False: 1.58G] ------------------ 858| 387M| case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */ ------------------ | Branch (858:4): [True: 33.8M, False: 1.57G] ------------------ 859| 434M| case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */ ------------------ | Branch (859:4): [True: 46.6M, False: 1.56G] ------------------ 860| 481M| case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */ ------------------ | Branch (860:4): [True: 46.8M, False: 1.56G] ------------------ 861| 541M| case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */ ------------------ | Branch (861:4): [True: 60.3M, False: 1.54G] ------------------ 862| 604M| case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13]; /* Falls through. */ ------------------ | Branch (862:4): [True: 63.2M, False: 1.54G] ------------------ 863| 666M| case 12: sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; /* Falls through. */ ------------------ | Branch (863:4): [True: 61.8M, False: 1.54G] ------------------ 864| 730M| case 11: sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; /* Falls through. */ ------------------ | Branch (864:4): [True: 63.9M, False: 1.54G] ------------------ 865| 792M| case 10: sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; /* Falls through. */ ------------------ | Branch (865:4): [True: 62.0M, False: 1.54G] ------------------ 866| 854M| case 9: sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; /* Falls through. */ ------------------ | Branch (866:4): [True: 62.1M, False: 1.54G] ------------------ 867| 927M| case 8: sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; /* Falls through. */ ------------------ | Branch (867:4): [True: 72.8M, False: 1.53G] ------------------ 868| 1.02G| case 7: sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; /* Falls through. */ ------------------ | Branch (868:4): [True: 92.9M, False: 1.51G] ------------------ 869| 1.11G| case 6: sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; /* Falls through. */ ------------------ | Branch (869:4): [True: 94.5M, False: 1.51G] ------------------ 870| 1.21G| case 5: sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; /* Falls through. */ ------------------ | Branch (870:4): [True: 99.3M, False: 1.50G] ------------------ 871| 1.30G| case 4: sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; /* Falls through. */ ------------------ | Branch (871:4): [True: 91.5M, False: 1.51G] ------------------ 872| 1.40G| case 3: sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; /* Falls through. */ ------------------ | Branch (872:4): [True: 100M, False: 1.50G] ------------------ 873| 1.50G| case 2: sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; /* Falls through. */ ------------------ | Branch (873:4): [True: 99.8M, False: 1.50G] ------------------ 874| 1.61G| case 1: sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; ------------------ | Branch (874:4): [True: 109M, False: 1.49G] ------------------ 875| 1.60G| } 876| 1.60G| residual_to_check = data[i] - (sum >> lp_quantization); 877| | /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */ 878| 1.60G| if(residual_to_check <= INT32_MIN || residual_to_check > INT32_MAX) ------------------ | Branch (878:6): [True: 891k, False: 1.60G] | Branch (878:40): [True: 1.02M, False: 1.60G] ------------------ 879| 1.83M| return false; 880| 1.60G| else 881| 1.60G| residual[i] = residual_to_check; 882| 1.60G| } 883| 10.5M| return true; 884| 11.8M|} FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual_33bit: 887| 1.16M|{ 888| 1.16M| int i; 889| 1.16M| FLAC__int64 sum, residual_to_check; 890| | 891| 1.16M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.16M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.16M] | | ------------------ ------------------ 892| 1.16M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.16M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.16M] | | ------------------ ------------------ 893| | 894| 76.1M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (894:13): [True: 75.2M, False: 830k] ------------------ 895| 75.2M| sum = 0; 896| 75.2M| switch(order) { ------------------ | Branch (896:10): [True: 75.4M, False: 18.4E] ------------------ 897| 1.95M| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (897:4): [True: 1.95M, False: 73.3M] ------------------ 898| 3.91M| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (898:4): [True: 1.96M, False: 73.3M] ------------------ 899| 5.91M| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (899:4): [True: 2.00M, False: 73.2M] ------------------ 900| 7.89M| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (900:4): [True: 1.98M, False: 73.3M] ------------------ 901| 9.86M| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (901:4): [True: 1.96M, False: 73.3M] ------------------ 902| 11.8M| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (902:4): [True: 1.94M, False: 73.3M] ------------------ 903| 13.7M| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (903:4): [True: 1.92M, False: 73.3M] ------------------ 904| 15.6M| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (904:4): [True: 1.91M, False: 73.3M] ------------------ 905| 17.6M| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (905:4): [True: 1.98M, False: 73.3M] ------------------ 906| 19.6M| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (906:4): [True: 2.00M, False: 73.2M] ------------------ 907| 21.6M| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (907:4): [True: 1.98M, False: 73.2M] ------------------ 908| 23.5M| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (908:4): [True: 1.91M, False: 73.3M] ------------------ 909| 25.3M| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (909:4): [True: 1.85M, False: 73.4M] ------------------ 910| 27.1M| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (910:4): [True: 1.80M, False: 73.4M] ------------------ 911| 29.0M| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (911:4): [True: 1.81M, False: 73.4M] ------------------ 912| 30.8M| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (912:4): [True: 1.80M, False: 73.4M] ------------------ 913| 32.6M| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (913:4): [True: 1.86M, False: 73.4M] ------------------ 914| 34.5M| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (914:4): [True: 1.88M, False: 73.4M] ------------------ 915| 37.0M| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (915:4): [True: 2.45M, False: 72.8M] ------------------ 916| 39.6M| case 13: sum += qlp_coeff[12] * data[i-13]; /* Falls through. */ ------------------ | Branch (916:4): [True: 2.64M, False: 72.6M] ------------------ 917| 42.3M| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (917:4): [True: 2.68M, False: 72.6M] ------------------ 918| 45.0M| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (918:4): [True: 2.73M, False: 72.5M] ------------------ 919| 47.8M| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (919:4): [True: 2.78M, False: 72.5M] ------------------ 920| 50.6M| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (920:4): [True: 2.83M, False: 72.4M] ------------------ 921| 53.5M| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (921:4): [True: 2.86M, False: 72.4M] ------------------ 922| 56.4M| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (922:4): [True: 2.90M, False: 72.3M] ------------------ 923| 59.4M| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (923:4): [True: 2.95M, False: 72.3M] ------------------ 924| 62.5M| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (924:4): [True: 3.11M, False: 72.1M] ------------------ 925| 65.6M| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (925:4): [True: 3.10M, False: 72.1M] ------------------ 926| 68.7M| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (926:4): [True: 3.14M, False: 72.1M] ------------------ 927| 71.8M| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (927:4): [True: 3.08M, False: 72.2M] ------------------ 928| 75.4M| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (928:4): [True: 3.60M, False: 71.6M] ------------------ 929| 75.2M| } 930| 75.3M| residual_to_check = data[i] - (sum >> lp_quantization); 931| | /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */ 932| 75.3M| if(residual_to_check <= INT32_MIN || residual_to_check > INT32_MAX) ------------------ | Branch (932:6): [True: 185k, False: 75.1M] | Branch (932:40): [True: 185k, False: 74.9M] ------------------ 933| 364k| return false; 934| 74.9M| else 935| 74.9M| residual[i] = residual_to_check; 936| 75.3M| } 937| 830k| return true; 938| 1.16M|} FLAC__lpc_max_prediction_value_before_shift: 943| 26.3M|{ 944| 26.3M| FLAC__uint64 max_abs_sample_value = (FLAC__uint64)(1) << (subframe_bps - 1); 945| 26.3M| FLAC__uint32 abs_sum_of_qlp_coeff = 0; 946| 26.3M| uint32_t i; 947| 244M| for(i = 0; i < order; i++) ------------------ | Branch (947:13): [True: 217M, False: 26.3M] ------------------ 948| 217M| abs_sum_of_qlp_coeff += abs(qlp_coeff[i]); 949| 26.3M| return max_abs_sample_value * abs_sum_of_qlp_coeff; 950| 26.3M|} FLAC__lpc_max_prediction_before_shift_bps: 953| 6.70M|{ 954| | /* This used to be subframe_bps + qlp_coeff_precision + FLAC__bitmath_ilog2(order) 955| | * but that treats both the samples as well as the predictor as unknown. The 956| | * predictor is known however, so taking the log2 of the sum of the absolute values 957| | * of all coefficients is a more accurate representation of the predictor */ 958| 6.70M| return FLAC__bitmath_silog2(FLAC__lpc_max_prediction_value_before_shift(subframe_bps, qlp_coeff, order)); 959| 6.70M|} FLAC__lpc_max_residual_bps: 963| 19.7M|{ 964| 19.7M| FLAC__uint64 max_abs_sample_value = (FLAC__uint64)(1) << (subframe_bps - 1); 965| 19.7M| FLAC__uint64 max_prediction_value_after_shift = -1 * ((-1 * (FLAC__int64)FLAC__lpc_max_prediction_value_before_shift(subframe_bps, qlp_coeff, order)) >> lp_quantization); 966| 19.7M| FLAC__uint64 max_residual_value = max_abs_sample_value + max_prediction_value_after_shift; 967| 19.7M| return FLAC__bitmath_silog2(max_residual_value); 968| 19.7M|} FLAC__lpc_restore_signal: 1019| 6.81k|{ 1020| 6.81k| int i; 1021| 6.81k| FLAC__int32 sum; 1022| | 1023| 6.81k| FLAC__ASSERT(order > 0); ------------------ | | 38| 6.81k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.81k] | | ------------------ ------------------ 1024| 6.81k| FLAC__ASSERT(order <= 32); ------------------ | | 38| 6.81k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.81k] | | ------------------ ------------------ 1025| | 1026| | /* 1027| | * We do unique versions up to 12th order since that's the subset limit. 1028| | * Also they are roughly ordered to match frequency of occurrence to 1029| | * minimize branching. 1030| | */ 1031| 6.81k| if(order <= 12) { ------------------ | Branch (1031:5): [True: 6.33k, False: 477] ------------------ 1032| 6.33k| if(order > 8) { ------------------ | Branch (1032:6): [True: 1.09k, False: 5.23k] ------------------ 1033| 1.09k| if(order > 10) { ------------------ | Branch (1033:7): [True: 581, False: 518] ------------------ 1034| 581| if(order == 12) { ------------------ | Branch (1034:8): [True: 402, False: 179] ------------------ 1035| 63.5k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1035:17): [True: 63.1k, False: 402] ------------------ 1036| 63.1k| sum = 0; 1037| 63.1k| sum += qlp_coeff[11] * data[i-12]; 1038| 63.1k| sum += qlp_coeff[10] * data[i-11]; 1039| 63.1k| sum += qlp_coeff[9] * data[i-10]; 1040| 63.1k| sum += qlp_coeff[8] * data[i-9]; 1041| 63.1k| sum += qlp_coeff[7] * data[i-8]; 1042| 63.1k| sum += qlp_coeff[6] * data[i-7]; 1043| 63.1k| sum += qlp_coeff[5] * data[i-6]; 1044| 63.1k| sum += qlp_coeff[4] * data[i-5]; 1045| 63.1k| sum += qlp_coeff[3] * data[i-4]; 1046| 63.1k| sum += qlp_coeff[2] * data[i-3]; 1047| 63.1k| sum += qlp_coeff[1] * data[i-2]; 1048| 63.1k| sum += qlp_coeff[0] * data[i-1]; 1049| 63.1k| data[i] = residual[i] + (sum >> lp_quantization); 1050| 63.1k| } 1051| 402| } 1052| 179| else { /* order == 11 */ 1053| 12.5k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1053:17): [True: 12.3k, False: 179] ------------------ 1054| 12.3k| sum = 0; 1055| 12.3k| sum += qlp_coeff[10] * data[i-11]; 1056| 12.3k| sum += qlp_coeff[9] * data[i-10]; 1057| 12.3k| sum += qlp_coeff[8] * data[i-9]; 1058| 12.3k| sum += qlp_coeff[7] * data[i-8]; 1059| 12.3k| sum += qlp_coeff[6] * data[i-7]; 1060| 12.3k| sum += qlp_coeff[5] * data[i-6]; 1061| 12.3k| sum += qlp_coeff[4] * data[i-5]; 1062| 12.3k| sum += qlp_coeff[3] * data[i-4]; 1063| 12.3k| sum += qlp_coeff[2] * data[i-3]; 1064| 12.3k| sum += qlp_coeff[1] * data[i-2]; 1065| 12.3k| sum += qlp_coeff[0] * data[i-1]; 1066| 12.3k| data[i] = residual[i] + (sum >> lp_quantization); 1067| 12.3k| } 1068| 179| } 1069| 581| } 1070| 518| else { 1071| 518| if(order == 10) { ------------------ | Branch (1071:8): [True: 391, False: 127] ------------------ 1072| 77.6k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1072:17): [True: 77.2k, False: 391] ------------------ 1073| 77.2k| sum = 0; 1074| 77.2k| sum += qlp_coeff[9] * data[i-10]; 1075| 77.2k| sum += qlp_coeff[8] * data[i-9]; 1076| 77.2k| sum += qlp_coeff[7] * data[i-8]; 1077| 77.2k| sum += qlp_coeff[6] * data[i-7]; 1078| 77.2k| sum += qlp_coeff[5] * data[i-6]; 1079| 77.2k| sum += qlp_coeff[4] * data[i-5]; 1080| 77.2k| sum += qlp_coeff[3] * data[i-4]; 1081| 77.2k| sum += qlp_coeff[2] * data[i-3]; 1082| 77.2k| sum += qlp_coeff[1] * data[i-2]; 1083| 77.2k| sum += qlp_coeff[0] * data[i-1]; 1084| 77.2k| data[i] = residual[i] + (sum >> lp_quantization); 1085| 77.2k| } 1086| 391| } 1087| 127| else { /* order == 9 */ 1088| 40.8k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1088:17): [True: 40.7k, False: 127] ------------------ 1089| 40.7k| sum = 0; 1090| 40.7k| sum += qlp_coeff[8] * data[i-9]; 1091| 40.7k| sum += qlp_coeff[7] * data[i-8]; 1092| 40.7k| sum += qlp_coeff[6] * data[i-7]; 1093| 40.7k| sum += qlp_coeff[5] * data[i-6]; 1094| 40.7k| sum += qlp_coeff[4] * data[i-5]; 1095| 40.7k| sum += qlp_coeff[3] * data[i-4]; 1096| 40.7k| sum += qlp_coeff[2] * data[i-3]; 1097| 40.7k| sum += qlp_coeff[1] * data[i-2]; 1098| 40.7k| sum += qlp_coeff[0] * data[i-1]; 1099| 40.7k| data[i] = residual[i] + (sum >> lp_quantization); 1100| 40.7k| } 1101| 127| } 1102| 518| } 1103| 1.09k| } 1104| 5.23k| else if(order > 4) { ------------------ | Branch (1104:11): [True: 1.49k, False: 3.74k] ------------------ 1105| 1.49k| if(order > 6) { ------------------ | Branch (1105:7): [True: 761, False: 734] ------------------ 1106| 761| if(order == 8) { ------------------ | Branch (1106:8): [True: 412, False: 349] ------------------ 1107| 62.1k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1107:17): [True: 61.7k, False: 412] ------------------ 1108| 61.7k| sum = 0; 1109| 61.7k| sum += qlp_coeff[7] * data[i-8]; 1110| 61.7k| sum += qlp_coeff[6] * data[i-7]; 1111| 61.7k| sum += qlp_coeff[5] * data[i-6]; 1112| 61.7k| sum += qlp_coeff[4] * data[i-5]; 1113| 61.7k| sum += qlp_coeff[3] * data[i-4]; 1114| 61.7k| sum += qlp_coeff[2] * data[i-3]; 1115| 61.7k| sum += qlp_coeff[1] * data[i-2]; 1116| 61.7k| sum += qlp_coeff[0] * data[i-1]; 1117| 61.7k| data[i] = residual[i] + (sum >> lp_quantization); 1118| 61.7k| } 1119| 412| } 1120| 349| else { /* order == 7 */ 1121| 168k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1121:17): [True: 167k, False: 349] ------------------ 1122| 167k| sum = 0; 1123| 167k| sum += qlp_coeff[6] * data[i-7]; 1124| 167k| sum += qlp_coeff[5] * data[i-6]; 1125| 167k| sum += qlp_coeff[4] * data[i-5]; 1126| 167k| sum += qlp_coeff[3] * data[i-4]; 1127| 167k| sum += qlp_coeff[2] * data[i-3]; 1128| 167k| sum += qlp_coeff[1] * data[i-2]; 1129| 167k| sum += qlp_coeff[0] * data[i-1]; 1130| 167k| data[i] = residual[i] + (sum >> lp_quantization); 1131| 167k| } 1132| 349| } 1133| 761| } 1134| 734| else { 1135| 734| if(order == 6) { ------------------ | Branch (1135:8): [True: 374, False: 360] ------------------ 1136| 93.1k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1136:17): [True: 92.7k, False: 374] ------------------ 1137| 92.7k| sum = 0; 1138| 92.7k| sum += qlp_coeff[5] * data[i-6]; 1139| 92.7k| sum += qlp_coeff[4] * data[i-5]; 1140| 92.7k| sum += qlp_coeff[3] * data[i-4]; 1141| 92.7k| sum += qlp_coeff[2] * data[i-3]; 1142| 92.7k| sum += qlp_coeff[1] * data[i-2]; 1143| 92.7k| sum += qlp_coeff[0] * data[i-1]; 1144| 92.7k| data[i] = residual[i] + (sum >> lp_quantization); 1145| 92.7k| } 1146| 374| } 1147| 360| else { /* order == 5 */ 1148| 139k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1148:17): [True: 138k, False: 360] ------------------ 1149| 138k| sum = 0; 1150| 138k| sum += qlp_coeff[4] * data[i-5]; 1151| 138k| sum += qlp_coeff[3] * data[i-4]; 1152| 138k| sum += qlp_coeff[2] * data[i-3]; 1153| 138k| sum += qlp_coeff[1] * data[i-2]; 1154| 138k| sum += qlp_coeff[0] * data[i-1]; 1155| 138k| data[i] = residual[i] + (sum >> lp_quantization); 1156| 138k| } 1157| 360| } 1158| 734| } 1159| 1.49k| } 1160| 3.74k| else { 1161| 3.74k| if(order > 2) { ------------------ | Branch (1161:7): [True: 1.26k, False: 2.48k] ------------------ 1162| 1.26k| if(order == 4) { ------------------ | Branch (1162:8): [True: 470, False: 792] ------------------ 1163| 38.7k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1163:17): [True: 38.3k, False: 470] ------------------ 1164| 38.3k| sum = 0; 1165| 38.3k| sum += qlp_coeff[3] * data[i-4]; 1166| 38.3k| sum += qlp_coeff[2] * data[i-3]; 1167| 38.3k| sum += qlp_coeff[1] * data[i-2]; 1168| 38.3k| sum += qlp_coeff[0] * data[i-1]; 1169| 38.3k| data[i] = residual[i] + (sum >> lp_quantization); 1170| 38.3k| } 1171| 470| } 1172| 792| else { /* order == 3 */ 1173| 251k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1173:17): [True: 250k, False: 792] ------------------ 1174| 250k| sum = 0; 1175| 250k| sum += qlp_coeff[2] * data[i-3]; 1176| 250k| sum += qlp_coeff[1] * data[i-2]; 1177| 250k| sum += qlp_coeff[0] * data[i-1]; 1178| 250k| data[i] = residual[i] + (sum >> lp_quantization); 1179| 250k| } 1180| 792| } 1181| 1.26k| } 1182| 2.48k| else { 1183| 2.48k| if(order == 2) { ------------------ | Branch (1183:8): [True: 1.03k, False: 1.45k] ------------------ 1184| 321k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1184:17): [True: 320k, False: 1.03k] ------------------ 1185| 320k| sum = 0; 1186| 320k| sum += qlp_coeff[1] * data[i-2]; 1187| 320k| sum += qlp_coeff[0] * data[i-1]; 1188| 320k| data[i] = residual[i] + (sum >> lp_quantization); 1189| 320k| } 1190| 1.03k| } 1191| 1.45k| else { /* order == 1 */ 1192| 49.4k| for(i = 0; i < (int)data_len; i++) ------------------ | Branch (1192:17): [True: 48.0k, False: 1.45k] ------------------ 1193| 48.0k| data[i] = residual[i] + ((qlp_coeff[0] * data[i-1]) >> lp_quantization); 1194| 1.45k| } 1195| 2.48k| } 1196| 3.74k| } 1197| 6.33k| } 1198| 477| else { /* order > 12 */ 1199| 340k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1199:14): [True: 340k, False: 477] ------------------ 1200| 340k| sum = 0; 1201| 340k| switch(order) { ------------------ | Branch (1201:11): [True: 340k, False: 0] ------------------ 1202| 120k| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (1202:5): [True: 120k, False: 220k] ------------------ 1203| 130k| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (1203:5): [True: 9.94k, False: 330k] ------------------ 1204| 131k| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (1204:5): [True: 1.26k, False: 339k] ------------------ 1205| 135k| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (1205:5): [True: 4.49k, False: 335k] ------------------ 1206| 137k| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (1206:5): [True: 1.39k, False: 338k] ------------------ 1207| 142k| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (1207:5): [True: 5.55k, False: 334k] ------------------ 1208| 144k| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (1208:5): [True: 1.23k, False: 339k] ------------------ 1209| 145k| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (1209:5): [True: 1.22k, False: 339k] ------------------ 1210| 146k| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (1210:5): [True: 1.01k, False: 339k] ------------------ 1211| 151k| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (1211:5): [True: 5.46k, False: 334k] ------------------ 1212| 158k| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (1212:5): [True: 6.62k, False: 333k] ------------------ 1213| 163k| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (1213:5): [True: 5.02k, False: 335k] ------------------ 1214| 172k| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (1214:5): [True: 8.79k, False: 331k] ------------------ 1215| 187k| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (1215:5): [True: 15.5k, False: 324k] ------------------ 1216| 193k| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (1216:5): [True: 5.52k, False: 334k] ------------------ 1217| 264k| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (1217:5): [True: 71.2k, False: 269k] ------------------ 1218| 287k| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (1218:5): [True: 22.4k, False: 317k] ------------------ 1219| 296k| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (1219:5): [True: 9.59k, False: 330k] ------------------ 1220| 307k| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (1220:5): [True: 10.5k, False: 329k] ------------------ 1221| 340k| case 13: sum += qlp_coeff[12] * data[i-13]; ------------------ | Branch (1221:5): [True: 33.1k, False: 307k] ------------------ 1222| 340k| sum += qlp_coeff[11] * data[i-12]; 1223| 340k| sum += qlp_coeff[10] * data[i-11]; 1224| 340k| sum += qlp_coeff[ 9] * data[i-10]; 1225| 340k| sum += qlp_coeff[ 8] * data[i- 9]; 1226| 340k| sum += qlp_coeff[ 7] * data[i- 8]; 1227| 340k| sum += qlp_coeff[ 6] * data[i- 7]; 1228| 340k| sum += qlp_coeff[ 5] * data[i- 6]; 1229| 340k| sum += qlp_coeff[ 4] * data[i- 5]; 1230| 340k| sum += qlp_coeff[ 3] * data[i- 4]; 1231| 340k| sum += qlp_coeff[ 2] * data[i- 3]; 1232| 340k| sum += qlp_coeff[ 1] * data[i- 2]; 1233| 340k| sum += qlp_coeff[ 0] * data[i- 1]; 1234| 340k| } 1235| 340k| data[i] = residual[i] + (sum >> lp_quantization); 1236| 340k| } 1237| 477| } 1238| 6.81k|} FLAC__lpc_restore_signal_wide: 1271| 10.5k|{ 1272| 10.5k| int i; 1273| 10.5k| FLAC__int64 sum; 1274| | 1275| 10.5k| FLAC__ASSERT(order > 0); ------------------ | | 38| 10.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.5k] | | ------------------ ------------------ 1276| 10.5k| FLAC__ASSERT(order <= 32); ------------------ | | 38| 10.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.5k] | | ------------------ ------------------ 1277| | 1278| | /* 1279| | * We do unique versions up to 12th order since that's the subset limit. 1280| | * Also they are roughly ordered to match frequency of occurrence to 1281| | * minimize branching. 1282| | */ 1283| 10.5k| if(order <= 12) { ------------------ | Branch (1283:5): [True: 9.93k, False: 656] ------------------ 1284| 9.93k| if(order > 8) { ------------------ | Branch (1284:6): [True: 1.90k, False: 8.03k] ------------------ 1285| 1.90k| if(order > 10) { ------------------ | Branch (1285:7): [True: 649, False: 1.25k] ------------------ 1286| 649| if(order == 12) { ------------------ | Branch (1286:8): [True: 309, False: 340] ------------------ 1287| 60.3k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1287:17): [True: 60.0k, False: 309] ------------------ 1288| 60.0k| sum = 0; 1289| 60.0k| sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; 1290| 60.0k| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1291| 60.0k| sum += qlp_coeff[9] * (FLAC__int64)data[i-10]; 1292| 60.0k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1293| 60.0k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1294| 60.0k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1295| 60.0k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1296| 60.0k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1297| 60.0k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1298| 60.0k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1299| 60.0k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1300| 60.0k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1301| 60.0k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1302| 60.0k| } 1303| 309| } 1304| 340| else { /* order == 11 */ 1305| 123k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1305:17): [True: 122k, False: 340] ------------------ 1306| 122k| sum = 0; 1307| 122k| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1308| 122k| sum += qlp_coeff[9] * (FLAC__int64)data[i-10]; 1309| 122k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1310| 122k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1311| 122k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1312| 122k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1313| 122k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1314| 122k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1315| 122k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1316| 122k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1317| 122k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1318| 122k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1319| 122k| } 1320| 340| } 1321| 649| } 1322| 1.25k| else { 1323| 1.25k| if(order == 10) { ------------------ | Branch (1323:8): [True: 440, False: 812] ------------------ 1324| 39.1k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1324:17): [True: 38.6k, False: 440] ------------------ 1325| 38.6k| sum = 0; 1326| 38.6k| sum += qlp_coeff[9] * (FLAC__int64)data[i-10]; 1327| 38.6k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1328| 38.6k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1329| 38.6k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1330| 38.6k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1331| 38.6k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1332| 38.6k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1333| 38.6k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1334| 38.6k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1335| 38.6k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1336| 38.6k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1337| 38.6k| } 1338| 440| } 1339| 812| else { /* order == 9 */ 1340| 68.0k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1340:17): [True: 67.1k, False: 812] ------------------ 1341| 67.1k| sum = 0; 1342| 67.1k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1343| 67.1k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1344| 67.1k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1345| 67.1k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1346| 67.1k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1347| 67.1k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1348| 67.1k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1349| 67.1k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1350| 67.1k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1351| 67.1k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1352| 67.1k| } 1353| 812| } 1354| 1.25k| } 1355| 1.90k| } 1356| 8.03k| else if(order > 4) { ------------------ | Branch (1356:11): [True: 2.23k, False: 5.80k] ------------------ 1357| 2.23k| if(order > 6) { ------------------ | Branch (1357:7): [True: 1.09k, False: 1.14k] ------------------ 1358| 1.09k| if(order == 8) { ------------------ | Branch (1358:8): [True: 446, False: 647] ------------------ 1359| 267k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1359:17): [True: 266k, False: 446] ------------------ 1360| 266k| sum = 0; 1361| 266k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1362| 266k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1363| 266k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1364| 266k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1365| 266k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1366| 266k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1367| 266k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1368| 266k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1369| 266k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1370| 266k| } 1371| 446| } 1372| 647| else { /* order == 7 */ 1373| 226k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1373:17): [True: 225k, False: 647] ------------------ 1374| 225k| sum = 0; 1375| 225k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1376| 225k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1377| 225k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1378| 225k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1379| 225k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1380| 225k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1381| 225k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1382| 225k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1383| 225k| } 1384| 647| } 1385| 1.09k| } 1386| 1.14k| else { 1387| 1.14k| if(order == 6) { ------------------ | Branch (1387:8): [True: 564, False: 577] ------------------ 1388| 203k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1388:17): [True: 202k, False: 564] ------------------ 1389| 202k| sum = 0; 1390| 202k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1391| 202k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1392| 202k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1393| 202k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1394| 202k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1395| 202k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1396| 202k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1397| 202k| } 1398| 564| } 1399| 577| else { /* order == 5 */ 1400| 191k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1400:17): [True: 190k, False: 577] ------------------ 1401| 190k| sum = 0; 1402| 190k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1403| 190k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1404| 190k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1405| 190k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1406| 190k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1407| 190k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1408| 190k| } 1409| 577| } 1410| 1.14k| } 1411| 2.23k| } 1412| 5.80k| else { 1413| 5.80k| if(order > 2) { ------------------ | Branch (1413:7): [True: 1.75k, False: 4.04k] ------------------ 1414| 1.75k| if(order == 4) { ------------------ | Branch (1414:8): [True: 890, False: 866] ------------------ 1415| 232k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1415:17): [True: 231k, False: 890] ------------------ 1416| 231k| sum = 0; 1417| 231k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1418| 231k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1419| 231k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1420| 231k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1421| 231k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1422| 231k| } 1423| 890| } 1424| 866| else { /* order == 3 */ 1425| 159k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1425:17): [True: 159k, False: 866] ------------------ 1426| 159k| sum = 0; 1427| 159k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1428| 159k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1429| 159k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1430| 159k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1431| 159k| } 1432| 866| } 1433| 1.75k| } 1434| 4.04k| else { 1435| 4.04k| if(order == 2) { ------------------ | Branch (1435:8): [True: 2.75k, False: 1.28k] ------------------ 1436| 434k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1436:17): [True: 431k, False: 2.75k] ------------------ 1437| 431k| sum = 0; 1438| 431k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1439| 431k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1440| 431k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1441| 431k| } 1442| 2.75k| } 1443| 1.28k| else { /* order == 1 */ 1444| 564k| for(i = 0; i < (int)data_len; i++) ------------------ | Branch (1444:17): [True: 563k, False: 1.28k] ------------------ 1445| 563k| data[i] = (FLAC__int32)(residual[i] + ((qlp_coeff[0] * (FLAC__int64)data[i-1]) >> lp_quantization)); 1446| 1.28k| } 1447| 4.04k| } 1448| 5.80k| } 1449| 9.93k| } 1450| 656| else { /* order > 12 */ 1451| 3.68M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1451:14): [True: 3.68M, False: 656] ------------------ 1452| 3.68M| sum = 0; 1453| 3.68M| switch(order) { ------------------ | Branch (1453:11): [True: 3.68M, False: 0] ------------------ 1454| 178k| case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */ ------------------ | Branch (1454:5): [True: 178k, False: 3.50M] ------------------ 1455| 184k| case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */ ------------------ | Branch (1455:5): [True: 6.03k, False: 3.67M] ------------------ 1456| 206k| case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */ ------------------ | Branch (1456:5): [True: 22.8k, False: 3.65M] ------------------ 1457| 209k| case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */ ------------------ | Branch (1457:5): [True: 2.12k, False: 3.68M] ------------------ 1458| 222k| case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */ ------------------ | Branch (1458:5): [True: 13.5k, False: 3.66M] ------------------ 1459| 257k| case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */ ------------------ | Branch (1459:5): [True: 35.0k, False: 3.64M] ------------------ 1460| 259k| case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */ ------------------ | Branch (1460:5): [True: 2.04k, False: 3.68M] ------------------ 1461| 261k| case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */ ------------------ | Branch (1461:5): [True: 1.50k, False: 3.68M] ------------------ 1462| 264k| case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */ ------------------ | Branch (1462:5): [True: 3.63k, False: 3.67M] ------------------ 1463| 296k| case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */ ------------------ | Branch (1463:5): [True: 32.0k, False: 3.65M] ------------------ 1464| 304k| case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */ ------------------ | Branch (1464:5): [True: 7.38k, False: 3.67M] ------------------ 1465| 309k| case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */ ------------------ | Branch (1465:5): [True: 5.05k, False: 3.67M] ------------------ 1466| 310k| case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */ ------------------ | Branch (1466:5): [True: 1.03k, False: 3.68M] ------------------ 1467| 315k| case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */ ------------------ | Branch (1467:5): [True: 5.21k, False: 3.67M] ------------------ 1468| 324k| case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */ ------------------ | Branch (1468:5): [True: 9.20k, False: 3.67M] ------------------ 1469| 395k| case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */ ------------------ | Branch (1469:5): [True: 70.7k, False: 3.61M] ------------------ 1470| 413k| case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */ ------------------ | Branch (1470:5): [True: 18.1k, False: 3.66M] ------------------ 1471| 420k| case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */ ------------------ | Branch (1471:5): [True: 7.02k, False: 3.67M] ------------------ 1472| 3.18M| case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */ ------------------ | Branch (1472:5): [True: 2.75M, False: 922k] ------------------ 1473| 3.68M| case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13]; ------------------ | Branch (1473:5): [True: 502k, False: 3.18M] ------------------ 1474| 3.68M| sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; 1475| 3.68M| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1476| 3.68M| sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; 1477| 3.68M| sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; 1478| 3.68M| sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; 1479| 3.68M| sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; 1480| 3.68M| sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; 1481| 3.68M| sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; 1482| 3.68M| sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; 1483| 3.68M| sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; 1484| 3.68M| sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; 1485| 3.68M| sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; 1486| 3.68M| } 1487| 3.68M| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1488| 3.68M| } 1489| 656| } 1490| 10.5k|} FLAC__lpc_restore_signal_wide_33bit: 1526| 1.50k|{ 1527| 1.50k| int i; 1528| 1.50k| FLAC__int64 sum; 1529| | 1530| 1.50k| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.50k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.50k] | | ------------------ ------------------ 1531| 1.50k| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.50k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.50k] | | ------------------ ------------------ 1532| | 1533| 127k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1533:13): [True: 126k, False: 1.50k] ------------------ 1534| 126k| sum = 0; 1535| 126k| switch(order) { ------------------ | Branch (1535:10): [True: 126k, False: 0] ------------------ 1536| 968| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (1536:4): [True: 968, False: 125k] ------------------ 1537| 1.93k| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (1537:4): [True: 964, False: 125k] ------------------ 1538| 10.3k| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (1538:4): [True: 8.41k, False: 117k] ------------------ 1539| 11.5k| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (1539:4): [True: 1.20k, False: 124k] ------------------ 1540| 12.5k| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (1540:4): [True: 973, False: 125k] ------------------ 1541| 13.4k| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (1541:4): [True: 963, False: 125k] ------------------ 1542| 14.7k| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (1542:4): [True: 1.29k, False: 124k] ------------------ 1543| 15.8k| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (1543:4): [True: 1.07k, False: 125k] ------------------ 1544| 16.8k| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (1544:4): [True: 963, False: 125k] ------------------ 1545| 17.7k| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (1545:4): [True: 963, False: 125k] ------------------ 1546| 20.1k| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (1546:4): [True: 2.36k, False: 123k] ------------------ 1547| 21.1k| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (1547:4): [True: 963, False: 125k] ------------------ 1548| 27.5k| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (1548:4): [True: 6.43k, False: 119k] ------------------ 1549| 28.5k| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (1549:4): [True: 962, False: 125k] ------------------ 1550| 29.4k| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (1550:4): [True: 963, False: 125k] ------------------ 1551| 30.4k| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (1551:4): [True: 1.01k, False: 125k] ------------------ 1552| 31.1k| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (1552:4): [True: 705, False: 125k] ------------------ 1553| 31.8k| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (1553:4): [True: 712, False: 125k] ------------------ 1554| 32.7k| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (1554:4): [True: 816, False: 125k] ------------------ 1555| 33.5k| case 13: sum += qlp_coeff[12] * data[i-13]; /* Falls through. */ ------------------ | Branch (1555:4): [True: 832, False: 125k] ------------------ 1556| 34.4k| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (1556:4): [True: 933, False: 125k] ------------------ 1557| 37.8k| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (1557:4): [True: 3.40k, False: 122k] ------------------ 1558| 39.6k| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (1558:4): [True: 1.74k, False: 124k] ------------------ 1559| 40.5k| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (1559:4): [True: 913, False: 125k] ------------------ 1560| 48.3k| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (1560:4): [True: 7.80k, False: 118k] ------------------ 1561| 54.1k| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (1561:4): [True: 5.80k, False: 120k] ------------------ 1562| 54.8k| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (1562:4): [True: 707, False: 125k] ------------------ 1563| 59.5k| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (1563:4): [True: 4.64k, False: 121k] ------------------ 1564| 62.4k| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (1564:4): [True: 2.97k, False: 123k] ------------------ 1565| 77.5k| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (1565:4): [True: 15.1k, False: 110k] ------------------ 1566| 85.2k| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (1566:4): [True: 7.67k, False: 118k] ------------------ 1567| 126k| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (1567:4): [True: 40.8k, False: 85.2k] ------------------ 1568| 126k| } 1569| 126k| data[i] = residual[i] + (sum >> lp_quantization); 1570| 126k| } 1571| 1.50k|} FLAC__lpc_compute_expected_bits_per_residual_sample: 1581| 3.28M|{ 1582| 3.28M| double error_scale; 1583| | 1584| 3.28M| FLAC__ASSERT(total_samples > 0); ------------------ | | 38| 3.28M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.28M] | | ------------------ ------------------ 1585| | 1586| 3.28M| error_scale = 0.5 / (double)total_samples; 1587| | 1588| 3.28M| return FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error, error_scale); 1589| 3.28M|} FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale: 1592| 7.32M|{ 1593| 7.32M| if(lpc_error > 0.0) { ------------------ | Branch (1593:5): [True: 7.26M, False: 61.4k] ------------------ 1594| 7.26M| double bps = (double)0.5 * log(error_scale * lpc_error) / M_LN2; 1595| 7.26M| if(bps >= 0.0) ------------------ | Branch (1595:6): [True: 7.02M, False: 242k] ------------------ 1596| 7.02M| return bps; 1597| 242k| else 1598| 242k| return 0.0; 1599| 7.26M| } 1600| 61.5k| else if(lpc_error < 0.0) { /* error should not be negative but can happen due to inadequate floating-point resolution */ ------------------ | Branch (1600:10): [True: 61.5k, False: 18.4E] ------------------ 1601| 61.5k| return 1e32; 1602| 61.5k| } 1603| 18.4E| else { 1604| 18.4E| return 0.0; 1605| 18.4E| } 1606| 7.32M|} FLAC__lpc_compute_best_order: 1609| 344k|{ 1610| 344k| uint32_t order, indx, best_index; /* 'index' the index into lpc_error; index==order-1 since lpc_error[0] is for order==1, lpc_error[1] is for order==2, etc */ 1611| 344k| double bits, best_bits, error_scale; 1612| | 1613| 344k| FLAC__ASSERT(max_order > 0); ------------------ | | 38| 344k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 344k] | | ------------------ ------------------ 1614| 344k| FLAC__ASSERT(total_samples > 0); ------------------ | | 38| 344k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 344k] | | ------------------ ------------------ 1615| | 1616| 344k| error_scale = 0.5 / (double)total_samples; 1617| | 1618| 344k| best_index = 0; 1619| 344k| best_bits = (uint32_t)(-1); 1620| | 1621| 4.40M| for(indx = 0, order = 1; indx < max_order; indx++, order++) { ------------------ | Branch (1621:27): [True: 4.05M, False: 344k] ------------------ 1622| 4.05M| bits = FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error[indx], error_scale) * (double)(total_samples - order) + (double)(order * overhead_bits_per_order); 1623| 4.05M| if(bits < best_bits) { ------------------ | Branch (1623:6): [True: 650k, False: 3.40M] ------------------ 1624| 650k| best_index = indx; 1625| 650k| best_bits = bits; 1626| 650k| } 1627| 4.05M| } 1628| | 1629| 344k| return best_index+1; /* +1 since indx of lpc_error[] is order-1 */ 1630| 344k|} FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2: 52| 1.58M|{ 53| 1.58M| int i; 54| 1.58M| FLAC__int32 sum; 55| 1.58M| const __m128i cnt = _mm_cvtsi32_si128(lp_quantization); 56| | 57| 1.58M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.58M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.58M] | | ------------------ ------------------ 58| 1.58M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.58M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.58M] | | ------------------ ------------------ 59| | 60| 1.58M| if(order <= 12) { ------------------ | Branch (60:5): [True: 1.23M, False: 355k] ------------------ 61| 1.23M| if(order > 8) { ------------------ | Branch (61:6): [True: 377k, False: 854k] ------------------ 62| 377k| if(order > 10) { ------------------ | Branch (62:7): [True: 187k, False: 189k] ------------------ 63| 187k| if(order == 12) { ------------------ | Branch (63:8): [True: 93.4k, False: 94.3k] ------------------ 64| 93.4k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11; 65| 93.4k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 66| 93.4k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 67| 93.4k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 68| 93.4k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 69| 93.4k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 70| 93.4k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 71| 93.4k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 72| 93.4k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 73| 93.4k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 74| 93.4k| q9 = _mm256_set1_epi32(0xffff & qlp_coeff[9 ]); 75| 93.4k| q10 = _mm256_set1_epi32(0xffff & qlp_coeff[10]); 76| 93.4k| q11 = _mm256_set1_epi32(0xffff & qlp_coeff[11]); 77| | 78| 1.72M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (78:17): [True: 1.63M, False: 93.4k] ------------------ 79| 1.63M| __m256i summ, mull; 80| 1.63M| summ = _mm256_madd_epi16(q11, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-12))); 81| 1.63M| mull = _mm256_madd_epi16(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); summ = _mm256_add_epi32(summ, mull); 82| 1.63M| mull = _mm256_madd_epi16(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 83| 1.63M| mull = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); summ = _mm256_add_epi32(summ, mull); 84| 1.63M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 85| 1.63M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 86| 1.63M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 87| 1.63M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 88| 1.63M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 89| 1.63M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 90| 1.63M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 91| 1.63M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 92| 1.63M| summ = _mm256_sra_epi32(summ, cnt); 93| 1.63M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 94| 1.63M| } 95| 93.4k| } 96| 94.3k| else { /* order == 11 */ 97| 94.3k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10; 98| 94.3k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 99| 94.3k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 100| 94.3k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 101| 94.3k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 102| 94.3k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 103| 94.3k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 104| 94.3k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 105| 94.3k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 106| 94.3k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 107| 94.3k| q9 = _mm256_set1_epi32(0xffff & qlp_coeff[9 ]); 108| 94.3k| q10 = _mm256_set1_epi32(0xffff & qlp_coeff[10]); 109| | 110| 1.73M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (110:17): [True: 1.63M, False: 94.3k] ------------------ 111| 1.63M| __m256i summ, mull; 112| 1.63M| summ = _mm256_madd_epi16(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); 113| 1.63M| mull = _mm256_madd_epi16(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 114| 1.63M| mull = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); summ = _mm256_add_epi32(summ, mull); 115| 1.63M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 116| 1.63M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 117| 1.63M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 118| 1.63M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 119| 1.63M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 120| 1.63M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 121| 1.63M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 122| 1.63M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 123| 1.63M| summ = _mm256_sra_epi32(summ, cnt); 124| 1.63M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 125| 1.63M| } 126| 94.3k| } 127| 187k| } 128| 189k| else { 129| 189k| if(order == 10) { ------------------ | Branch (129:8): [True: 94.5k, False: 94.9k] ------------------ 130| 94.5k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9; 131| 94.5k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 132| 94.5k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 133| 94.5k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 134| 94.5k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 135| 94.5k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 136| 94.5k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 137| 94.5k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 138| 94.5k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 139| 94.5k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 140| 94.5k| q9 = _mm256_set1_epi32(0xffff & qlp_coeff[9 ]); 141| | 142| 1.73M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (142:17): [True: 1.63M, False: 94.5k] ------------------ 143| 1.63M| __m256i summ, mull; 144| 1.63M| summ = _mm256_madd_epi16(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); 145| 1.63M| mull = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); summ = _mm256_add_epi32(summ, mull); 146| 1.63M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 147| 1.63M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 148| 1.63M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 149| 1.63M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 150| 1.63M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 151| 1.63M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 152| 1.63M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 153| 1.63M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 154| 1.63M| summ = _mm256_sra_epi32(summ, cnt); 155| 1.63M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 156| 1.63M| } 157| 94.5k| } 158| 94.9k| else { /* order == 9 */ 159| 94.9k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8; 160| 94.9k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 161| 94.9k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 162| 94.9k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 163| 94.9k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 164| 94.9k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 165| 94.9k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 166| 94.9k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 167| 94.9k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 168| 94.9k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 169| | 170| 1.77M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (170:17): [True: 1.68M, False: 94.9k] ------------------ 171| 1.68M| __m256i summ, mull; 172| 1.68M| summ = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); 173| 1.68M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 174| 1.68M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 175| 1.68M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 176| 1.68M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 177| 1.68M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 178| 1.68M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 179| 1.68M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 180| 1.68M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 181| 1.68M| summ = _mm256_sra_epi32(summ, cnt); 182| 1.68M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 183| 1.68M| } 184| 94.9k| } 185| 189k| } 186| 377k| } 187| 854k| else if(order > 4) { ------------------ | Branch (187:11): [True: 402k, False: 451k] ------------------ 188| 402k| if(order > 6) { ------------------ | Branch (188:7): [True: 198k, False: 204k] ------------------ 189| 198k| if(order == 8) { ------------------ | Branch (189:8): [True: 95.5k, False: 102k] ------------------ 190| 95.5k| __m256i q0, q1, q2, q3, q4, q5, q6, q7; 191| 95.5k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 192| 95.5k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 193| 95.5k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 194| 95.5k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 195| 95.5k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 196| 95.5k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 197| 95.5k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 198| 95.5k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 199| | 200| 1.80M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (200:17): [True: 1.71M, False: 95.5k] ------------------ 201| 1.71M| __m256i summ, mull; 202| 1.71M| summ = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); 203| 1.71M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 204| 1.71M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 205| 1.71M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 206| 1.71M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 207| 1.71M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 208| 1.71M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 209| 1.71M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 210| 1.71M| summ = _mm256_sra_epi32(summ, cnt); 211| 1.71M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 212| 1.71M| } 213| 95.5k| } 214| 102k| else { /* order == 7 */ 215| 102k| __m256i q0, q1, q2, q3, q4, q5, q6; 216| 102k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 217| 102k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 218| 102k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 219| 102k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 220| 102k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 221| 102k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 222| 102k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 223| | 224| 1.87M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (224:17): [True: 1.76M, False: 102k] ------------------ 225| 1.76M| __m256i summ, mull; 226| 1.76M| summ = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); 227| 1.76M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 228| 1.76M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 229| 1.76M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 230| 1.76M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 231| 1.76M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 232| 1.76M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 233| 1.76M| summ = _mm256_sra_epi32(summ, cnt); 234| 1.76M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 235| 1.76M| } 236| 102k| } 237| 198k| } 238| 204k| else { 239| 204k| if(order == 6) { ------------------ | Branch (239:8): [True: 102k, False: 102k] ------------------ 240| 102k| __m256i q0, q1, q2, q3, q4, q5; 241| 102k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 242| 102k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 243| 102k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 244| 102k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 245| 102k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 246| 102k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 247| | 248| 1.86M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (248:17): [True: 1.76M, False: 102k] ------------------ 249| 1.76M| __m256i summ, mull; 250| 1.76M| summ = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); 251| 1.76M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 252| 1.76M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 253| 1.76M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 254| 1.76M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 255| 1.76M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 256| 1.76M| summ = _mm256_sra_epi32(summ, cnt); 257| 1.76M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 258| 1.76M| } 259| 102k| } 260| 102k| else { /* order == 5 */ 261| 102k| __m256i q0, q1, q2, q3, q4; 262| 102k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 263| 102k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 264| 102k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 265| 102k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 266| 102k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 267| | 268| 1.87M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (268:17): [True: 1.77M, False: 102k] ------------------ 269| 1.77M| __m256i summ, mull; 270| 1.77M| summ = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); 271| 1.77M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 272| 1.77M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 273| 1.77M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 274| 1.77M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 275| 1.77M| summ = _mm256_sra_epi32(summ, cnt); 276| 1.77M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 277| 1.77M| } 278| 102k| } 279| 204k| } 280| 402k| } 281| 451k| else { 282| 451k| if(order > 2) { ------------------ | Branch (282:7): [True: 215k, False: 236k] ------------------ 283| 215k| if(order == 4) { ------------------ | Branch (283:8): [True: 104k, False: 111k] ------------------ 284| 104k| __m256i q0, q1, q2, q3; 285| 104k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 286| 104k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 287| 104k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 288| 104k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 289| | 290| 1.87M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (290:17): [True: 1.76M, False: 104k] ------------------ 291| 1.76M| __m256i summ, mull; 292| 1.76M| summ = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); 293| 1.76M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 294| 1.76M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 295| 1.76M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 296| 1.76M| summ = _mm256_sra_epi32(summ, cnt); 297| 1.76M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 298| 1.76M| } 299| 104k| } 300| 111k| else { /* order == 3 */ 301| 111k| __m256i q0, q1, q2; 302| 111k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 303| 111k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 304| 111k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 305| | 306| 1.92M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (306:17): [True: 1.80M, False: 111k] ------------------ 307| 1.80M| __m256i summ, mull; 308| 1.80M| summ = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); 309| 1.80M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 310| 1.80M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 311| 1.80M| summ = _mm256_sra_epi32(summ, cnt); 312| 1.80M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 313| 1.80M| } 314| 111k| } 315| 215k| } 316| 236k| else { 317| 236k| if(order == 2) { ------------------ | Branch (317:8): [True: 111k, False: 125k] ------------------ 318| 111k| __m256i q0, q1; 319| 111k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 320| 111k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 321| | 322| 1.92M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (322:17): [True: 1.81M, False: 111k] ------------------ 323| 1.81M| __m256i summ, mull; 324| 1.81M| summ = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); 325| 1.81M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 326| 1.81M| summ = _mm256_sra_epi32(summ, cnt); 327| 1.81M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 328| 1.81M| } 329| 111k| } 330| 125k| else { /* order == 1 */ 331| 125k| __m256i q0; 332| 125k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 333| | 334| 2.01M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (334:17): [True: 1.88M, False: 125k] ------------------ 335| 1.88M| __m256i summ; 336| 1.88M| summ = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); 337| 1.88M| summ = _mm256_sra_epi32(summ, cnt); 338| 1.88M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 339| 1.88M| } 340| 125k| } 341| 236k| } 342| 451k| } 343| 5.96M| for(; i < (int)data_len; i++) { ------------------ | Branch (343:9): [True: 4.73M, False: 1.23M] ------------------ 344| 4.73M| sum = 0; 345| 4.73M| switch(order) { ------------------ | Branch (345:11): [True: 4.73M, False: 0] ------------------ 346| 406k| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (346:5): [True: 406k, False: 4.32M] ------------------ 347| 874k| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (347:5): [True: 468k, False: 4.26M] ------------------ 348| 1.42M| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (348:5): [True: 554k, False: 4.17M] ------------------ 349| 1.73M| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (349:5): [True: 303k, False: 4.42M] ------------------ 350| 1.90M| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (350:5): [True: 167k, False: 4.56M] ------------------ 351| 2.08M| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (351:5): [True: 179k, False: 4.55M] ------------------ 352| 2.35M| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (352:5): [True: 271k, False: 4.45M] ------------------ 353| 2.70M| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (353:5): [True: 355k, False: 4.37M] ------------------ 354| 3.15M| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (354:5): [True: 450k, False: 4.28M] ------------------ 355| 3.70M| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (355:5): [True: 550k, False: 4.18M] ------------------ 356| 4.35M| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (356:5): [True: 649k, False: 4.08M] ------------------ 357| 4.73M| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (357:5): [True: 372k, False: 4.35M] ------------------ 358| 4.73M| } 359| 4.73M| residual[i] = data[i] - (sum >> lp_quantization); 360| 4.73M| } 361| 1.23M| } 362| 355k| else { /* order > 12 */ 363| 251M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (363:14): [True: 251M, False: 355k] ------------------ 364| 251M| sum = 0; 365| 251M| switch(order) { ------------------ | Branch (365:11): [True: 251M, False: 0] ------------------ 366| 11.5M| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (366:5): [True: 11.5M, False: 239M] ------------------ 367| 23.5M| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (367:5): [True: 12.0M, False: 239M] ------------------ 368| 36.0M| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (368:5): [True: 12.5M, False: 239M] ------------------ 369| 48.5M| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (369:5): [True: 12.5M, False: 239M] ------------------ 370| 61.1M| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (370:5): [True: 12.5M, False: 239M] ------------------ 371| 73.6M| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (371:5): [True: 12.5M, False: 239M] ------------------ 372| 86.1M| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (372:5): [True: 12.5M, False: 239M] ------------------ 373| 98.6M| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (373:5): [True: 12.5M, False: 238M] ------------------ 374| 111M| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (374:5): [True: 12.5M, False: 238M] ------------------ 375| 123M| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (375:5): [True: 12.5M, False: 238M] ------------------ 376| 136M| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (376:5): [True: 12.5M, False: 238M] ------------------ 377| 148M| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (377:5): [True: 12.5M, False: 238M] ------------------ 378| 161M| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (378:5): [True: 12.5M, False: 238M] ------------------ 379| 174M| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (379:5): [True: 12.5M, False: 238M] ------------------ 380| 186M| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (380:5): [True: 12.5M, False: 238M] ------------------ 381| 199M| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (381:5): [True: 12.6M, False: 238M] ------------------ 382| 211M| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (382:5): [True: 12.6M, False: 238M] ------------------ 383| 224M| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (383:5): [True: 12.9M, False: 238M] ------------------ 384| 238M| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (384:5): [True: 13.2M, False: 238M] ------------------ 385| 251M| case 13: sum += qlp_coeff[12] * data[i-13]; ------------------ | Branch (385:5): [True: 13.3M, False: 238M] ------------------ 386| 251M| sum += qlp_coeff[11] * data[i-12]; 387| 251M| sum += qlp_coeff[10] * data[i-11]; 388| 251M| sum += qlp_coeff[ 9] * data[i-10]; 389| 251M| sum += qlp_coeff[ 8] * data[i- 9]; 390| 251M| sum += qlp_coeff[ 7] * data[i- 8]; 391| 251M| sum += qlp_coeff[ 6] * data[i- 7]; 392| 251M| sum += qlp_coeff[ 5] * data[i- 6]; 393| 251M| sum += qlp_coeff[ 4] * data[i- 5]; 394| 251M| sum += qlp_coeff[ 3] * data[i- 4]; 395| 251M| sum += qlp_coeff[ 2] * data[i- 3]; 396| 251M| sum += qlp_coeff[ 1] * data[i- 2]; 397| 251M| sum += qlp_coeff[ 0] * data[i- 1]; 398| 251M| } 399| 251M| residual[i] = data[i] - (sum >> lp_quantization); 400| 251M| } 401| 355k| } 402| 1.58M| _mm256_zeroupper(); 403| 1.58M|} FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2: 407| 1.89M|{ 408| 1.89M| int i; 409| 1.89M| FLAC__int32 sum; 410| 1.89M| const __m128i cnt = _mm_cvtsi32_si128(lp_quantization); 411| | 412| 1.89M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.89M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.89M] | | ------------------ ------------------ 413| 1.89M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.89M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.89M] | | ------------------ ------------------ 414| | 415| 1.89M| if(order <= 12) { ------------------ | Branch (415:5): [True: 1.59M, False: 299k] ------------------ 416| 1.59M| if(order > 8) { ------------------ | Branch (416:6): [True: 437k, False: 1.16M] ------------------ 417| 437k| if(order > 10) { ------------------ | Branch (417:7): [True: 215k, False: 221k] ------------------ 418| 215k| if(order == 12) { ------------------ | Branch (418:8): [True: 106k, False: 108k] ------------------ 419| 106k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11; 420| 106k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 421| 106k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 422| 106k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 423| 106k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 424| 106k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 425| 106k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 426| 106k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 427| 106k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 428| 106k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 429| 106k| q9 = _mm256_set1_epi32(qlp_coeff[9 ]); 430| 106k| q10 = _mm256_set1_epi32(qlp_coeff[10]); 431| 106k| q11 = _mm256_set1_epi32(qlp_coeff[11]); 432| | 433| 1.05M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (433:17): [True: 952k, False: 106k] ------------------ 434| 952k| __m256i summ, mull; 435| 952k| summ = _mm256_mullo_epi32(q11, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-12))); 436| 952k| mull = _mm256_mullo_epi32(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); summ = _mm256_add_epi32(summ, mull); 437| 952k| mull = _mm256_mullo_epi32(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 438| 952k| mull = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); summ = _mm256_add_epi32(summ, mull); 439| 952k| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 440| 952k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 441| 952k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 442| 952k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 443| 952k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 444| 952k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 445| 952k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 446| 952k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 447| 952k| summ = _mm256_sra_epi32(summ, cnt); 448| 952k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 449| 952k| } 450| 106k| } 451| 108k| else { /* order == 11 */ 452| 108k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10; 453| 108k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 454| 108k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 455| 108k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 456| 108k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 457| 108k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 458| 108k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 459| 108k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 460| 108k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 461| 108k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 462| 108k| q9 = _mm256_set1_epi32(qlp_coeff[9 ]); 463| 108k| q10 = _mm256_set1_epi32(qlp_coeff[10]); 464| | 465| 1.07M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (465:17): [True: 961k, False: 108k] ------------------ 466| 961k| __m256i summ, mull; 467| 961k| summ = _mm256_mullo_epi32(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); 468| 961k| mull = _mm256_mullo_epi32(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 469| 961k| mull = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); summ = _mm256_add_epi32(summ, mull); 470| 961k| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 471| 961k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 472| 961k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 473| 961k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 474| 961k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 475| 961k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 476| 961k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 477| 961k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 478| 961k| summ = _mm256_sra_epi32(summ, cnt); 479| 961k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 480| 961k| } 481| 108k| } 482| 215k| } 483| 221k| else { 484| 221k| if(order == 10) { ------------------ | Branch (484:8): [True: 110k, False: 111k] ------------------ 485| 110k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9; 486| 110k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 487| 110k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 488| 110k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 489| 110k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 490| 110k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 491| 110k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 492| 110k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 493| 110k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 494| 110k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 495| 110k| q9 = _mm256_set1_epi32(qlp_coeff[9 ]); 496| | 497| 1.07M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (497:17): [True: 966k, False: 110k] ------------------ 498| 966k| __m256i summ, mull; 499| 966k| summ = _mm256_mullo_epi32(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); 500| 966k| mull = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); summ = _mm256_add_epi32(summ, mull); 501| 966k| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 502| 966k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 503| 966k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 504| 966k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 505| 966k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 506| 966k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 507| 966k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 508| 966k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 509| 966k| summ = _mm256_sra_epi32(summ, cnt); 510| 966k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 511| 966k| } 512| 110k| } 513| 111k| else { /* order == 9 */ 514| 111k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8; 515| 111k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 516| 111k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 517| 111k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 518| 111k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 519| 111k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 520| 111k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 521| 111k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 522| 111k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 523| 111k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 524| | 525| 1.15M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (525:17): [True: 1.04M, False: 111k] ------------------ 526| 1.04M| __m256i summ, mull; 527| 1.04M| summ = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); 528| 1.04M| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 529| 1.04M| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 530| 1.04M| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 531| 1.04M| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 532| 1.04M| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 533| 1.04M| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 534| 1.04M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 535| 1.04M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 536| 1.04M| summ = _mm256_sra_epi32(summ, cnt); 537| 1.04M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 538| 1.04M| } 539| 111k| } 540| 221k| } 541| 437k| } 542| 1.16M| else if(order > 4) { ------------------ | Branch (542:11): [True: 499k, False: 661k] ------------------ 543| 499k| if(order > 6) { ------------------ | Branch (543:7): [True: 237k, False: 262k] ------------------ 544| 237k| if(order == 8) { ------------------ | Branch (544:8): [True: 114k, False: 122k] ------------------ 545| 114k| __m256i q0, q1, q2, q3, q4, q5, q6, q7; 546| 114k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 547| 114k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 548| 114k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 549| 114k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 550| 114k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 551| 114k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 552| 114k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 553| 114k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 554| | 555| 1.21M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (555:17): [True: 1.10M, False: 114k] ------------------ 556| 1.10M| __m256i summ, mull; 557| 1.10M| summ = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); 558| 1.10M| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 559| 1.10M| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 560| 1.10M| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 561| 1.10M| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 562| 1.10M| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 563| 1.10M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 564| 1.10M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 565| 1.10M| summ = _mm256_sra_epi32(summ, cnt); 566| 1.10M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 567| 1.10M| } 568| 114k| } 569| 122k| else { /* order == 7 */ 570| 122k| __m256i q0, q1, q2, q3, q4, q5, q6; 571| 122k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 572| 122k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 573| 122k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 574| 122k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 575| 122k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 576| 122k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 577| 122k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 578| | 579| 1.37M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (579:17): [True: 1.25M, False: 122k] ------------------ 580| 1.25M| __m256i summ, mull; 581| 1.25M| summ = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); 582| 1.25M| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 583| 1.25M| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 584| 1.25M| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 585| 1.25M| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 586| 1.25M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 587| 1.25M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 588| 1.25M| summ = _mm256_sra_epi32(summ, cnt); 589| 1.25M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 590| 1.25M| } 591| 122k| } 592| 237k| } 593| 262k| else { 594| 262k| if(order == 6) { ------------------ | Branch (594:8): [True: 126k, False: 135k] ------------------ 595| 126k| __m256i q0, q1, q2, q3, q4, q5; 596| 126k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 597| 126k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 598| 126k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 599| 126k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 600| 126k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 601| 126k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 602| | 603| 1.38M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (603:17): [True: 1.26M, False: 126k] ------------------ 604| 1.26M| __m256i summ, mull; 605| 1.26M| summ = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); 606| 1.26M| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 607| 1.26M| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 608| 1.26M| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 609| 1.26M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 610| 1.26M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 611| 1.26M| summ = _mm256_sra_epi32(summ, cnt); 612| 1.26M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 613| 1.26M| } 614| 126k| } 615| 135k| else { /* order == 5 */ 616| 135k| __m256i q0, q1, q2, q3, q4; 617| 135k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 618| 135k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 619| 135k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 620| 135k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 621| 135k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 622| | 623| 1.42M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (623:17): [True: 1.28M, False: 135k] ------------------ 624| 1.28M| __m256i summ, mull; 625| 1.28M| summ = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); 626| 1.28M| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 627| 1.28M| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 628| 1.28M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 629| 1.28M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 630| 1.28M| summ = _mm256_sra_epi32(summ, cnt); 631| 1.28M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 632| 1.28M| } 633| 135k| } 634| 262k| } 635| 499k| } 636| 661k| else { 637| 661k| if(order > 2) { ------------------ | Branch (637:7): [True: 292k, False: 368k] ------------------ 638| 292k| if(order == 4) { ------------------ | Branch (638:8): [True: 141k, False: 151k] ------------------ 639| 141k| __m256i q0, q1, q2, q3; 640| 141k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 641| 141k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 642| 141k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 643| 141k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 644| | 645| 1.49M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (645:17): [True: 1.35M, False: 141k] ------------------ 646| 1.35M| __m256i summ, mull; 647| 1.35M| summ = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); 648| 1.35M| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 649| 1.35M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 650| 1.35M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 651| 1.35M| summ = _mm256_sra_epi32(summ, cnt); 652| 1.35M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 653| 1.35M| } 654| 141k| } 655| 151k| else { /* order == 3 */ 656| 151k| __m256i q0, q1, q2; 657| 151k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 658| 151k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 659| 151k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 660| | 661| 1.55M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (661:17): [True: 1.40M, False: 151k] ------------------ 662| 1.40M| __m256i summ, mull; 663| 1.40M| summ = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); 664| 1.40M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 665| 1.40M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 666| 1.40M| summ = _mm256_sra_epi32(summ, cnt); 667| 1.40M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 668| 1.40M| } 669| 151k| } 670| 292k| } 671| 368k| else { 672| 368k| if(order == 2) { ------------------ | Branch (672:8): [True: 157k, False: 211k] ------------------ 673| 157k| __m256i q0, q1; 674| 157k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 675| 157k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 676| | 677| 1.79M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (677:17): [True: 1.63M, False: 157k] ------------------ 678| 1.63M| __m256i summ, mull; 679| 1.63M| summ = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); 680| 1.63M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 681| 1.63M| summ = _mm256_sra_epi32(summ, cnt); 682| 1.63M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 683| 1.63M| } 684| 157k| } 685| 211k| else { /* order == 1 */ 686| 211k| __m256i q0; 687| 211k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 688| | 689| 2.18M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (689:17): [True: 1.97M, False: 211k] ------------------ 690| 1.97M| __m256i summ; 691| 1.97M| summ = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); 692| 1.97M| summ = _mm256_sra_epi32(summ, cnt); 693| 1.97M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 694| 1.97M| } 695| 211k| } 696| 368k| } 697| 661k| } 698| 7.53M| for(; i < (int)data_len; i++) { ------------------ | Branch (698:9): [True: 5.93M, False: 1.59M] ------------------ 699| 5.93M| sum = 0; 700| 5.93M| switch(order) { ------------------ | Branch (700:11): [True: 5.97M, False: 18.4E] ------------------ 701| 424k| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (701:5): [True: 424k, False: 5.51M] ------------------ 702| 923k| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (702:5): [True: 498k, False: 5.43M] ------------------ 703| 1.52M| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (703:5): [True: 602k, False: 5.33M] ------------------ 704| 1.79M| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (704:5): [True: 266k, False: 5.66M] ------------------ 705| 1.97M| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (705:5): [True: 177k, False: 5.75M] ------------------ 706| 2.26M| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (706:5): [True: 294k, False: 5.64M] ------------------ 707| 2.68M| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (707:5): [True: 419k, False: 5.51M] ------------------ 708| 3.25M| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (708:5): [True: 570k, False: 5.36M] ------------------ 709| 3.80M| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (709:5): [True: 550k, False: 5.38M] ------------------ 710| 4.48M| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (710:5): [True: 678k, False: 5.25M] ------------------ 711| 5.33M| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (711:5): [True: 847k, False: 5.08M] ------------------ 712| 5.97M| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (712:5): [True: 639k, False: 5.29M] ------------------ 713| 5.93M| } 714| 5.93M| residual[i] = data[i] - (sum >> lp_quantization); 715| 5.93M| } 716| 1.59M| } 717| 299k| else { /* order > 12 */ 718| 133M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (718:14): [True: 133M, False: 299k] ------------------ 719| 133M| sum = 0; 720| 133M| switch(order) { ------------------ | Branch (720:11): [True: 133M, False: 18.4E] ------------------ 721| 6.28M| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (721:5): [True: 6.28M, False: 126M] ------------------ 722| 12.6M| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (722:5): [True: 6.38M, False: 126M] ------------------ 723| 19.0M| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (723:5): [True: 6.41M, False: 126M] ------------------ 724| 25.4M| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (724:5): [True: 6.40M, False: 126M] ------------------ 725| 31.8M| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (725:5): [True: 6.40M, False: 126M] ------------------ 726| 38.3M| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (726:5): [True: 6.42M, False: 126M] ------------------ 727| 44.7M| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (727:5): [True: 6.41M, False: 126M] ------------------ 728| 51.1M| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (728:5): [True: 6.42M, False: 126M] ------------------ 729| 57.6M| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (729:5): [True: 6.47M, False: 126M] ------------------ 730| 64.1M| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (730:5): [True: 6.48M, False: 126M] ------------------ 731| 70.5M| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (731:5): [True: 6.49M, False: 126M] ------------------ 732| 77.1M| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (732:5): [True: 6.51M, False: 126M] ------------------ 733| 83.6M| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (733:5): [True: 6.54M, False: 126M] ------------------ 734| 90.2M| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (734:5): [True: 6.57M, False: 126M] ------------------ 735| 96.9M| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (735:5): [True: 6.72M, False: 126M] ------------------ 736| 103M| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (736:5): [True: 6.81M, False: 126M] ------------------ 737| 110M| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (737:5): [True: 6.84M, False: 126M] ------------------ 738| 117M| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (738:5): [True: 6.88M, False: 126M] ------------------ 739| 125M| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (739:5): [True: 7.65M, False: 125M] ------------------ 740| 133M| case 13: sum += qlp_coeff[12] * data[i-13]; ------------------ | Branch (740:5): [True: 7.90M, False: 125M] ------------------ 741| 133M| sum += qlp_coeff[11] * data[i-12]; 742| 133M| sum += qlp_coeff[10] * data[i-11]; 743| 133M| sum += qlp_coeff[ 9] * data[i-10]; 744| 133M| sum += qlp_coeff[ 8] * data[i- 9]; 745| 133M| sum += qlp_coeff[ 7] * data[i- 8]; 746| 133M| sum += qlp_coeff[ 6] * data[i- 7]; 747| 133M| sum += qlp_coeff[ 5] * data[i- 6]; 748| 133M| sum += qlp_coeff[ 4] * data[i- 5]; 749| 133M| sum += qlp_coeff[ 3] * data[i- 4]; 750| 133M| sum += qlp_coeff[ 2] * data[i- 3]; 751| 133M| sum += qlp_coeff[ 1] * data[i- 2]; 752| 133M| sum += qlp_coeff[ 0] * data[i- 1]; 753| 133M| } 754| 133M| residual[i] = data[i] - (sum >> lp_quantization); 755| 133M| } 756| 299k| } 757| 1.89M| _mm256_zeroupper(); 758| 1.89M|} FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2: 764| 3.23M|{ 765| 3.23M| int i; 766| 3.23M| FLAC__int64 sum; 767| 3.23M| const __m128i cnt = _mm_cvtsi32_si128(lp_quantization); 768| 3.23M| const __m256i pack = _mm256_loadu_si256((const __m256i *)(const void*)pack_arr); 769| | 770| 3.23M| FLAC__ASSERT(order > 0); ------------------ | | 38| 3.23M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.23M] | | ------------------ ------------------ 771| 3.23M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 3.23M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.23M] | | ------------------ ------------------ 772| 3.23M| FLAC__ASSERT(lp_quantization <= 32); /* there's no _mm256_sra_epi64() so we have to use _mm256_srl_epi64() */ ------------------ | | 38| 3.23M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.23M] | | ------------------ ------------------ 773| | 774| 3.23M| if(order <= 12) { ------------------ | Branch (774:5): [True: 2.60M, False: 628k] ------------------ 775| 2.60M| if(order > 8) { ------------------ | Branch (775:6): [True: 899k, False: 1.71M] ------------------ 776| 899k| if(order > 10) { ------------------ | Branch (776:7): [True: 452k, False: 446k] ------------------ 777| 452k| if(order == 12) { ------------------ | Branch (777:8): [True: 226k, False: 225k] ------------------ 778| 226k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11; 779| 226k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 780| 226k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 781| 226k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 782| 226k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 783| 226k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 784| 226k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 785| 226k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 786| 226k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 787| 226k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 788| 226k| q9 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[9 ])); 789| 226k| q10 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[10])); 790| 226k| q11 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[11])); 791| | 792| 5.91M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (792:17): [True: 5.68M, False: 226k] ------------------ 793| 5.68M| __m256i summ, mull; 794| 5.68M| summ = _mm256_mul_epi32(q11, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-12)))); 795| 5.68M| mull = _mm256_mul_epi32(q10, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-11)))); summ = _mm256_add_epi64(summ, mull); 796| 5.68M| mull = _mm256_mul_epi32(q9, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-10)))); summ = _mm256_add_epi64(summ, mull); 797| 5.68M| mull = _mm256_mul_epi32(q8, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-9 )))); summ = _mm256_add_epi64(summ, mull); 798| 5.68M| mull = _mm256_mul_epi32(q7, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-8 )))); summ = _mm256_add_epi64(summ, mull); 799| 5.68M| mull = _mm256_mul_epi32(q6, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-7 )))); summ = _mm256_add_epi64(summ, mull); 800| 5.68M| mull = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); summ = _mm256_add_epi64(summ, mull); 801| 5.68M| mull = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); summ = _mm256_add_epi64(summ, mull); 802| 5.68M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 803| 5.68M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 804| 5.68M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 805| 5.68M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 806| 5.68M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 807| 5.68M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 808| 5.68M| } 809| 226k| } 810| 225k| else { /* order == 11 */ 811| 225k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10; 812| 225k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 813| 225k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 814| 225k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 815| 225k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 816| 225k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 817| 225k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 818| 225k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 819| 225k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 820| 225k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 821| 225k| q9 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[9 ])); 822| 225k| q10 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[10])); 823| | 824| 5.89M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (824:17): [True: 5.67M, False: 225k] ------------------ 825| 5.67M| __m256i summ, mull; 826| 5.67M| summ = _mm256_mul_epi32(q10, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-11)))); 827| 5.67M| mull = _mm256_mul_epi32(q9, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-10)))); summ = _mm256_add_epi64(summ, mull); 828| 5.67M| mull = _mm256_mul_epi32(q8, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-9 )))); summ = _mm256_add_epi64(summ, mull); 829| 5.67M| mull = _mm256_mul_epi32(q7, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-8 )))); summ = _mm256_add_epi64(summ, mull); 830| 5.67M| mull = _mm256_mul_epi32(q6, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-7 )))); summ = _mm256_add_epi64(summ, mull); 831| 5.67M| mull = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); summ = _mm256_add_epi64(summ, mull); 832| 5.67M| mull = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); summ = _mm256_add_epi64(summ, mull); 833| 5.67M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 834| 5.67M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 835| 5.67M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 836| 5.67M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 837| 5.67M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 838| 5.67M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 839| 5.67M| } 840| 225k| } 841| 452k| } 842| 446k| else { 843| 446k| if(order == 10) { ------------------ | Branch (843:8): [True: 225k, False: 221k] ------------------ 844| 225k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9; 845| 225k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 846| 225k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 847| 225k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 848| 225k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 849| 225k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 850| 225k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 851| 225k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 852| 225k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 853| 225k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 854| 225k| q9 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[9 ])); 855| | 856| 5.91M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (856:17): [True: 5.68M, False: 225k] ------------------ 857| 5.68M| __m256i summ, mull; 858| 5.68M| summ = _mm256_mul_epi32(q9, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-10)))); 859| 5.68M| mull = _mm256_mul_epi32(q8, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-9 )))); summ = _mm256_add_epi64(summ, mull); 860| 5.68M| mull = _mm256_mul_epi32(q7, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-8 )))); summ = _mm256_add_epi64(summ, mull); 861| 5.68M| mull = _mm256_mul_epi32(q6, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-7 )))); summ = _mm256_add_epi64(summ, mull); 862| 5.68M| mull = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); summ = _mm256_add_epi64(summ, mull); 863| 5.68M| mull = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); summ = _mm256_add_epi64(summ, mull); 864| 5.68M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 865| 5.68M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 866| 5.68M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 867| 5.68M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 868| 5.68M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 869| 5.68M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 870| 5.68M| } 871| 225k| } 872| 221k| else { /* order == 9 */ 873| 221k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8; 874| 221k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 875| 221k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 876| 221k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 877| 221k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 878| 221k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 879| 221k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 880| 221k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 881| 221k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 882| 221k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 883| | 884| 6.06M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (884:17): [True: 5.83M, False: 221k] ------------------ 885| 5.83M| __m256i summ, mull; 886| 5.83M| summ = _mm256_mul_epi32(q8, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-9 )))); 887| 5.83M| mull = _mm256_mul_epi32(q7, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-8 )))); summ = _mm256_add_epi64(summ, mull); 888| 5.83M| mull = _mm256_mul_epi32(q6, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-7 )))); summ = _mm256_add_epi64(summ, mull); 889| 5.83M| mull = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); summ = _mm256_add_epi64(summ, mull); 890| 5.83M| mull = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); summ = _mm256_add_epi64(summ, mull); 891| 5.83M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 892| 5.83M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 893| 5.83M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 894| 5.83M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 895| 5.83M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 896| 5.83M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 897| 5.83M| } 898| 221k| } 899| 446k| } 900| 899k| } 901| 1.71M| else if(order > 4) { ------------------ | Branch (901:11): [True: 877k, False: 832k] ------------------ 902| 877k| if(order > 6) { ------------------ | Branch (902:7): [True: 444k, False: 432k] ------------------ 903| 444k| if(order == 8) { ------------------ | Branch (903:8): [True: 224k, False: 220k] ------------------ 904| 224k| __m256i q0, q1, q2, q3, q4, q5, q6, q7; 905| 224k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 906| 224k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 907| 224k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 908| 224k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 909| 224k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 910| 224k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 911| 224k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 912| 224k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 913| | 914| 6.09M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (914:17): [True: 5.86M, False: 224k] ------------------ 915| 5.86M| __m256i summ, mull; 916| 5.86M| summ = _mm256_mul_epi32(q7, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-8 )))); 917| 5.86M| mull = _mm256_mul_epi32(q6, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-7 )))); summ = _mm256_add_epi64(summ, mull); 918| 5.86M| mull = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); summ = _mm256_add_epi64(summ, mull); 919| 5.86M| mull = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); summ = _mm256_add_epi64(summ, mull); 920| 5.86M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 921| 5.86M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 922| 5.86M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 923| 5.86M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 924| 5.86M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 925| 5.86M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 926| 5.86M| } 927| 224k| } 928| 220k| else { /* order == 7 */ 929| 220k| __m256i q0, q1, q2, q3, q4, q5, q6; 930| 220k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 931| 220k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 932| 220k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 933| 220k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 934| 220k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 935| 220k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 936| 220k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 937| | 938| 5.80M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (938:17): [True: 5.58M, False: 220k] ------------------ 939| 5.58M| __m256i summ, mull; 940| 5.58M| summ = _mm256_mul_epi32(q6, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-7 )))); 941| 5.58M| mull = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); summ = _mm256_add_epi64(summ, mull); 942| 5.58M| mull = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); summ = _mm256_add_epi64(summ, mull); 943| 5.58M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 944| 5.58M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 945| 5.58M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 946| 5.58M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 947| 5.58M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 948| 5.58M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 949| 5.58M| } 950| 220k| } 951| 444k| } 952| 432k| else { 953| 432k| if(order == 6) { ------------------ | Branch (953:8): [True: 218k, False: 213k] ------------------ 954| 218k| __m256i q0, q1, q2, q3, q4, q5; 955| 218k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 956| 218k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 957| 218k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 958| 218k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 959| 218k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 960| 218k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 961| | 962| 5.78M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (962:17): [True: 5.56M, False: 218k] ------------------ 963| 5.56M| __m256i summ, mull; 964| 5.56M| summ = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); 965| 5.56M| mull = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); summ = _mm256_add_epi64(summ, mull); 966| 5.56M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 967| 5.56M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 968| 5.56M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 969| 5.56M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 970| 5.56M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 971| 5.56M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 972| 5.56M| } 973| 218k| } 974| 213k| else { /* order == 5 */ 975| 213k| __m256i q0, q1, q2, q3, q4; 976| 213k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 977| 213k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 978| 213k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 979| 213k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 980| 213k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 981| | 982| 5.89M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (982:17): [True: 5.68M, False: 213k] ------------------ 983| 5.68M| __m256i summ, mull; 984| 5.68M| summ = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); 985| 5.68M| mull = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); summ = _mm256_add_epi64(summ, mull); 986| 5.68M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 987| 5.68M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 988| 5.68M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 989| 5.68M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 990| 5.68M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 991| 5.68M| } 992| 213k| } 993| 432k| } 994| 877k| } 995| 832k| else { 996| 832k| if(order > 2) { ------------------ | Branch (996:7): [True: 422k, False: 410k] ------------------ 997| 422k| if(order == 4) { ------------------ | Branch (997:8): [True: 216k, False: 205k] ------------------ 998| 216k| __m256i q0, q1, q2, q3; 999| 216k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1000| 216k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 1001| 216k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 1002| 216k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 1003| | 1004| 5.86M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1004:17): [True: 5.65M, False: 216k] ------------------ 1005| 5.65M| __m256i summ, mull; 1006| 5.65M| summ = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); 1007| 5.65M| mull = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); summ = _mm256_add_epi64(summ, mull); 1008| 5.65M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 1009| 5.65M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 1010| 5.65M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1011| 5.65M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 1012| 5.65M| } 1013| 216k| } 1014| 205k| else { /* order == 3 */ 1015| 205k| __m256i q0, q1, q2; 1016| 205k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1017| 205k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 1018| 205k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 1019| | 1020| 5.78M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1020:17): [True: 5.58M, False: 205k] ------------------ 1021| 5.58M| __m256i summ, mull; 1022| 5.58M| summ = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); 1023| 5.58M| mull = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); summ = _mm256_add_epi64(summ, mull); 1024| 5.58M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 1025| 5.58M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1026| 5.58M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 1027| 5.58M| } 1028| 205k| } 1029| 422k| } 1030| 410k| else { 1031| 410k| if(order == 2) { ------------------ | Branch (1031:8): [True: 198k, False: 212k] ------------------ 1032| 198k| __m256i q0, q1; 1033| 198k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1034| 198k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 1035| | 1036| 5.29M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1036:17): [True: 5.09M, False: 198k] ------------------ 1037| 5.09M| __m256i summ, mull; 1038| 5.09M| summ = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); 1039| 5.09M| mull = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); summ = _mm256_add_epi64(summ, mull); 1040| 5.09M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1041| 5.09M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 1042| 5.09M| } 1043| 198k| } 1044| 212k| else { /* order == 1 */ 1045| 212k| __m256i q0; 1046| 212k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1047| | 1048| 5.39M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1048:17): [True: 5.18M, False: 212k] ------------------ 1049| 5.18M| __m256i summ; 1050| 5.18M| summ = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); 1051| 5.18M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1052| 5.18M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 1053| 5.18M| } 1054| 212k| } 1055| 410k| } 1056| 832k| } 1057| 6.44M| for(; i < (int)data_len; i++) { ------------------ | Branch (1057:9): [True: 3.84M, False: 2.60M] ------------------ 1058| 3.84M| sum = 0; 1059| 3.84M| switch(order) { ------------------ | Branch (1059:11): [True: 3.88M, False: 18.4E] ------------------ 1060| 161k| case 12: sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; /* Falls through. */ ------------------ | Branch (1060:5): [True: 161k, False: 3.67M] ------------------ 1061| 523k| case 11: sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; /* Falls through. */ ------------------ | Branch (1061:5): [True: 362k, False: 3.47M] ------------------ 1062| 1.09M| case 10: sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; /* Falls through. */ ------------------ | Branch (1062:5): [True: 572k, False: 3.26M] ------------------ 1063| 1.35M| case 9: sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; /* Falls through. */ ------------------ | Branch (1063:5): [True: 258k, False: 3.58M] ------------------ 1064| 1.51M| case 8: sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; /* Falls through. */ ------------------ | Branch (1064:5): [True: 159k, False: 3.68M] ------------------ 1065| 1.86M| case 7: sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; /* Falls through. */ ------------------ | Branch (1065:5): [True: 353k, False: 3.48M] ------------------ 1066| 2.42M| case 6: sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; /* Falls through. */ ------------------ | Branch (1066:5): [True: 552k, False: 3.28M] ------------------ 1067| 2.67M| case 5: sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; /* Falls through. */ ------------------ | Branch (1067:5): [True: 249k, False: 3.59M] ------------------ 1068| 2.83M| case 4: sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; /* Falls through. */ ------------------ | Branch (1068:5): [True: 162k, False: 3.67M] ------------------ 1069| 3.16M| case 3: sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; /* Falls through. */ ------------------ | Branch (1069:5): [True: 333k, False: 3.50M] ------------------ 1070| 3.66M| case 2: sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; /* Falls through. */ ------------------ | Branch (1070:5): [True: 501k, False: 3.33M] ------------------ 1071| 3.88M| case 1: sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; ------------------ | Branch (1071:5): [True: 218k, False: 3.62M] ------------------ 1072| 3.84M| } 1073| 3.84M| residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization); 1074| 3.83M| } 1075| 2.60M| } 1076| 628k| else { /* order > 12 */ 1077| 207M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1077:14): [True: 206M, False: 629k] ------------------ 1078| 206M| sum = 0; 1079| 206M| switch(order) { ------------------ | Branch (1079:11): [True: 206M, False: 18.4E] ------------------ 1080| 8.72M| case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */ ------------------ | Branch (1080:5): [True: 8.72M, False: 197M] ------------------ 1081| 17.6M| case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */ ------------------ | Branch (1081:5): [True: 8.94M, False: 197M] ------------------ 1082| 26.5M| case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */ ------------------ | Branch (1082:5): [True: 8.86M, False: 197M] ------------------ 1083| 35.4M| case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */ ------------------ | Branch (1083:5): [True: 8.89M, False: 197M] ------------------ 1084| 44.3M| case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */ ------------------ | Branch (1084:5): [True: 8.89M, False: 197M] ------------------ 1085| 53.2M| case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */ ------------------ | Branch (1085:5): [True: 8.89M, False: 197M] ------------------ 1086| 62.1M| case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */ ------------------ | Branch (1086:5): [True: 8.91M, False: 197M] ------------------ 1087| 71.0M| case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */ ------------------ | Branch (1087:5): [True: 8.91M, False: 197M] ------------------ 1088| 80.0M| case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */ ------------------ | Branch (1088:5): [True: 8.98M, False: 197M] ------------------ 1089| 89.0M| case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */ ------------------ | Branch (1089:5): [True: 8.98M, False: 197M] ------------------ 1090| 98.0M| case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */ ------------------ | Branch (1090:5): [True: 8.98M, False: 197M] ------------------ 1091| 107M| case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */ ------------------ | Branch (1091:5): [True: 8.98M, False: 197M] ------------------ 1092| 115M| case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */ ------------------ | Branch (1092:5): [True: 8.91M, False: 197M] ------------------ 1093| 124M| case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */ ------------------ | Branch (1093:5): [True: 8.90M, False: 197M] ------------------ 1094| 133M| case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */ ------------------ | Branch (1094:5): [True: 8.77M, False: 197M] ------------------ 1095| 142M| case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */ ------------------ | Branch (1095:5): [True: 8.70M, False: 197M] ------------------ 1096| 151M| case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */ ------------------ | Branch (1096:5): [True: 8.78M, False: 197M] ------------------ 1097| 159M| case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */ ------------------ | Branch (1097:5): [True: 8.73M, False: 197M] ------------------ 1098| 183M| case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */ ------------------ | Branch (1098:5): [True: 24.1M, False: 182M] ------------------ 1099| 206M| case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13]; ------------------ | Branch (1099:5): [True: 22.6M, False: 183M] ------------------ 1100| 206M| sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; 1101| 206M| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1102| 206M| sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; 1103| 206M| sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; 1104| 206M| sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; 1105| 206M| sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; 1106| 206M| sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; 1107| 206M| sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; 1108| 206M| sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; 1109| 206M| sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; 1110| 206M| sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; 1111| 206M| sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; 1112| 206M| } 1113| 206M| residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization); 1114| 206M| } 1115| 628k| } 1116| 3.23M| _mm256_zeroupper(); 1117| 3.23M|} FLAC__lpc_compute_autocorrelation_intrin_fma_lag_8: 48| 3.89k|{ 49| 3.89k|#undef MAX_LAG 50| 3.89k|#define MAX_LAG 8 51| 3.89k|#include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 3.89k| int i, j; | | 2| 3.89k| (void) lag; | | 3| 3.89k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 3.89k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 3.89k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 35.0k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 50| 35.0k|#define MAX_LAG 8 | | ------------------ | | | Branch (5:20): [True: 31.1k, False: 3.89k] | | ------------------ | | 6| 31.1k| autoc[i] = 0.0; | | 7| | | | 8| 35.0k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 50| 35.0k|#define MAX_LAG 8 | | ------------------ | | | Branch (8:20): [True: 31.1k, False: 3.89k] | | ------------------ | | 9| 171k| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 140k, False: 31.1k] | | ------------------ | | 10| 140k| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 4.83M| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 50| 3.89k|#define MAX_LAG 8 | | ------------------ | | | Branch (12:26): [True: 4.83M, False: 3.89k] | | ------------------ | | 13| 43.4M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 50| 43.4M|#define MAX_LAG 8 | | ------------------ | | | Branch (13:14): [True: 38.6M, False: 4.83M] | | ------------------ | | 14| 38.6M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 52| 3.89k|} FLAC__lpc_compute_autocorrelation_intrin_fma_lag_12: 56| 25.4k|{ 57| 25.4k|#undef MAX_LAG 58| 25.4k|#define MAX_LAG 12 59| 25.4k|#include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 25.4k| int i, j; | | 2| 25.4k| (void) lag; | | 3| 25.4k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 25.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 25.4k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 330k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 58| 330k|#define MAX_LAG 12 | | ------------------ | | | Branch (5:20): [True: 304k, False: 25.4k] | | ------------------ | | 6| 304k| autoc[i] = 0.0; | | 7| | | | 8| 330k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 58| 330k|#define MAX_LAG 12 | | ------------------ | | | Branch (8:20): [True: 304k, False: 25.4k] | | ------------------ | | 9| 2.28M| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 1.98M, False: 304k] | | ------------------ | | 10| 1.98M| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 4.31M| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 58| 25.4k|#define MAX_LAG 12 | | ------------------ | | | Branch (12:26): [True: 4.28M, False: 25.4k] | | ------------------ | | 13| 55.7M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 58| 55.7M|#define MAX_LAG 12 | | ------------------ | | | Branch (13:14): [True: 51.4M, False: 4.28M] | | ------------------ | | 14| 51.4M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 60| 25.4k|} FLAC__lpc_compute_autocorrelation_intrin_fma_lag_16: 63| 22.9k|{ 64| 22.9k|#undef MAX_LAG 65| 22.9k|#define MAX_LAG 16 66| 22.9k|#include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 22.9k| int i, j; | | 2| 22.9k| (void) lag; | | 3| 22.9k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 22.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 22.9k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 389k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 65| 389k|#define MAX_LAG 16 | | ------------------ | | | Branch (5:20): [True: 366k, False: 22.9k] | | ------------------ | | 6| 366k| autoc[i] = 0.0; | | 7| | | | 8| 384k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 65| 384k|#define MAX_LAG 16 | | ------------------ | | | Branch (8:20): [True: 361k, False: 22.9k] | | ------------------ | | 9| 3.41M| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 3.05M, False: 361k] | | ------------------ | | 10| 3.05M| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 7.30M| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 65| 22.9k|#define MAX_LAG 16 | | ------------------ | | | Branch (12:26): [True: 7.27M, False: 22.9k] | | ------------------ | | 13| 123M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 65| 123M|#define MAX_LAG 16 | | ------------------ | | | Branch (13:14): [True: 116M, False: 7.27M] | | ------------------ | | 14| 116M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 67| | 68| 22.9k|} FLAC__MD5Init: 224| 17.5k|{ 225| 17.5k| ctx->buf[0] = 0x67452301; 226| 17.5k| ctx->buf[1] = 0xefcdab89; 227| 17.5k| ctx->buf[2] = 0x98badcfe; 228| 17.5k| ctx->buf[3] = 0x10325476; 229| | 230| 17.5k| ctx->bytes[0] = 0; 231| 17.5k| ctx->bytes[1] = 0; 232| | 233| 17.5k| ctx->internal_buf.p8 = 0; 234| 17.5k| ctx->capacity = 0; 235| 17.5k|} FLAC__MD5Final: 242| 17.5k|{ 243| 17.5k| int count = ctx->bytes[0] & 0x3f; /* Number of bytes in ctx->in */ 244| 17.5k| FLAC__byte *p = (FLAC__byte *)ctx->in + count; 245| | 246| | /* Set the first char of padding to 0x80. There is always room. */ 247| 17.5k| *p++ = 0x80; 248| | 249| | /* Bytes of padding needed to make 56 bytes (-8..55) */ 250| 17.5k| count = 56 - 1 - count; 251| | 252| 17.5k| if (count < 0) { /* Padding forces an extra block */ ------------------ | Branch (252:6): [True: 721, False: 16.8k] ------------------ 253| 721| memset(p, 0, count + 8); 254| 721| byteSwapX16(ctx->in); 255| 721| FLAC__MD5Transform(ctx->buf, ctx->in); 256| 721| p = (FLAC__byte *)ctx->in; 257| 721| count = 56; 258| 721| } 259| 17.5k| memset(p, 0, count); 260| 17.5k| byteSwap(ctx->in, 14); 261| | 262| | /* Append length in bits and transform */ 263| 17.5k| ctx->in[14] = ctx->bytes[0] << 3; 264| 17.5k| ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29; 265| 17.5k| FLAC__MD5Transform(ctx->buf, ctx->in); 266| | 267| 17.5k| byteSwap(ctx->buf, 4); 268| 17.5k| memcpy(digest, ctx->buf, 16); 269| 17.5k| if (0 != ctx->internal_buf.p8) { ------------------ | Branch (269:6): [True: 8.54k, False: 8.99k] ------------------ 270| 8.54k| free(ctx->internal_buf.p8); 271| 8.54k| ctx->internal_buf.p8 = 0; 272| 8.54k| ctx->capacity = 0; 273| 8.54k| } 274| 17.5k| memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ 275| 17.5k|} FLAC__MD5Accumulate: 498| 199k|{ 499| 199k| const size_t bytes_needed = (size_t)channels * (size_t)samples * (size_t)bytes_per_sample; 500| | 501| | /* overflow check */ 502| 199k| if ((size_t)channels > SIZE_MAX / (size_t)bytes_per_sample) ------------------ | Branch (502:6): [True: 0, False: 199k] ------------------ 503| 0| return false; 504| 199k| if ((size_t)channels * (size_t)bytes_per_sample > SIZE_MAX / (size_t)samples) ------------------ | Branch (504:6): [True: 0, False: 199k] ------------------ 505| 0| return false; 506| | 507| 199k| if (ctx->capacity < bytes_needed) { ------------------ | Branch (507:6): [True: 9.06k, False: 190k] ------------------ 508| 9.06k| if (0 == (ctx->internal_buf.p8 = safe_realloc_(ctx->internal_buf.p8, bytes_needed))) { ------------------ | Branch (508:7): [True: 0, False: 9.06k] ------------------ 509| 0| if (0 == (ctx->internal_buf.p8 = safe_malloc_(bytes_needed))) { ------------------ | Branch (509:8): [True: 0, False: 0] ------------------ 510| 0| ctx->capacity = 0; 511| 0| return false; 512| 0| } 513| 0| } 514| 9.06k| ctx->capacity = bytes_needed; 515| 9.06k| } 516| | 517| 199k| format_input_(&ctx->internal_buf, signal, channels, samples, bytes_per_sample); 518| | 519| 199k| FLAC__MD5Update(ctx, ctx->internal_buf.p8, bytes_needed); 520| | 521| | return true; 522| 199k|} md5.c:FLAC__MD5Transform: 61| 1.72M|{ 62| 1.72M| register FLAC__uint32 a, b, c, d; 63| | 64| 1.72M| a = buf[0]; 65| 1.72M| b = buf[1]; 66| 1.72M| c = buf[2]; 67| 1.72M| d = buf[3]; 68| | 69| 1.72M| MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 69| 1.72M| MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 70| 1.72M| MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 70| 1.72M| MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 71| 1.72M| MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 71| 1.72M| MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 72| 1.72M| MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 72| 1.72M| MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 73| 1.72M| MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 73| 1.72M| MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 74| 1.72M| MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 74| 1.72M| MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 75| 1.72M| MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 75| 1.72M| MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 76| 1.72M| MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 76| 1.72M| MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 77| 1.72M| MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 77| 1.72M| MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 78| 1.72M| MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 78| 1.72M| MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 79| 1.72M| MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 79| 1.72M| MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 80| 1.72M| MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 80| 1.72M| MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 81| 1.72M| MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 81| 1.72M| MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 82| 1.72M| MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 82| 1.72M| MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 83| 1.72M| MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 83| 1.72M| MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 84| 1.72M| MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 84| 1.72M| MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); | | | | ------------------ | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | ------------------ | | ------------------ ------------------ 85| | 86| 1.72M| MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 86| 1.72M| MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 87| 1.72M| MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 87| 1.72M| MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 88| 1.72M| MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 88| 1.72M| MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 89| 1.72M| MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 89| 1.72M| MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 90| 1.72M| MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 90| 1.72M| MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 91| 1.72M| MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 91| 1.72M| MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 92| 1.72M| MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 92| 1.72M| MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 93| 1.72M| MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 93| 1.72M| MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 94| 1.72M| MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 94| 1.72M| MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 95| 1.72M| MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 95| 1.72M| MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 96| 1.72M| MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 96| 1.72M| MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 97| 1.72M| MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 97| 1.72M| MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 98| 1.72M| MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 98| 1.72M| MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 99| 1.72M| MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 99| 1.72M| MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 100| 1.72M| MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 100| 1.72M| MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 101| 1.72M| MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 101| 1.72M| MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); | | | | ------------------ | | | | | | 42| 1.72M|#define F2(x, y, z) F1(z, x, y) | | | | | | ------------------ | | | | | | | | 41| 1.72M|#define F1(x, y, z) (z ^ (x & (y ^ z))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 102| | 103| 1.72M| MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 103| 1.72M| MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 104| 1.72M| MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 104| 1.72M| MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 105| 1.72M| MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 105| 1.72M| MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 106| 1.72M| MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 106| 1.72M| MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 107| 1.72M| MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 107| 1.72M| MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 108| 1.72M| MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 108| 1.72M| MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 109| 1.72M| MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 109| 1.72M| MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 110| 1.72M| MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 110| 1.72M| MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 111| 1.72M| MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 111| 1.72M| MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 112| 1.72M| MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 112| 1.72M| MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 113| 1.72M| MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 113| 1.72M| MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 114| 1.72M| MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 114| 1.72M| MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 115| 1.72M| MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 115| 1.72M| MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 116| 1.72M| MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 116| 1.72M| MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 117| 1.72M| MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 117| 1.72M| MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 118| 1.72M| MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 118| 1.72M| MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); | | | | ------------------ | | | | | | 43| 1.72M|#define F3(x, y, z) (x ^ y ^ z) | | | | ------------------ | | ------------------ ------------------ 119| | 120| 1.72M| MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 120| 1.72M| MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 121| 1.72M| MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 121| 1.72M| MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 122| 1.72M| MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 122| 1.72M| MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 123| 1.72M| MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 123| 1.72M| MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 124| 1.72M| MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 124| 1.72M| MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 125| 1.72M| MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 125| 1.72M| MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 126| 1.72M| MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 126| 1.72M| MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 127| 1.72M| MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 127| 1.72M| MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 128| 1.72M| MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 128| 1.72M| MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 129| 1.72M| MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 129| 1.72M| MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 130| 1.72M| MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 130| 1.72M| MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 131| 1.72M| MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 131| 1.72M| MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 132| 1.72M| MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 132| 1.72M| MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 133| 1.72M| MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 133| 1.72M| MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 134| 1.72M| MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 134| 1.72M| MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 135| 1.72M| MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); ------------------ | | 48| 1.72M| (w += f(x,y,z) + in, w = (w<>(32-s)) + x) | | ------------------ | | | | 135| 1.72M| MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); | | | | ------------------ | | | | | | 44| 1.72M|#define F4(x, y, z) (y ^ (x | ~z)) | | | | ------------------ | | ------------------ ------------------ 136| | 137| 1.72M| buf[0] += a; 138| 1.72M| buf[1] += b; 139| 1.72M| buf[2] += c; 140| 1.72M| buf[3] += d; 141| 1.72M|} md5.c:format_input_: 281| 199k|{ 282| 199k| FLAC__byte *buf_ = mbuf->p8; 283| 199k| FLAC__int16 *buf16 = mbuf->p16; 284| 199k| FLAC__int32 *buf32 = mbuf->p32; 285| 199k| FLAC__int32 a_word; 286| 199k| uint32_t channel, sample; 287| | 288| | /* Storage in the output buffer, buf, is little endian. */ 289| | 290| 199k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) 291| | 292| | /* First do the most commonly used combinations. */ 293| 199k| switch (BYTES_CHANNEL_SELECTOR (bytes_per_sample, channels)) { ------------------ | | 290| 199k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ 294| | /* One byte per sample. */ 295| 3.12k| case (BYTES_CHANNEL_SELECTOR (1, 1)): ------------------ | | 290| 3.12k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (295:3): [True: 3.12k, False: 196k] ------------------ 296| 1.25M| for (sample = 0; sample < samples; sample++) ------------------ | Branch (296:21): [True: 1.24M, False: 3.12k] ------------------ 297| 1.24M| *buf_++ = signal[0][sample]; 298| 3.12k| return; 299| | 300| 1.07k| case (BYTES_CHANNEL_SELECTOR (1, 2)): ------------------ | | 290| 1.07k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (300:3): [True: 1.07k, False: 198k] ------------------ 301| 27.0k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (301:21): [True: 25.9k, False: 1.07k] ------------------ 302| 25.9k| *buf_++ = signal[0][sample]; 303| 25.9k| *buf_++ = signal[1][sample]; 304| 25.9k| } 305| 1.07k| return; 306| | 307| 434| case (BYTES_CHANNEL_SELECTOR (1, 4)): ------------------ | | 290| 434|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (307:3): [True: 434, False: 199k] ------------------ 308| 7.54k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (308:21): [True: 7.11k, False: 434] ------------------ 309| 7.11k| *buf_++ = signal[0][sample]; 310| 7.11k| *buf_++ = signal[1][sample]; 311| 7.11k| *buf_++ = signal[2][sample]; 312| 7.11k| *buf_++ = signal[3][sample]; 313| 7.11k| } 314| 434| return; 315| | 316| 202| case (BYTES_CHANNEL_SELECTOR (1, 6)): ------------------ | | 290| 202|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (316:3): [True: 202, False: 199k] ------------------ 317| 3.26k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (317:21): [True: 3.05k, False: 202] ------------------ 318| 3.05k| *buf_++ = signal[0][sample]; 319| 3.05k| *buf_++ = signal[1][sample]; 320| 3.05k| *buf_++ = signal[2][sample]; 321| 3.05k| *buf_++ = signal[3][sample]; 322| 3.05k| *buf_++ = signal[4][sample]; 323| 3.05k| *buf_++ = signal[5][sample]; 324| 3.05k| } 325| 202| return; 326| | 327| 226| case (BYTES_CHANNEL_SELECTOR (1, 8)): ------------------ | | 290| 226|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (327:3): [True: 226, False: 199k] ------------------ 328| 3.74k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (328:21): [True: 3.51k, False: 226] ------------------ 329| 3.51k| *buf_++ = signal[0][sample]; 330| 3.51k| *buf_++ = signal[1][sample]; 331| 3.51k| *buf_++ = signal[2][sample]; 332| 3.51k| *buf_++ = signal[3][sample]; 333| 3.51k| *buf_++ = signal[4][sample]; 334| 3.51k| *buf_++ = signal[5][sample]; 335| 3.51k| *buf_++ = signal[6][sample]; 336| 3.51k| *buf_++ = signal[7][sample]; 337| 3.51k| } 338| 226| return; 339| | 340| | /* Two bytes per sample. */ 341| 2.32k| case (BYTES_CHANNEL_SELECTOR (2, 1)): ------------------ | | 290| 2.32k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (341:3): [True: 2.32k, False: 197k] ------------------ 342| 103k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (342:21): [True: 101k, False: 2.32k] ------------------ 343| 101k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 103k|#define H2LE_16(x) (x) ------------------ 344| 2.32k| return; 345| | 346| 2.58k| case (BYTES_CHANNEL_SELECTOR (2, 2)): ------------------ | | 290| 2.58k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (346:3): [True: 2.58k, False: 197k] ------------------ 347| 52.0k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (347:21): [True: 49.4k, False: 2.58k] ------------------ 348| 49.4k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 49.4k|#define H2LE_16(x) (x) ------------------ 349| 49.4k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 49.4k|#define H2LE_16(x) (x) ------------------ 350| 49.4k| } 351| 2.58k| return; 352| | 353| 473| case (BYTES_CHANNEL_SELECTOR (2, 4)): ------------------ | | 290| 473|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (353:3): [True: 473, False: 199k] ------------------ 354| 8.20k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (354:21): [True: 7.73k, False: 473] ------------------ 355| 7.73k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 7.73k|#define H2LE_16(x) (x) ------------------ 356| 7.73k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 7.73k|#define H2LE_16(x) (x) ------------------ 357| 7.73k| *buf16++ = H2LE_16(signal[2][sample]); ------------------ | | 81| 7.73k|#define H2LE_16(x) (x) ------------------ 358| 7.73k| *buf16++ = H2LE_16(signal[3][sample]); ------------------ | | 81| 7.73k|#define H2LE_16(x) (x) ------------------ 359| 7.73k| } 360| 473| return; 361| | 362| 413| case (BYTES_CHANNEL_SELECTOR (2, 6)): ------------------ | | 290| 413|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (362:3): [True: 413, False: 199k] ------------------ 363| 17.8k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (363:21): [True: 17.3k, False: 413] ------------------ 364| 17.3k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 17.3k|#define H2LE_16(x) (x) ------------------ 365| 17.3k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 17.3k|#define H2LE_16(x) (x) ------------------ 366| 17.3k| *buf16++ = H2LE_16(signal[2][sample]); ------------------ | | 81| 17.3k|#define H2LE_16(x) (x) ------------------ 367| 17.3k| *buf16++ = H2LE_16(signal[3][sample]); ------------------ | | 81| 17.3k|#define H2LE_16(x) (x) ------------------ 368| 17.3k| *buf16++ = H2LE_16(signal[4][sample]); ------------------ | | 81| 17.3k|#define H2LE_16(x) (x) ------------------ 369| 17.3k| *buf16++ = H2LE_16(signal[5][sample]); ------------------ | | 81| 17.3k|#define H2LE_16(x) (x) ------------------ 370| 17.3k| } 371| 413| return; 372| | 373| 216| case (BYTES_CHANNEL_SELECTOR (2, 8)): ------------------ | | 290| 216|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (373:3): [True: 216, False: 199k] ------------------ 374| 7.27k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (374:21): [True: 7.05k, False: 216] ------------------ 375| 7.05k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 376| 7.05k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 377| 7.05k| *buf16++ = H2LE_16(signal[2][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 378| 7.05k| *buf16++ = H2LE_16(signal[3][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 379| 7.05k| *buf16++ = H2LE_16(signal[4][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 380| 7.05k| *buf16++ = H2LE_16(signal[5][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 381| 7.05k| *buf16++ = H2LE_16(signal[6][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 382| 7.05k| *buf16++ = H2LE_16(signal[7][sample]); ------------------ | | 81| 7.05k|#define H2LE_16(x) (x) ------------------ 383| 7.05k| } 384| 216| return; 385| | 386| | /* Three bytes per sample. */ 387| 1.30k| case (BYTES_CHANNEL_SELECTOR (3, 1)): ------------------ | | 290| 1.30k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (387:3): [True: 1.30k, False: 198k] ------------------ 388| 787k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (388:21): [True: 786k, False: 1.30k] ------------------ 389| 786k| a_word = signal[0][sample]; 390| 786k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 391| 786k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 392| 786k| *buf_++ = (FLAC__byte)a_word; 393| 786k| } 394| 1.30k| return; 395| | 396| 8.65k| case (BYTES_CHANNEL_SELECTOR (3, 2)): ------------------ | | 290| 8.65k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (396:3): [True: 8.65k, False: 191k] ------------------ 397| 257k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (397:21): [True: 249k, False: 8.65k] ------------------ 398| 249k| a_word = signal[0][sample]; 399| 249k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 400| 249k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 401| 249k| *buf_++ = (FLAC__byte)a_word; 402| 249k| a_word = signal[1][sample]; 403| 249k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 404| 249k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 405| 249k| *buf_++ = (FLAC__byte)a_word; 406| 249k| } 407| 8.65k| return; 408| | 409| | /* Four bytes per sample. */ 410| 144k| case (BYTES_CHANNEL_SELECTOR (4, 1)): ------------------ | | 290| 144k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (410:3): [True: 144k, False: 54.8k] ------------------ 411| 16.0M| for (sample = 0; sample < samples; sample++) ------------------ | Branch (411:21): [True: 15.8M, False: 144k] ------------------ 412| 15.8M| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 16.0M|#define H2LE_32(x) (x) ------------------ 413| 144k| return; 414| | 415| 30.3k| case (BYTES_CHANNEL_SELECTOR (4, 2)): ------------------ | | 290| 30.3k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (415:3): [True: 30.3k, False: 169k] ------------------ 416| 4.35M| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (416:21): [True: 4.32M, False: 30.3k] ------------------ 417| 4.32M| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 4.32M|#define H2LE_32(x) (x) ------------------ 418| 4.32M| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 4.32M|#define H2LE_32(x) (x) ------------------ 419| 4.32M| } 420| 30.3k| return; 421| | 422| 880| case (BYTES_CHANNEL_SELECTOR (4, 4)): ------------------ | | 290| 880|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (422:3): [True: 880, False: 198k] ------------------ 423| 78.5k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (423:21): [True: 77.6k, False: 880] ------------------ 424| 77.6k| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 77.6k|#define H2LE_32(x) (x) ------------------ 425| 77.6k| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 77.6k|#define H2LE_32(x) (x) ------------------ 426| 77.6k| *buf32++ = H2LE_32(signal[2][sample]); ------------------ | | 82| 77.6k|#define H2LE_32(x) (x) ------------------ 427| 77.6k| *buf32++ = H2LE_32(signal[3][sample]); ------------------ | | 82| 77.6k|#define H2LE_32(x) (x) ------------------ 428| 77.6k| } 429| 880| return; 430| | 431| 606| case (BYTES_CHANNEL_SELECTOR (4, 6)): ------------------ | | 290| 606|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (431:3): [True: 606, False: 199k] ------------------ 432| 40.6k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (432:21): [True: 40.0k, False: 606] ------------------ 433| 40.0k| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 40.0k|#define H2LE_32(x) (x) ------------------ 434| 40.0k| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 40.0k|#define H2LE_32(x) (x) ------------------ 435| 40.0k| *buf32++ = H2LE_32(signal[2][sample]); ------------------ | | 82| 40.0k|#define H2LE_32(x) (x) ------------------ 436| 40.0k| *buf32++ = H2LE_32(signal[3][sample]); ------------------ | | 82| 40.0k|#define H2LE_32(x) (x) ------------------ 437| 40.0k| *buf32++ = H2LE_32(signal[4][sample]); ------------------ | | 82| 40.0k|#define H2LE_32(x) (x) ------------------ 438| 40.0k| *buf32++ = H2LE_32(signal[5][sample]); ------------------ | | 82| 40.0k|#define H2LE_32(x) (x) ------------------ 439| 40.0k| } 440| 606| return; 441| | 442| 646| case (BYTES_CHANNEL_SELECTOR (4, 8)): ------------------ | | 290| 646|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (442:3): [True: 646, False: 199k] ------------------ 443| 44.7k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (443:21): [True: 44.0k, False: 646] ------------------ 444| 44.0k| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 445| 44.0k| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 446| 44.0k| *buf32++ = H2LE_32(signal[2][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 447| 44.0k| *buf32++ = H2LE_32(signal[3][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 448| 44.0k| *buf32++ = H2LE_32(signal[4][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 449| 44.0k| *buf32++ = H2LE_32(signal[5][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 450| 44.0k| *buf32++ = H2LE_32(signal[6][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 451| 44.0k| *buf32++ = H2LE_32(signal[7][sample]); ------------------ | | 82| 44.0k|#define H2LE_32(x) (x) ------------------ 452| 44.0k| } 453| 646| return; 454| | 455| 1.30k| default: ------------------ | Branch (455:3): [True: 1.30k, False: 198k] ------------------ 456| 1.30k| break; 457| 199k| } 458| | 459| | /* General version. */ 460| 1.30k| switch (bytes_per_sample) { 461| 251| case 1: ------------------ | Branch (461:3): [True: 251, False: 1.05k] ------------------ 462| 4.10k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (462:21): [True: 3.85k, False: 251] ------------------ 463| 16.0k| for (channel = 0; channel < channels; channel++) ------------------ | Branch (463:23): [True: 12.1k, False: 3.85k] ------------------ 464| 12.1k| *buf_++ = signal[channel][sample]; 465| 251| return; 466| | 467| 224| case 2: ------------------ | Branch (467:3): [True: 224, False: 1.07k] ------------------ 468| 3.83k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (468:21): [True: 3.60k, False: 224] ------------------ 469| 14.8k| for (channel = 0; channel < channels; channel++) ------------------ | Branch (469:23): [True: 11.2k, False: 3.60k] ------------------ 470| 11.2k| *buf16++ = H2LE_16(signal[channel][sample]); ------------------ | | 81| 11.4k|#define H2LE_16(x) (x) ------------------ 471| 224| return; 472| | 473| 424| case 3: ------------------ | Branch (473:3): [True: 424, False: 877] ------------------ 474| 9.92k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (474:21): [True: 9.50k, False: 424] ------------------ 475| 40.1k| for (channel = 0; channel < channels; channel++) { ------------------ | Branch (475:23): [True: 30.6k, False: 9.50k] ------------------ 476| 30.6k| a_word = signal[channel][sample]; 477| 30.6k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 478| 30.6k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 479| 30.6k| *buf_++ = (FLAC__byte)a_word; 480| 30.6k| } 481| 424| return; 482| | 483| 402| case 4: ------------------ | Branch (483:3): [True: 402, False: 899] ------------------ 484| 58.5k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (484:21): [True: 58.1k, False: 402] ------------------ 485| 382k| for (channel = 0; channel < channels; channel++) ------------------ | Branch (485:23): [True: 324k, False: 58.1k] ------------------ 486| 324k| *buf32++ = H2LE_32(signal[channel][sample]); ------------------ | | 82| 324k|#define H2LE_32(x) (x) ------------------ 487| 402| return; 488| | 489| 0| default: ------------------ | Branch (489:3): [True: 0, False: 1.30k] ------------------ 490| 0| break; 491| 1.30k| } 492| 1.30k|} md5.c:FLAC__MD5Update: 185| 199k|{ 186| 199k| FLAC__uint32 t; 187| | 188| | /* Update byte count */ 189| | 190| 199k| t = ctx->bytes[0]; 191| 199k| if ((ctx->bytes[0] = t + len) < t) ------------------ | Branch (191:6): [True: 0, False: 199k] ------------------ 192| 0| ctx->bytes[1]++; /* Carry from low to high */ 193| | 194| 199k| t = 64 - (t & 0x3f); /* Space available in ctx->in (at least 1) */ 195| 199k| if (t > len) { ------------------ | Branch (195:6): [True: 7.84k, False: 191k] ------------------ 196| 7.84k| memcpy((FLAC__byte *)ctx->in + 64 - t, buf, len); 197| 7.84k| return; 198| 7.84k| } 199| | /* First chunk is an odd size */ 200| 191k| memcpy((FLAC__byte *)ctx->in + 64 - t, buf, t); 201| 191k| byteSwapX16(ctx->in); 202| 191k| FLAC__MD5Transform(ctx->buf, ctx->in); 203| 191k| buf += t; 204| 191k| len -= t; 205| | 206| | /* Process data in 64-byte chunks */ 207| 1.70M| while (len >= 64) { ------------------ | Branch (207:9): [True: 1.51M, False: 191k] ------------------ 208| 1.51M| memcpy(ctx->in, buf, 64); 209| 1.51M| byteSwapX16(ctx->in); 210| 1.51M| FLAC__MD5Transform(ctx->buf, ctx->in); 211| 1.51M| buf += 64; 212| 1.51M| len -= 64; 213| 1.51M| } 214| | 215| | /* Handle any remaining bytes of data. */ 216| 191k| memcpy(ctx->in, buf, len); 217| 191k|} FLAC__memory_alloc_aligned: 47| 346k|{ 48| 346k| void *x; 49| | 50| 346k| FLAC__ASSERT(0 != aligned_address); ------------------ | | 38| 346k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 346k] | | ------------------ ------------------ 51| | 52| 346k|#ifdef FLAC__ALIGN_MALLOC_DATA 53| | /* align on 32-byte (256-bit) boundary */ 54| 346k| x = safe_malloc_add_2op_(bytes, /*+*/31L); 55| 346k| *aligned_address = (void*)(((uintptr_t)x + 31L) & -32L); 56| |#else 57| | x = safe_malloc_(bytes); 58| | *aligned_address = x; 59| |#endif 60| 346k| return x; 61| 346k|} FLAC__memory_alloc_aligned_int32_array: 64| 252k|{ 65| 252k| FLAC__int32 *pu; /* unaligned pointer */ 66| 252k| union { /* union needed to comply with C99 pointer aliasing rules */ 67| 252k| FLAC__int32 *pa; /* aligned pointer */ 68| 252k| void *pv; /* aligned pointer alias */ 69| 252k| } u; 70| | 71| 252k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 252k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 252k] | | ------------------ ------------------ 72| 252k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 252k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 252k] | | ------------------ ------------------ 73| 252k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 252k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 252k] | | ------------------ ------------------ 74| 252k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 252k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 252k] | | ------------------ ------------------ 75| | 76| 252k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (76:5): [True: 0, False: 252k] ------------------ 77| 0| return false; 78| | 79| 252k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 80| 252k| if(0 == pu) { ------------------ | Branch (80:5): [True: 0, False: 252k] ------------------ 81| 0| return false; 82| 0| } 83| 252k| else { 84| 252k| if(*unaligned_pointer != 0) ------------------ | Branch (84:6): [True: 0, False: 252k] ------------------ 85| 0| free(*unaligned_pointer); 86| 252k| *unaligned_pointer = pu; 87| 252k| *aligned_pointer = u.pa; 88| | return true; 89| 252k| } 90| 252k|} FLAC__memory_alloc_aligned_uint32_array: 93| 15.4k|{ 94| 15.4k| FLAC__uint32 *pu; /* unaligned pointer */ 95| 15.4k| union { /* union needed to comply with C99 pointer aliasing rules */ 96| 15.4k| FLAC__uint32 *pa; /* aligned pointer */ 97| 15.4k| void *pv; /* aligned pointer alias */ 98| 15.4k| } u; 99| | 100| 15.4k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 15.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 15.4k] | | ------------------ ------------------ 101| 15.4k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 15.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 15.4k] | | ------------------ ------------------ 102| 15.4k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 15.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 15.4k] | | ------------------ ------------------ 103| 15.4k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 15.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 15.4k] | | ------------------ ------------------ 104| | 105| 15.4k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (105:5): [True: 0, False: 15.4k] ------------------ 106| 0| return false; 107| | 108| 15.4k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 109| 15.4k| if(0 == pu) { ------------------ | Branch (109:5): [True: 0, False: 15.4k] ------------------ 110| 0| return false; 111| 0| } 112| 15.4k| else { 113| 15.4k| if(*unaligned_pointer != 0) ------------------ | Branch (113:6): [True: 0, False: 15.4k] ------------------ 114| 0| free(*unaligned_pointer); 115| 15.4k| *unaligned_pointer = pu; 116| 15.4k| *aligned_pointer = u.pa; 117| | return true; 118| 15.4k| } 119| 15.4k|} FLAC__memory_alloc_aligned_int64_array: 122| 21.9k|{ 123| 21.9k| FLAC__int64 *pu; /* unaligned pointer */ 124| 21.9k| union { /* union needed to comply with C99 pointer aliasing rules */ 125| 21.9k| FLAC__int64 *pa; /* aligned pointer */ 126| 21.9k| void *pv; /* aligned pointer alias */ 127| 21.9k| } u; 128| | 129| 21.9k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 130| 21.9k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 131| 21.9k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 132| 21.9k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 133| | 134| 21.9k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (134:5): [True: 0, False: 21.9k] ------------------ 135| 0| return false; 136| | 137| 21.9k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 138| 21.9k| if(0 == pu) { ------------------ | Branch (138:5): [True: 0, False: 21.9k] ------------------ 139| 0| return false; 140| 0| } 141| 21.9k| else { 142| 21.9k| if(*unaligned_pointer != 0) ------------------ | Branch (142:6): [True: 0, False: 21.9k] ------------------ 143| 0| free(*unaligned_pointer); 144| 21.9k| *unaligned_pointer = pu; 145| 21.9k| *aligned_pointer = u.pa; 146| | return true; 147| 21.9k| } 148| 21.9k|} FLAC__memory_alloc_aligned_uint64_array: 151| 21.9k|{ 152| 21.9k| FLAC__uint64 *pu; /* unaligned pointer */ 153| 21.9k| union { /* union needed to comply with C99 pointer aliasing rules */ 154| 21.9k| FLAC__uint64 *pa; /* aligned pointer */ 155| 21.9k| void *pv; /* aligned pointer alias */ 156| 21.9k| } u; 157| | 158| 21.9k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 159| 21.9k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 160| 21.9k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 161| 21.9k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 162| | 163| 21.9k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (163:5): [True: 0, False: 21.9k] ------------------ 164| 0| return false; 165| | 166| 21.9k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 167| 21.9k| if(0 == pu) { ------------------ | Branch (167:5): [True: 0, False: 21.9k] ------------------ 168| 0| return false; 169| 0| } 170| 21.9k| else { 171| 21.9k| if(*unaligned_pointer != 0) ------------------ | Branch (171:6): [True: 0, False: 21.9k] ------------------ 172| 0| free(*unaligned_pointer); 173| 21.9k| *unaligned_pointer = pu; 174| 21.9k| *aligned_pointer = u.pa; 175| | return true; 176| 21.9k| } 177| 21.9k|} FLAC__memory_alloc_aligned_real_array: 182| 34.5k|{ 183| 34.5k| FLAC__real *pu; /* unaligned pointer */ 184| 34.5k| union { /* union needed to comply with C99 pointer aliasing rules */ 185| 34.5k| FLAC__real *pa; /* aligned pointer */ 186| 34.5k| void *pv; /* aligned pointer alias */ 187| 34.5k| } u; 188| | 189| 34.5k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 34.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 34.5k] | | ------------------ ------------------ 190| 34.5k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 34.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 34.5k] | | ------------------ ------------------ 191| 34.5k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 34.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 34.5k] | | ------------------ ------------------ 192| 34.5k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 34.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 34.5k] | | ------------------ ------------------ 193| | 194| 34.5k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (194:5): [True: 0, False: 34.5k] ------------------ 195| 0| return false; 196| | 197| 34.5k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 198| 34.5k| if(0 == pu) { ------------------ | Branch (198:5): [True: 0, False: 34.5k] ------------------ 199| 0| return false; 200| 0| } 201| 34.5k| else { 202| 34.5k| if(*unaligned_pointer != 0) ------------------ | Branch (202:6): [True: 0, False: 34.5k] ------------------ 203| 0| free(*unaligned_pointer); 204| 34.5k| *unaligned_pointer = pu; 205| 34.5k| *aligned_pointer = u.pa; 206| | return true; 207| 34.5k| } 208| 34.5k|} safe_malloc_mul_2op_p: 213| 20.5k|{ 214| 20.5k| if(!size1 || !size2) ------------------ | Branch (214:5): [True: 0, False: 20.5k] | Branch (214:15): [True: 0, False: 20.5k] ------------------ 215| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 216| 20.5k| if(size1 > SIZE_MAX / size2) ------------------ | Branch (216:5): [True: 0, False: 20.5k] ------------------ 217| 0| return 0; 218| 20.5k| return malloc(size1*size2); 219| 20.5k|} FLAC__ogg_decoder_aspect_set_defaults: 215| 16.3k|{ 216| 16.3k| aspect->use_first_serial_number = true; 217| | aspect->decode_chained_stream = false; 218| 16.3k|} FLAC__ogg_encoder_aspect_init: 52| 2.89k|{ 53| | /* we will determine the serial number later if necessary */ 54| 2.89k| if(ogg_stream_init(&aspect->stream_state, aspect->serial_number) != 0) ------------------ | Branch (54:5): [True: 0, False: 2.89k] ------------------ 55| 0| return false; 56| | 57| 2.89k| aspect->seen_magic = false; 58| 2.89k| aspect->is_first_packet = true; 59| 2.89k| aspect->samples_written = 0; 60| 2.89k| aspect->last_page_granule_pos = 0; 61| | 62| | return true; 63| 2.89k|} FLAC__ogg_encoder_aspect_finish: 66| 2.89k|{ 67| 2.89k| (void)ogg_stream_clear(&aspect->stream_state); 68| | /*@@@ what about the page? */ 69| 2.89k|} FLAC__ogg_encoder_aspect_set_serial_number: 72| 11.5k|{ 73| 11.5k| aspect->serial_number = value; 74| 11.5k|} FLAC__ogg_encoder_aspect_set_defaults: 87| 20.9k|{ 88| 20.9k| aspect->serial_number = 0; 89| 20.9k| aspect->num_metadata = 0; 90| 20.9k|} FLAC__ogg_encoder_aspect_write_callback_wrapper: 114| 145k|{ 115| | /* WATCHOUT: 116| | * This depends on the behavior of FLAC__StreamEncoder that 'samples' 117| | * will be 0 for metadata writes. 118| | */ 119| 145k| const FLAC__bool is_metadata = (samples == 0); 120| | 121| | /* 122| | * Treat fLaC magic packet specially. We will note when we see it, then 123| | * wait until we get the STREAMINFO and prepend it in that packet 124| | */ 125| 145k| if(aspect->seen_magic) { ------------------ | Branch (125:5): [True: 142k, False: 2.89k] ------------------ 126| 142k| ogg_packet packet; 127| 142k| FLAC__byte synthetic_first_packet_body[ 128| 142k| FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH + 129| 142k| FLAC__OGG_MAPPING_MAGIC_LENGTH + 130| 142k| FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH + 131| 142k| FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH + 132| 142k| FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH + 133| 142k| FLAC__STREAM_SYNC_LENGTH + 134| 142k| FLAC__STREAM_METADATA_HEADER_LENGTH + 135| 142k| FLAC__STREAM_METADATA_STREAMINFO_LENGTH 136| 142k| ]; 137| | 138| 142k| memset(&packet, 0, sizeof(packet)); 139| 142k| packet.granulepos = aspect->samples_written + samples; 140| | 141| 142k| if(aspect->is_first_packet) { ------------------ | Branch (141:6): [True: 2.89k, False: 139k] ------------------ 142| 2.89k| FLAC__byte *b = synthetic_first_packet_body; 143| 2.89k| if(bytes != FLAC__STREAM_METADATA_HEADER_LENGTH + FLAC__STREAM_METADATA_STREAMINFO_LENGTH) { ------------------ | | 872| 2.89k|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ if(bytes != FLAC__STREAM_METADATA_HEADER_LENGTH + FLAC__STREAM_METADATA_STREAMINFO_LENGTH) { ------------------ | | 557| 2.89k|#define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u) ------------------ | Branch (143:7): [True: 0, False: 2.89k] ------------------ 144| | /* 145| | * If we get here, our assumption about the way write callbacks happen 146| | * (explained above) is wrong 147| | */ 148| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 149| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 150| 0| } 151| | /* add first header packet type */ 152| 2.89k| *b = FLAC__OGG_MAPPING_FIRST_HEADER_PACKET_TYPE; 153| 2.89k| b += FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH; ------------------ | | 39| 2.89k|#define FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH (1u) ------------------ 154| | /* add 'FLAC' mapping magic */ 155| 2.89k| memcpy(b, FLAC__OGG_MAPPING_MAGIC, FLAC__OGG_MAPPING_MAGIC_LENGTH); ------------------ | | 46| 2.89k|#define FLAC__OGG_MAPPING_MAGIC_LENGTH (4u) ------------------ 156| 2.89k| b += FLAC__OGG_MAPPING_MAGIC_LENGTH; ------------------ | | 46| 2.89k|#define FLAC__OGG_MAPPING_MAGIC_LENGTH (4u) ------------------ 157| | /* add Ogg FLAC mapping major version number */ 158| 2.89k| memcpy(b, &FLAC__OGG_MAPPING_VERSION_MAJOR, FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH); ------------------ | | 54| 2.89k|#define FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH (1u) ------------------ 159| 2.89k| b += FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH; ------------------ | | 54| 2.89k|#define FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH (1u) ------------------ 160| | /* add Ogg FLAC mapping minor version number */ 161| 2.89k| memcpy(b, &FLAC__OGG_MAPPING_VERSION_MINOR, FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH); ------------------ | | 57| 2.89k|#define FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH (1u) ------------------ 162| 2.89k| b += FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH; ------------------ | | 57| 2.89k|#define FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH (1u) ------------------ 163| | /* add number of header packets */ 164| 2.89k| *b = (FLAC__byte)(aspect->num_metadata >> 8); 165| 2.89k| b++; 166| 2.89k| *b = (FLAC__byte)(aspect->num_metadata); 167| 2.89k| b++; 168| | /* add native FLAC 'fLaC' magic */ 169| 2.89k| memcpy(b, FLAC__STREAM_SYNC_STRING, FLAC__STREAM_SYNC_LENGTH); ------------------ | | 179| 2.89k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 170| 2.89k| b += FLAC__STREAM_SYNC_LENGTH; ------------------ | | 179| 2.89k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 171| | /* add STREAMINFO */ 172| 2.89k| memcpy(b, buffer, bytes); 173| 2.89k| FLAC__ASSERT(b + bytes - synthetic_first_packet_body == sizeof(synthetic_first_packet_body)); ------------------ | | 38| 2.89k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 2.89k] | | ------------------ ------------------ 174| 2.89k| packet.packet = (uint8_t *)synthetic_first_packet_body; 175| 2.89k| packet.bytes = sizeof(synthetic_first_packet_body); 176| | 177| 2.89k| packet.b_o_s = 1; 178| 2.89k| aspect->is_first_packet = false; 179| 2.89k| } 180| 139k| else { 181| 139k| packet.packet = (uint8_t *)buffer; 182| 139k| packet.bytes = bytes; 183| 139k| } 184| | 185| 142k| if(is_last_block) { ------------------ | Branch (185:6): [True: 2.52k, False: 140k] ------------------ 186| | /* we used to check: 187| | * FLAC__ASSERT(total_samples_estimate == 0 || total_samples_estimate == aspect->samples_written + samples); 188| | * but it's really not useful since total_samples_estimate is an estimate and can be inexact 189| | */ 190| 2.52k| packet.e_o_s = 1; 191| 2.52k| } 192| | 193| 142k| if(ogg_stream_packetin(&aspect->stream_state, &packet) != 0) ------------------ | Branch (193:6): [True: 0, False: 142k] ------------------ 194| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 195| | 196| | /* For a batch of write_callback calls associated with the same current_frame, pass the number of samples in the 197| | * first non-metadata page body call, and then set to zero in case there are more iterations of the while loop (so 198| | * as not to give the impression of more samples being processed). 199| | */ 200| 142k| if(is_metadata) { ------------------ | Branch (200:6): [True: 5.78k, False: 137k] ------------------ 201| 11.5k| while(ogg_stream_flush(&aspect->stream_state, &aspect->page) != 0) { ------------------ | Branch (201:10): [True: 5.78k, False: 5.78k] ------------------ 202| 5.78k| FLAC__int64 page_granule_pos = ogg_page_granulepos(&aspect->page); 203| 5.78k| uint32_t samples_on_this_page; 204| 5.78k| if(page_granule_pos == -1) { ------------------ | Branch (204:8): [True: 0, False: 5.78k] ------------------ 205| | /* a granule position of -1 means no packets finish on this page */ 206| 0| samples_on_this_page = 0; 207| 0| } 208| 5.78k| else { 209| 5.78k| samples_on_this_page = (uint32_t)(page_granule_pos - aspect->last_page_granule_pos); 210| 5.78k| aspect->last_page_granule_pos = page_granule_pos; 211| 5.78k| } 212| 5.78k| if(write_callback(encoder, aspect->page.header, aspect->page.header_len, 0, current_frame, client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) ------------------ | Branch (212:8): [True: 0, False: 5.78k] ------------------ 213| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 214| 5.78k| if(write_callback(encoder, aspect->page.body, aspect->page.body_len, samples_on_this_page, current_frame, client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) ------------------ | Branch (214:8): [True: 0, False: 5.78k] ------------------ 215| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 216| 5.78k| } 217| 5.78k| } 218| 137k| else { 219| 141k| while(ogg_stream_pageout(&aspect->stream_state, &aspect->page) != 0) { ------------------ | Branch (219:10): [True: 4.33k, False: 137k] ------------------ 220| 4.33k| FLAC__int64 page_granule_pos = ogg_page_granulepos(&aspect->page); 221| 4.33k| uint32_t samples_on_this_page; 222| 4.33k| if(page_granule_pos == -1) { ------------------ | Branch (222:8): [True: 315, False: 4.02k] ------------------ 223| | /* a granule position of -1 means no packets finish on this page */ 224| 315| samples_on_this_page = 0; 225| 315| } 226| 4.02k| else { 227| 4.02k| samples_on_this_page = (uint32_t)(page_granule_pos - aspect->last_page_granule_pos); 228| 4.02k| aspect->last_page_granule_pos = page_granule_pos; 229| 4.02k| } 230| 4.33k| if(write_callback(encoder, aspect->page.header, aspect->page.header_len, 0, current_frame, client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) ------------------ | Branch (230:8): [True: 0, False: 4.33k] ------------------ 231| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 232| 4.33k| if(write_callback(encoder, aspect->page.body, aspect->page.body_len, samples_on_this_page, current_frame, client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) ------------------ | Branch (232:8): [True: 0, False: 4.33k] ------------------ 233| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 234| 4.33k| } 235| 137k| } 236| 142k| } 237| 2.89k| else if(is_metadata && current_frame == 0 && samples == 0 && bytes == 4 && 0 == memcmp(buffer, FLAC__STREAM_SYNC_STRING, sizeof(FLAC__STREAM_SYNC_STRING))) { ------------------ | Branch (237:10): [True: 2.89k, False: 0] | Branch (237:25): [True: 2.89k, False: 0] | Branch (237:47): [True: 2.89k, False: 0] | Branch (237:63): [True: 2.89k, False: 0] | Branch (237:77): [True: 2.89k, False: 0] ------------------ 238| 2.89k| aspect->seen_magic = true; 239| 2.89k| } 240| 0| else { 241| | /* 242| | * If we get here, our assumption about the way write callbacks happen 243| | * explained above is wrong 244| | */ 245| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 246| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 247| 0| } 248| | 249| 145k| aspect->samples_written += samples; 250| | 251| 145k| return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 252| 145k|} FLAC__stream_decoder_new: 256| 8.16k|{ 257| 8.16k| FLAC__StreamDecoder *decoder; 258| 8.16k| uint32_t i; 259| | 260| 8.16k| FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 8.16k] | | ------------------ ------------------ 261| | 262| 8.16k| decoder = safe_calloc_(1, sizeof(FLAC__StreamDecoder)); 263| 8.16k| if(decoder == 0) { ------------------ | Branch (263:5): [True: 0, False: 8.16k] ------------------ 264| 0| return 0; 265| 0| } 266| | 267| 8.16k| decoder->protected_ = safe_calloc_(1, sizeof(FLAC__StreamDecoderProtected)); 268| 8.16k| if(decoder->protected_ == 0) { ------------------ | Branch (268:5): [True: 0, False: 8.16k] ------------------ 269| 0| free(decoder); 270| 0| return 0; 271| 0| } 272| | 273| 8.16k| decoder->private_ = safe_calloc_(1, sizeof(FLAC__StreamDecoderPrivate)); 274| 8.16k| if(decoder->private_ == 0) { ------------------ | Branch (274:5): [True: 0, False: 8.16k] ------------------ 275| 0| free(decoder->protected_); 276| 0| free(decoder); 277| 0| return 0; 278| 0| } 279| | 280| 8.16k| decoder->private_->input = FLAC__bitreader_new(); 281| 8.16k| if(decoder->private_->input == 0) { ------------------ | Branch (281:5): [True: 0, False: 8.16k] ------------------ 282| 0| free(decoder->private_); 283| 0| free(decoder->protected_); 284| 0| free(decoder); 285| 0| return 0; 286| 0| } 287| | 288| 8.16k| decoder->private_->metadata_filter_ids_capacity = 16; 289| 8.16k| if(0 == (decoder->private_->metadata_filter_ids = malloc((FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) * decoder->private_->metadata_filter_ids_capacity))) { ------------------ | Branch (289:5): [True: 0, False: 8.16k] ------------------ 290| 0| FLAC__bitreader_delete(decoder->private_->input); 291| 0| free(decoder->private_); 292| 0| free(decoder->protected_); 293| 0| free(decoder); 294| 0| return 0; 295| 0| } 296| | 297| 73.4k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 73.4k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (297:13): [True: 65.3k, False: 8.16k] ------------------ 298| 65.3k| decoder->private_->output[i] = 0; 299| 65.3k| decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0; 300| 65.3k| } 301| | 302| 8.16k| decoder->private_->side_subframe = 0; 303| | 304| 8.16k| decoder->private_->output_capacity = 0; 305| 8.16k| decoder->private_->output_channels = 0; 306| 8.16k| decoder->private_->has_seek_table = false; 307| | 308| 73.4k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) ------------------ | | 106| 73.4k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (308:13): [True: 65.3k, False: 8.16k] ------------------ 309| 65.3k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&decoder->private_->partitioned_rice_contents[i]); 310| | 311| 8.16k| decoder->private_->file = 0; 312| | 313| 8.16k| set_defaults_(decoder); 314| | 315| 8.16k| decoder->protected_->state = FLAC__STREAM_DECODER_UNINITIALIZED; 316| | 317| 8.16k| return decoder; 318| 8.16k|} FLAC__stream_decoder_delete: 321| 8.16k|{ 322| 8.16k| uint32_t i; 323| | 324| 8.16k| if (decoder == NULL) ------------------ | Branch (324:6): [True: 0, False: 8.16k] ------------------ 325| 0| return ; 326| | 327| 8.16k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 328| 8.16k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 329| 8.16k| FLAC__ASSERT(0 != decoder->private_->input); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 330| | 331| 8.16k| (void)FLAC__stream_decoder_finish(decoder); 332| | 333| 8.16k| if(0 != decoder->private_->metadata_filter_ids) ------------------ | Branch (333:5): [True: 8.16k, False: 0] ------------------ 334| 8.16k| free(decoder->private_->metadata_filter_ids); 335| | 336| 8.16k| FLAC__bitreader_delete(decoder->private_->input); 337| | 338| 73.4k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) ------------------ | | 106| 73.4k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (338:13): [True: 65.3k, False: 8.16k] ------------------ 339| 65.3k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&decoder->private_->partitioned_rice_contents[i]); 340| | 341| 8.16k| free(decoder->private_); 342| 8.16k| free(decoder->protected_); 343| 8.16k| free(decoder); 344| 8.16k|} FLAC__stream_decoder_init_stream: 445| 8.16k|{ 446| 8.16k| return init_stream_internal_( 447| 8.16k| decoder, 448| 8.16k| read_callback, 449| 8.16k| seek_callback, 450| 8.16k| tell_callback, 451| 8.16k| length_callback, 452| 8.16k| eof_callback, 453| 8.16k| write_callback, 454| 8.16k| metadata_callback, 455| 8.16k| error_callback, 456| 8.16k| client_data, 457| | /*is_ogg=*/false 458| 8.16k| ); 459| 8.16k|} FLAC__stream_decoder_finish: 615| 16.3k|{ 616| 16.3k| FLAC__bool md5_failed = false; 617| 16.3k| uint32_t i; 618| | 619| 16.3k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 620| 16.3k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 621| 16.3k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 622| | 623| 16.3k| if(decoder->protected_->state == FLAC__STREAM_DECODER_UNINITIALIZED) ------------------ | Branch (623:5): [True: 8.16k, False: 8.16k] ------------------ 624| 8.16k| return true; 625| | 626| | /* see the comment in FLAC__stream_decoder_reset() as to why we 627| | * always call FLAC__MD5Final() 628| | */ 629| 8.16k| FLAC__MD5Final(decoder->private_->computed_md5sum, &decoder->private_->md5context); 630| | 631| 8.16k| free(decoder->private_->seek_table.data.seek_table.points); 632| 8.16k| decoder->private_->seek_table.data.seek_table.points = 0; 633| 8.16k| decoder->private_->has_seek_table = false; 634| | 635| 8.16k| FLAC__bitreader_free(decoder->private_->input); 636| 73.4k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 73.4k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (636:13): [True: 65.3k, False: 8.16k] ------------------ 637| | /* WATCHOUT: 638| | * FLAC__lpc_restore_signal_asm_ia32_mmx() and ..._intrin_sseN() 639| | * require that the output arrays have a buffer of up to 3 zeroes 640| | * in front (at negative indices) for alignment purposes; 641| | * we use 4 to keep the data well-aligned. 642| | */ 643| 65.3k| if(0 != decoder->private_->output[i]) { ------------------ | Branch (643:6): [True: 13.3k, False: 51.9k] ------------------ 644| 13.3k| free(decoder->private_->output[i]-4); 645| 13.3k| decoder->private_->output[i] = 0; 646| 13.3k| } 647| 65.3k| if(0 != decoder->private_->residual_unaligned[i]) { ------------------ | Branch (647:6): [True: 13.3k, False: 51.9k] ------------------ 648| 13.3k| free(decoder->private_->residual_unaligned[i]); 649| 13.3k| decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0; 650| 13.3k| } 651| 65.3k| } 652| 8.16k| if(0 != decoder->private_->side_subframe) { ------------------ | Branch (652:5): [True: 5.06k, False: 3.10k] ------------------ 653| 5.06k| free(decoder->private_->side_subframe); 654| 5.06k| decoder->private_->side_subframe = 0; 655| 5.06k| } 656| 8.16k| decoder->private_->output_capacity = 0; 657| 8.16k| decoder->private_->output_channels = 0; 658| | 659| 8.16k|#if FLAC__HAS_OGG 660| 8.16k| if(decoder->private_->is_ogg) ------------------ | Branch (660:5): [True: 0, False: 8.16k] ------------------ 661| 0| FLAC__ogg_decoder_aspect_finish(&decoder->protected_->ogg_decoder_aspect); 662| 8.16k|#endif 663| | 664| 8.16k| if(0 != decoder->private_->file) { ------------------ | Branch (664:5): [True: 0, False: 8.16k] ------------------ 665| 0| if(decoder->private_->file != stdin) ------------------ | Branch (665:6): [True: 0, False: 0] ------------------ 666| 0| fclose(decoder->private_->file); 667| 0| decoder->private_->file = 0; 668| 0| } 669| | 670| 8.16k| if(decoder->private_->do_md5_checking) { ------------------ | Branch (670:5): [True: 0, False: 8.16k] ------------------ 671| 0| if(memcmp(decoder->private_->stream_info.data.stream_info.md5sum, decoder->private_->computed_md5sum, 16)) ------------------ | Branch (671:6): [True: 0, False: 0] ------------------ 672| 0| md5_failed = true; 673| 0| } 674| 8.16k| decoder->private_->is_seeking = false; 675| 8.16k| decoder->private_->is_indexing = false; 676| | 677| 8.16k| set_defaults_(decoder); 678| | 679| 8.16k| decoder->protected_->state = FLAC__STREAM_DECODER_UNINITIALIZED; 680| | 681| 8.16k| return !md5_failed; 682| 16.3k|} FLAC__stream_decoder_get_state: 831| 212k|{ 832| 212k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 212k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 212k] | | ------------------ ------------------ 833| 212k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 212k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 212k] | | ------------------ ------------------ 834| 212k| return decoder->protected_->state; 835| 212k|} FLAC__stream_decoder_get_decode_position: 904| 211k|{ 905| 211k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 211k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 211k] | | ------------------ ------------------ 906| 211k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 211k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 211k] | | ------------------ ------------------ 907| 211k| FLAC__ASSERT(0 != position); ------------------ | | 38| 211k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 211k] | | ------------------ ------------------ 908| | 909| 211k| if(FLAC__HAS_OGG && decoder->private_->is_ogg) ------------------ | | 45| 423k|#define FLAC__HAS_OGG 1 | | ------------------ | | | Branch (45:23): [True: 211k, Folded] | | ------------------ ------------------ | Branch (909:22): [True: 0, False: 211k] ------------------ 910| 0| return false; 911| | 912| 211k| if(0 == decoder->private_->tell_callback) ------------------ | Branch (912:5): [True: 211k, False: 0] ------------------ 913| 211k| return false; 914| 0| if(decoder->private_->tell_callback(decoder, position, decoder->private_->client_data) != FLAC__STREAM_DECODER_TELL_STATUS_OK) ------------------ | Branch (914:5): [True: 0, False: 0] ------------------ 915| 0| return false; 916| | /* should never happen since all FLAC frames and metadata blocks are byte aligned, but check just in case */ 917| 0| if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) ------------------ | Branch (917:5): [True: 0, False: 0] ------------------ 918| 0| return false; 919| 0| FLAC__ASSERT(*position >= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder)); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 920| 0| *position -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder); 921| | return true; 922| 0|} FLAC__stream_decoder_flush: 930| 8.16k|{ 931| 8.16k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 932| 8.16k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 933| 8.16k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 934| | 935| 8.16k| if(!decoder->private_->internal_reset_hack && decoder->protected_->state == FLAC__STREAM_DECODER_UNINITIALIZED) ------------------ | Branch (935:5): [True: 0, False: 8.16k] | Branch (935:48): [True: 0, False: 0] ------------------ 936| 0| return false; 937| 8.16k| if(decoder->protected_->state == FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR) ------------------ | Branch (937:5): [True: 0, False: 8.16k] ------------------ 938| 0| return false; 939| | 940| 8.16k| decoder->private_->samples_decoded = 0; 941| 8.16k| decoder->private_->do_md5_checking = false; 942| 8.16k| decoder->private_->last_seen_framesync = 0; 943| 8.16k| decoder->private_->last_frame_is_set = false; 944| | 945| 8.16k|#if FLAC__HAS_OGG 946| 8.16k| if(decoder->private_->is_ogg) ------------------ | Branch (946:5): [True: 0, False: 8.16k] ------------------ 947| 0| FLAC__ogg_decoder_aspect_flush(&decoder->protected_->ogg_decoder_aspect); 948| 8.16k|#endif 949| | 950| 8.16k| if(!FLAC__bitreader_clear(decoder->private_->input)) { ------------------ | Branch (950:5): [True: 0, False: 8.16k] ------------------ 951| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 952| 0| return false; 953| 0| } 954| 8.16k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 955| | 956| | return true; 957| 8.16k|} FLAC__stream_decoder_reset: 1001| 8.16k|{ 1002| 8.16k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 1003| 8.16k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 1004| 8.16k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 1005| | 1006| 8.16k| if(!FLAC__stream_decoder_flush(decoder)) { ------------------ | Branch (1006:5): [True: 0, False: 8.16k] ------------------ 1007| | /* above call sets the state for us */ 1008| 0| return false; 1009| 0| } 1010| | 1011| 8.16k|#if FLAC__HAS_OGG 1012| | /*@@@ could go in !internal_reset_hack block below */ 1013| 8.16k| if(decoder->private_->is_ogg) ------------------ | Branch (1013:5): [True: 0, False: 8.16k] ------------------ 1014| 0| FLAC__ogg_decoder_aspect_reset(&decoder->protected_->ogg_decoder_aspect); 1015| 8.16k|#endif 1016| | 1017| | /* Rewind if necessary. If FLAC__stream_decoder_init() is calling us, 1018| | * (internal_reset_hack) don't try to rewind since we are already at 1019| | * the beginning of the stream and don't want to fail if the input is 1020| | * not seekable. 1021| | */ 1022| 8.16k| if(!decoder->private_->internal_reset_hack) { ------------------ | Branch (1022:5): [True: 0, False: 8.16k] ------------------ 1023| 0| if(decoder->private_->file == stdin) ------------------ | Branch (1023:6): [True: 0, False: 0] ------------------ 1024| 0| return false; /* can't rewind stdin, reset fails */ 1025| 0| if(decoder->private_->seek_callback && decoder->private_->seek_callback(decoder, 0, decoder->private_->client_data) == FLAC__STREAM_DECODER_SEEK_STATUS_ERROR) ------------------ | Branch (1025:6): [True: 0, False: 0] | Branch (1025:42): [True: 0, False: 0] ------------------ 1026| 0| return false; /* seekable and seek fails, reset fails */ 1027| 0| } 1028| | 1029| 8.16k| reset_decoder_internal_(decoder); 1030| | 1031| | return true; 1032| 8.16k|} FLAC__stream_decoder_process_single: 1035| 219k|{ 1036| 219k| FLAC__bool got_a_frame; 1037| 219k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 219k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 219k] | | ------------------ ------------------ 1038| 219k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 219k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 219k] | | ------------------ ------------------ 1039| | 1040| 431k| while(1) { ------------------ | Branch (1040:8): [True: 431k, Folded] ------------------ 1041| 431k| switch(decoder->protected_->state) { 1042| 8.16k| case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA: ------------------ | Branch (1042:4): [True: 8.16k, False: 423k] ------------------ 1043| 8.16k| if(!find_metadata_(decoder)) ------------------ | Branch (1043:8): [True: 0, False: 8.16k] ------------------ 1044| 0| return false; /* above function sets the status for us */ 1045| 8.16k| break; 1046| 16.3k| case FLAC__STREAM_DECODER_READ_METADATA: ------------------ | Branch (1046:4): [True: 16.3k, False: 415k] ------------------ 1047| 16.3k| if(!read_metadata_(decoder)) ------------------ | Branch (1047:8): [True: 0, False: 16.3k] ------------------ 1048| 0| return false; /* above function sets the status for us */ 1049| 16.3k| else 1050| 16.3k| return true; 1051| 203k| case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC: ------------------ | Branch (1051:4): [True: 203k, False: 228k] ------------------ 1052| 203k| if(!frame_sync_(decoder)) { ------------------ | Branch (1052:8): [True: 0, False: 203k] ------------------ 1053| 0| return true; /* above function sets the status for us */ 1054| 0| } 1055| 203k| break; 1056| 203k| case FLAC__STREAM_DECODER_READ_FRAME: ------------------ | Branch (1056:4): [True: 203k, False: 228k] ------------------ 1057| 203k| if(!read_frame_(decoder, &got_a_frame, /*do_full_decode=*/true)) ------------------ | Branch (1057:8): [True: 0, False: 203k] ------------------ 1058| 0| return false; /* above function sets the status for us */ 1059| 203k| if(got_a_frame) ------------------ | Branch (1059:8): [True: 203k, False: 0] ------------------ 1060| 203k| return true; /* above function sets the status for us */ 1061| 0| break; 1062| 0| case FLAC__STREAM_DECODER_END_OF_STREAM: ------------------ | Branch (1062:4): [True: 0, False: 431k] ------------------ 1063| 0| case FLAC__STREAM_DECODER_END_OF_LINK: ------------------ | Branch (1063:4): [True: 0, False: 431k] ------------------ 1064| 0| case FLAC__STREAM_DECODER_ABORTED: ------------------ | Branch (1064:4): [True: 0, False: 431k] ------------------ 1065| 0| return true; 1066| 0| default: ------------------ | Branch (1066:4): [True: 0, False: 431k] ------------------ 1067| | return false; 1068| 431k| } 1069| 431k| } 1070| 219k|} stream_decoder.c:init_stream_internal_: 365| 8.16k|{ 366| 8.16k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 367| | 368| 8.16k| if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED) ------------------ | Branch (368:5): [True: 0, False: 8.16k] ------------------ 369| 0| return FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED; 370| | 371| 8.16k| if(FLAC__HAS_OGG == 0 && is_ogg) ------------------ | | 45| 8.16k|#define FLAC__HAS_OGG 1 ------------------ | Branch (371:5): [Folded, False: 8.16k] | Branch (371:27): [True: 0, False: 0] ------------------ 372| 0| return FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER; 373| | 374| 8.16k| if( 375| 8.16k| 0 == read_callback || ------------------ | Branch (375:3): [True: 0, False: 8.16k] ------------------ 376| 8.16k| 0 == write_callback || ------------------ | Branch (376:3): [True: 0, False: 8.16k] ------------------ 377| 8.16k| 0 == error_callback || ------------------ | Branch (377:3): [True: 0, False: 8.16k] ------------------ 378| 8.16k| (seek_callback && (0 == tell_callback || 0 == length_callback || 0 == eof_callback)) ------------------ | Branch (378:4): [True: 0, False: 8.16k] | Branch (378:22): [True: 0, False: 0] | Branch (378:44): [True: 0, False: 0] | Branch (378:68): [True: 0, False: 0] ------------------ 379| 8.16k| ) 380| 0| return FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS; 381| | 382| 8.16k|#if FLAC__HAS_OGG 383| 8.16k| decoder->private_->is_ogg = is_ogg; 384| 8.16k| if(is_ogg && !FLAC__ogg_decoder_aspect_init(&decoder->protected_->ogg_decoder_aspect)) { ------------------ | Branch (384:5): [True: 0, False: 8.16k] | Branch (384:15): [True: 0, False: 0] ------------------ 385| 0| FLAC__ogg_decoder_aspect_finish(&decoder->protected_->ogg_decoder_aspect); 386| 0| return decoder->protected_->initstate = FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE; 387| 0| } 388| 8.16k|#endif 389| | 390| 8.16k| FLAC__cpu_info(&decoder->private_->cpuinfo); 391| 8.16k| decoder->private_->local_bitreader_read_rice_signed_block = FLAC__bitreader_read_rice_signed_block; 392| | 393| 8.16k|#ifdef FLAC__BMI2_SUPPORTED 394| 8.16k| if (decoder->private_->cpuinfo.x86.bmi2) { ------------------ | Branch (394:6): [True: 8.16k, False: 0] ------------------ 395| 8.16k| decoder->private_->local_bitreader_read_rice_signed_block = FLAC__bitreader_read_rice_signed_block_bmi2; 396| 8.16k| } 397| 8.16k|#endif 398| | 399| | /* from here on, errors are fatal */ 400| | 401| 8.16k| if(!FLAC__bitreader_init(decoder->private_->input, read_callback_, decoder)) { ------------------ | Branch (401:5): [True: 0, False: 8.16k] ------------------ 402| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 403| 0| return FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR; 404| 0| } 405| | 406| 8.16k| decoder->private_->read_callback = read_callback; 407| 8.16k| decoder->private_->seek_callback = seek_callback; 408| 8.16k| decoder->private_->tell_callback = tell_callback; 409| 8.16k| decoder->private_->length_callback = length_callback; 410| 8.16k| decoder->private_->eof_callback = eof_callback; 411| 8.16k| decoder->private_->write_callback = write_callback; 412| 8.16k| decoder->private_->metadata_callback = metadata_callback; 413| 8.16k| decoder->private_->error_callback = error_callback; 414| 8.16k| decoder->private_->client_data = client_data; 415| 8.16k| decoder->private_->fixed_block_size = decoder->private_->next_fixed_block_size = 0; 416| 8.16k| decoder->private_->samples_decoded = 0; 417| 8.16k| decoder->private_->has_stream_info = false; 418| 8.16k| decoder->private_->cached = false; 419| | 420| 8.16k| decoder->private_->do_md5_checking = decoder->protected_->md5_checking; 421| 8.16k| decoder->private_->is_seeking = false; 422| 8.16k| decoder->private_->is_indexing = false; 423| | 424| 8.16k| decoder->private_->internal_reset_hack = true; /* so the following reset does not try to rewind the input */ 425| 8.16k| if(!FLAC__stream_decoder_reset(decoder)) { ------------------ | Branch (425:5): [True: 0, False: 8.16k] ------------------ 426| | /* above call sets the state for us */ 427| 0| return FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR; 428| 0| } 429| | 430| 8.16k| return FLAC__STREAM_DECODER_INIT_STATUS_OK; 431| 8.16k|} stream_decoder.c:read_callback_: 3376| 235k|{ 3377| 235k| FLAC__StreamDecoder *decoder = (FLAC__StreamDecoder *)client_data; 3378| | 3379| 235k| if( 3380| 235k|#if FLAC__HAS_OGG 3381| | /* see [1] HACK NOTE below for why we don't call the eof_callback when decoding Ogg FLAC */ 3382| 235k| !decoder->private_->is_ogg && ------------------ | Branch (3382:3): [True: 235k, False: 0] ------------------ 3383| 235k|#endif 3384| 235k| decoder->private_->eof_callback && decoder->private_->eof_callback(decoder, decoder->private_->client_data) ------------------ | Branch (3384:3): [True: 0, False: 235k] | Branch (3384:38): [True: 0, False: 0] ------------------ 3385| 235k| ) { 3386| 0| *bytes = 0; 3387| 0| decoder->protected_->state = FLAC__STREAM_DECODER_END_OF_STREAM; 3388| 0| return false; 3389| 0| } 3390| 235k| else if(*bytes > 0) { ------------------ | Branch (3390:10): [True: 235k, False: 0] ------------------ 3391| | /* While seeking, it is possible for our seek to land in the 3392| | * middle of audio data that looks exactly like a frame header 3393| | * from a future version of an encoder. When that happens, our 3394| | * error callback will get an 3395| | * FLAC__STREAM_DECODER_UNPARSEABLE_STREAM and increment its 3396| | * unparseable_frame_count. But there is a remote possibility 3397| | * that it is properly synced at such a "future-codec frame", 3398| | * so to make sure, we wait to see many "unparseable" errors in 3399| | * a row before bailing out. 3400| | */ 3401| 235k| if(decoder->private_->is_seeking && decoder->private_->unparseable_frame_count > 20) { ------------------ | Branch (3401:6): [True: 0, False: 235k] | Branch (3401:39): [True: 0, False: 0] ------------------ 3402| 0| decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED; 3403| 0| return false; 3404| 0| } 3405| 235k| else { 3406| 235k| const FLAC__StreamDecoderReadStatus status = 3407| 235k|#if FLAC__HAS_OGG 3408| 235k| decoder->private_->is_ogg? ------------------ | Branch (3408:5): [True: 0, False: 235k] ------------------ 3409| 0| read_callback_ogg_aspect_(decoder, buffer, bytes) : 3410| 235k|#endif 3411| 235k| decoder->private_->read_callback(decoder, buffer, bytes, decoder->private_->client_data) 3412| 235k| ; 3413| 235k| if(status == FLAC__STREAM_DECODER_READ_STATUS_ABORT) { ------------------ | Branch (3413:7): [True: 0, False: 235k] ------------------ 3414| 0|#if FLAC__HAS_OGG 3415| 0| if(decoder->private_->ogg_decoder_aspect_allocation_failure) { ------------------ | Branch (3415:8): [True: 0, False: 0] ------------------ 3416| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 3417| 0| return false; 3418| 0| } 3419| 0|#endif 3420| 0| decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED; 3421| 0| return false; 3422| 0| } 3423| 235k| else if(*bytes == 0) { ------------------ | Branch (3423:12): [True: 0, False: 235k] ------------------ 3424| 0| if(status == FLAC__STREAM_DECODER_READ_STATUS_END_OF_LINK) { ------------------ | Branch (3424:8): [True: 0, False: 0] ------------------ 3425| 0| if(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) ------------------ | Branch (3425:9): [True: 0, False: 0] ------------------ 3426| 0| decoder->protected_->state = FLAC__STREAM_DECODER_END_OF_LINK; 3427| 0| else 3428| 0| decoder->protected_->state = FLAC__STREAM_DECODER_OGG_ERROR; 3429| 0| return false; 3430| 0| } 3431| 0| else if( 3432| 0| status == FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM || ------------------ | Branch (3432:6): [True: 0, False: 0] ------------------ 3433| 0| ( 3434| 0|#if FLAC__HAS_OGG 3435| | /* see [1] HACK NOTE below for why we don't call the eof_callback when decoding Ogg FLAC */ 3436| 0| !decoder->private_->is_ogg && ------------------ | Branch (3436:7): [True: 0, False: 0] ------------------ 3437| 0|#endif 3438| 0| decoder->private_->eof_callback && decoder->private_->eof_callback(decoder, decoder->private_->client_data) ------------------ | Branch (3438:7): [True: 0, False: 0] | Branch (3438:42): [True: 0, False: 0] ------------------ 3439| 0| ) 3440| 0| ) { 3441| 0| decoder->protected_->state = FLAC__STREAM_DECODER_END_OF_STREAM; 3442| 0| return false; 3443| 0| } 3444| 0| else 3445| 0| return true; 3446| 0| } 3447| 235k| else 3448| 235k| return true; 3449| 235k| } 3450| 235k| } 3451| 0| else { 3452| | /* abort to avoid a deadlock */ 3453| 0| decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED; 3454| 0| return false; 3455| 0| } 3456| | /* [1] @@@ HACK NOTE: The end-of-stream checking has to be hacked around 3457| | * for Ogg FLAC. This is because the ogg decoder aspect can lose sync 3458| | * and at the same time hit the end of the stream (for example, seeking 3459| | * to a point that is after the beginning of the last Ogg page). There 3460| | * is no way to report an Ogg sync loss through the callbacks (see note 3461| | * in read_callback_ogg_aspect_()) so it returns CONTINUE with *bytes==0. 3462| | * So to keep the decoder from stopping at this point we gate the call 3463| | * to the eof_callback and let the Ogg decoder aspect set the 3464| | * end-of-stream state when it is needed. 3465| | */ 3466| 235k|} stream_decoder.c:reset_decoder_internal_: 959| 8.16k|void reset_decoder_internal_(FLAC__StreamDecoder* decoder) { 960| | /* This code resets only the FLAC parser and decoder, not the Ogg part, 961| | * nor the input buffering etc. This is used to prepare the FLAC 962| | * decoder to receive another Ogg chain link */ 963| 8.16k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_METADATA; 964| | 965| 8.16k| decoder->private_->has_stream_info = false; 966| | 967| 8.16k| free(decoder->private_->seek_table.data.seek_table.points); 968| 8.16k| decoder->private_->seek_table.data.seek_table.points = 0; 969| 8.16k| decoder->private_->has_seek_table = false; 970| | 971| 8.16k| decoder->private_->do_md5_checking = decoder->protected_->md5_checking; 972| | /* 973| | * This goes in reset() and not flush() because according to the spec, a 974| | * fixed-blocksize stream must stay that way through the whole stream. 975| | */ 976| 8.16k| decoder->private_->fixed_block_size = decoder->private_->next_fixed_block_size = 0; 977| | 978| | /* We initialize the FLAC__MD5Context even though we may never use it. This 979| | * is because md5 checking may be turned on to start and then turned off if 980| | * a seek occurs. So we init the context here and finalize it in 981| | * FLAC__stream_decoder_finish() to make sure things are always cleaned up 982| | * properly. 983| | */ 984| 8.16k| if(!decoder->private_->internal_reset_hack) { ------------------ | Branch (984:5): [True: 0, False: 8.16k] ------------------ 985| | /* Only finish MD5 context when it has been initialized 986| | * (i.e. when internal_reset_hack is not set) */ 987| 0| FLAC__MD5Final(decoder->private_->computed_md5sum, &decoder->private_->md5context); 988| 0| } 989| 8.16k| else 990| 8.16k| decoder->private_->internal_reset_hack = false; 991| 8.16k| FLAC__MD5Init(&decoder->private_->md5context); 992| | 993| 8.16k| decoder->private_->first_frame_offset = 0; 994| 8.16k| decoder->private_->unparseable_frame_count = 0; 995| 8.16k| decoder->private_->last_seen_framesync = 0; 996| 8.16k| decoder->private_->last_frame_is_set = false; 997| | decoder->private_->error_has_been_sent = false; 998| 8.16k|} stream_decoder.c:set_defaults_: 1532| 16.3k|{ 1533| 16.3k| decoder->private_->is_ogg = false; 1534| 16.3k| decoder->private_->read_callback = 0; 1535| 16.3k| decoder->private_->seek_callback = 0; 1536| 16.3k| decoder->private_->tell_callback = 0; 1537| 16.3k| decoder->private_->length_callback = 0; 1538| 16.3k| decoder->private_->eof_callback = 0; 1539| 16.3k| decoder->private_->write_callback = 0; 1540| 16.3k| decoder->private_->metadata_callback = 0; 1541| 16.3k| decoder->private_->error_callback = 0; 1542| 16.3k| decoder->private_->client_data = 0; 1543| | 1544| 16.3k| memset(decoder->private_->metadata_filter, 0, sizeof(decoder->private_->metadata_filter)); 1545| 16.3k| decoder->private_->metadata_filter[FLAC__METADATA_TYPE_STREAMINFO] = true; 1546| 16.3k| decoder->private_->metadata_filter_ids_count = 0; 1547| | 1548| 16.3k| decoder->protected_->md5_checking = false; 1549| | 1550| 16.3k|#if FLAC__HAS_OGG 1551| 16.3k| FLAC__ogg_decoder_aspect_set_defaults(&decoder->protected_->ogg_decoder_aspect); 1552| 16.3k|#endif 1553| 16.3k|} stream_decoder.c:find_metadata_: 1655| 8.16k|{ 1656| 8.16k| FLAC__uint32 x; 1657| 8.16k| uint32_t i, id; 1658| 8.16k| FLAC__bool first = true; 1659| | 1660| 8.16k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 1661| | 1662| 40.8k| for(i = id = 0; i < 4; ) { ------------------ | Branch (1662:18): [True: 32.6k, False: 8.16k] ------------------ 1663| 32.6k| if(decoder->private_->cached) { ------------------ | Branch (1663:6): [True: 0, False: 32.6k] ------------------ 1664| 0| x = (FLAC__uint32)decoder->private_->lookahead; 1665| 0| decoder->private_->cached = false; 1666| 0| } 1667| 32.6k| else { 1668| 32.6k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (1668:7): [True: 0, False: 32.6k] ------------------ 1669| 0| return false; /* read_callback_ sets the state for us */ 1670| 32.6k| } 1671| 32.6k| if(x == FLAC__STREAM_SYNC_STRING[i]) { ------------------ | Branch (1671:6): [True: 32.6k, False: 0] ------------------ 1672| 32.6k| first = true; 1673| 32.6k| i++; 1674| 32.6k| id = 0; 1675| 32.6k| continue; 1676| 32.6k| } 1677| | 1678| 0| if(id >= 3) ------------------ | Branch (1678:6): [True: 0, False: 0] ------------------ 1679| 0| return false; 1680| | 1681| 0| if(x == ID3V2_TAG_[id]) { ------------------ | Branch (1681:6): [True: 0, False: 0] ------------------ 1682| 0| id++; 1683| 0| i = 0; 1684| 0| if(id == 3) { ------------------ | Branch (1684:7): [True: 0, False: 0] ------------------ 1685| 0| if(!skip_id3v2_tag_(decoder)) ------------------ | Branch (1685:8): [True: 0, False: 0] ------------------ 1686| 0| return false; /* skip_id3v2_tag_ sets the state for us */ 1687| 0| } 1688| 0| continue; 1689| 0| } 1690| 0| id = 0; 1691| 0| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (1691:6): [True: 0, False: 0] ------------------ 1692| 0| decoder->private_->header_warmup[0] = (FLAC__byte)x; 1693| 0| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (1693:7): [True: 0, False: 0] ------------------ 1694| 0| return false; /* read_callback_ sets the state for us */ 1695| | 1696| | /* we have to check if we just read two 0xff's in a row; the second may actually be the beginning of the sync code */ 1697| | /* else we have to check if the second byte is the end of a sync code */ 1698| 0| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (1698:7): [True: 0, False: 0] ------------------ 1699| 0| decoder->private_->lookahead = (FLAC__byte)x; 1700| 0| decoder->private_->cached = true; 1701| 0| } 1702| 0| else if(x >> 1 == 0x7c) { /* MAGIC NUMBER for the last 6 sync bits and reserved 7th bit */ ------------------ | Branch (1702:12): [True: 0, False: 0] ------------------ 1703| 0| decoder->private_->header_warmup[1] = (FLAC__byte)x; 1704| 0| decoder->protected_->state = FLAC__STREAM_DECODER_READ_FRAME; 1705| 0| return true; 1706| 0| } 1707| 0| } 1708| 0| i = 0; 1709| 0| if(first) { ------------------ | Branch (1709:6): [True: 0, False: 0] ------------------ 1710| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 1711| 0| first = false; 1712| 0| } 1713| 0| } 1714| | 1715| 8.16k| decoder->protected_->state = FLAC__STREAM_DECODER_READ_METADATA; 1716| | return true; 1717| 8.16k|} stream_decoder.c:read_metadata_: 1720| 16.3k|{ 1721| 16.3k| FLAC__bool is_last; 1722| 16.3k| FLAC__uint32 i, x, type, length; 1723| | 1724| 16.3k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 16.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.3k] | | ------------------ ------------------ 1725| | 1726| 16.3k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_IS_LAST_LEN)) ------------------ | Branch (1726:5): [True: 0, False: 16.3k] ------------------ 1727| 0| return false; /* read_callback_ sets the state for us */ 1728| 16.3k| is_last = x? true : false; ------------------ | Branch (1728:12): [True: 8.16k, False: 8.16k] ------------------ 1729| | 1730| 16.3k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &type, FLAC__STREAM_METADATA_TYPE_LEN)) ------------------ | Branch (1730:5): [True: 0, False: 16.3k] ------------------ 1731| 0| return false; /* read_callback_ sets the state for us */ 1732| | 1733| 16.3k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &length, FLAC__STREAM_METADATA_LENGTH_LEN)) ------------------ | Branch (1733:5): [True: 0, False: 16.3k] ------------------ 1734| 0| return false; /* read_callback_ sets the state for us */ 1735| | 1736| 16.3k| if(type == FLAC__METADATA_TYPE_STREAMINFO) { ------------------ | Branch (1736:5): [True: 8.16k, False: 8.16k] ------------------ 1737| 8.16k| if(!read_metadata_streaminfo_(decoder, is_last, length)) ------------------ | Branch (1737:6): [True: 0, False: 8.16k] ------------------ 1738| 0| return false; 1739| | 1740| 8.16k| decoder->private_->has_stream_info = true; 1741| 8.16k| if(0 == memcmp(decoder->private_->stream_info.data.stream_info.md5sum, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16)) ------------------ | Branch (1741:6): [True: 8.16k, False: 0] ------------------ 1742| 8.16k| decoder->private_->do_md5_checking = false; 1743| 8.16k| if(!decoder->private_->is_seeking && decoder->private_->metadata_filter[FLAC__METADATA_TYPE_STREAMINFO] && decoder->private_->metadata_callback) ------------------ | Branch (1743:6): [True: 8.16k, False: 0] | Branch (1743:40): [True: 8.16k, False: 0] | Branch (1743:110): [True: 8.16k, False: 0] ------------------ 1744| 8.16k| decoder->private_->metadata_callback(decoder, &decoder->private_->stream_info, decoder->private_->client_data); 1745| 8.16k| } 1746| 8.16k| else if(type == FLAC__METADATA_TYPE_SEEKTABLE) { ------------------ | Branch (1746:10): [True: 0, False: 8.16k] ------------------ 1747| | /* just in case we already have a seek table, and reading the next one fails: */ 1748| 0| decoder->private_->has_seek_table = false; 1749| | 1750| 0| if(length > 0) { ------------------ | Branch (1750:6): [True: 0, False: 0] ------------------ 1751| 0| if(!read_metadata_seektable_(decoder, is_last, length)) ------------------ | Branch (1751:7): [True: 0, False: 0] ------------------ 1752| 0| return false; 1753| | 1754| 0| decoder->private_->has_seek_table = true; 1755| 0| if(!decoder->private_->is_seeking && decoder->private_->metadata_filter[FLAC__METADATA_TYPE_SEEKTABLE] && decoder->private_->metadata_callback) ------------------ | Branch (1755:7): [True: 0, False: 0] | Branch (1755:41): [True: 0, False: 0] | Branch (1755:110): [True: 0, False: 0] ------------------ 1756| 0| decoder->private_->metadata_callback(decoder, &decoder->private_->seek_table, decoder->private_->client_data); 1757| 0| } 1758| 0| } 1759| 8.16k| else { 1760| 8.16k| FLAC__bool skip_it = !decoder->private_->metadata_filter[type]; 1761| 8.16k| uint32_t real_length = length; 1762| 8.16k| FLAC__StreamMetadata block; 1763| | 1764| 8.16k| memset(&block, 0, sizeof(block)); 1765| 8.16k| block.is_last = is_last; 1766| 8.16k| block.type = (FLAC__MetadataType)type; 1767| 8.16k| block.length = length; 1768| | 1769| 8.16k| if(type == FLAC__METADATA_TYPE_APPLICATION) { ------------------ | Branch (1769:6): [True: 0, False: 8.16k] ------------------ 1770| 0| if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, block.data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8)) ------------------ | Branch (1770:7): [True: 0, False: 0] ------------------ 1771| 0| return false; /* read_callback_ sets the state for us */ 1772| | 1773| 0| if(real_length < FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) { /* underflow check */ ------------------ | Branch (1773:7): [True: 0, False: 0] ------------------ 1774| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;/*@@@@@@ maybe wrong error? need to resync?*/ 1775| 0| return false; 1776| 0| } 1777| | 1778| 0| real_length -= FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8; 1779| | 1780| 0| if(decoder->private_->metadata_filter_ids_count > 0 && has_id_filtered_(decoder, block.data.application.id)) ------------------ | Branch (1780:7): [True: 0, False: 0] | Branch (1780:59): [True: 0, False: 0] ------------------ 1781| 0| skip_it = !skip_it; 1782| 0| } 1783| | 1784| 8.16k| if(skip_it) { ------------------ | Branch (1784:6): [True: 8.16k, False: 0] ------------------ 1785| 8.16k| if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, real_length)) ------------------ | Branch (1785:7): [True: 0, False: 8.16k] ------------------ 1786| 0| return false; /* read_callback_ sets the state for us */ 1787| 8.16k| } 1788| 0| else { 1789| 0| FLAC__bool ok = true; 1790| 0| FLAC__bitreader_set_limit(decoder->private_->input, real_length*8); 1791| 0| switch(type) { 1792| 0| case FLAC__METADATA_TYPE_PADDING: ------------------ | Branch (1792:5): [True: 0, False: 0] ------------------ 1793| | /* skip the padding bytes */ 1794| 0| if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, real_length)) ------------------ | Branch (1794:9): [True: 0, False: 0] ------------------ 1795| 0| ok = false; /* read_callback_ sets the state for us */ 1796| 0| break; 1797| 0| case FLAC__METADATA_TYPE_APPLICATION: ------------------ | Branch (1797:5): [True: 0, False: 0] ------------------ 1798| | /* remember, we read the ID already */ 1799| 0| if(real_length > 0) { ------------------ | Branch (1799:9): [True: 0, False: 0] ------------------ 1800| 0| if(0 == (block.data.application.data = malloc(real_length))) { ------------------ | Branch (1800:10): [True: 0, False: 0] ------------------ 1801| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1802| 0| ok = false; 1803| 0| } 1804| 0| else if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, block.data.application.data, real_length)) ------------------ | Branch (1804:15): [True: 0, False: 0] ------------------ 1805| 0| ok = false; /* read_callback_ sets the state for us */ 1806| 0| } 1807| 0| else 1808| 0| block.data.application.data = 0; 1809| 0| break; 1810| 0| case FLAC__METADATA_TYPE_VORBIS_COMMENT: ------------------ | Branch (1810:5): [True: 0, False: 0] ------------------ 1811| 0| if(!read_metadata_vorbiscomment_(decoder, &block.data.vorbis_comment, real_length)) ------------------ | Branch (1811:9): [True: 0, False: 0] ------------------ 1812| 0| ok = false; 1813| 0| break; 1814| 0| case FLAC__METADATA_TYPE_CUESHEET: ------------------ | Branch (1814:5): [True: 0, False: 0] ------------------ 1815| 0| if(!read_metadata_cuesheet_(decoder, &block.data.cue_sheet)) ------------------ | Branch (1815:9): [True: 0, False: 0] ------------------ 1816| 0| ok = false; 1817| 0| break; 1818| 0| case FLAC__METADATA_TYPE_PICTURE: ------------------ | Branch (1818:5): [True: 0, False: 0] ------------------ 1819| 0| if(!read_metadata_picture_(decoder, &block.data.picture)) ------------------ | Branch (1819:9): [True: 0, False: 0] ------------------ 1820| 0| ok = false; 1821| 0| break; 1822| 0| case FLAC__METADATA_TYPE_STREAMINFO: ------------------ | Branch (1822:5): [True: 0, False: 0] ------------------ 1823| 0| case FLAC__METADATA_TYPE_SEEKTABLE: ------------------ | Branch (1823:5): [True: 0, False: 0] ------------------ 1824| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 1825| 0| break; 1826| 0| default: ------------------ | Branch (1826:5): [True: 0, False: 0] ------------------ 1827| 0| if(real_length > 0) { ------------------ | Branch (1827:9): [True: 0, False: 0] ------------------ 1828| 0| if(0 == (block.data.unknown.data = malloc(real_length))) { ------------------ | Branch (1828:10): [True: 0, False: 0] ------------------ 1829| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1830| 0| ok = false; 1831| 0| } 1832| 0| else if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, block.data.unknown.data, real_length)) ------------------ | Branch (1832:15): [True: 0, False: 0] ------------------ 1833| 0| ok = false; /* read_callback_ sets the state for us */ 1834| 0| } 1835| 0| else 1836| 0| block.data.unknown.data = 0; 1837| 0| break; 1838| 0| } 1839| 0| if(FLAC__bitreader_limit_remaining(decoder->private_->input) > 0) { ------------------ | Branch (1839:7): [True: 0, False: 0] ------------------ 1840| | /* Content in metadata block didn't fit in block length 1841| | * We cannot know whether the length or the content was 1842| | * corrupt, so stop parsing metadata */ 1843| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA); 1844| 0| if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_METADATA) ------------------ | Branch (1844:8): [True: 0, False: 0] ------------------ 1845| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 1846| 0| ok = false; 1847| 0| } 1848| 0| FLAC__bitreader_remove_limit(decoder->private_->input); 1849| 0| if(ok && !decoder->private_->is_seeking && decoder->private_->metadata_callback) ------------------ | Branch (1849:7): [True: 0, False: 0] | Branch (1849:13): [True: 0, False: 0] | Branch (1849:47): [True: 0, False: 0] ------------------ 1850| 0| decoder->private_->metadata_callback(decoder, &block, decoder->private_->client_data); 1851| | 1852| | /* now we have to free any malloc()ed data in the block */ 1853| 0| switch(type) { 1854| 0| case FLAC__METADATA_TYPE_PADDING: ------------------ | Branch (1854:5): [True: 0, False: 0] ------------------ 1855| 0| break; 1856| 0| case FLAC__METADATA_TYPE_APPLICATION: ------------------ | Branch (1856:5): [True: 0, False: 0] ------------------ 1857| 0| if(0 != block.data.application.data) ------------------ | Branch (1857:9): [True: 0, False: 0] ------------------ 1858| 0| free(block.data.application.data); 1859| 0| break; 1860| 0| case FLAC__METADATA_TYPE_VORBIS_COMMENT: ------------------ | Branch (1860:5): [True: 0, False: 0] ------------------ 1861| 0| if(0 != block.data.vorbis_comment.vendor_string.entry) ------------------ | Branch (1861:9): [True: 0, False: 0] ------------------ 1862| 0| free(block.data.vorbis_comment.vendor_string.entry); 1863| 0| if(block.data.vorbis_comment.num_comments > 0) ------------------ | Branch (1863:9): [True: 0, False: 0] ------------------ 1864| 0| for(i = 0; i < block.data.vorbis_comment.num_comments; i++) ------------------ | Branch (1864:18): [True: 0, False: 0] ------------------ 1865| 0| if(0 != block.data.vorbis_comment.comments[i].entry) ------------------ | Branch (1865:11): [True: 0, False: 0] ------------------ 1866| 0| free(block.data.vorbis_comment.comments[i].entry); 1867| 0| if(0 != block.data.vorbis_comment.comments) ------------------ | Branch (1867:9): [True: 0, False: 0] ------------------ 1868| 0| free(block.data.vorbis_comment.comments); 1869| 0| break; 1870| 0| case FLAC__METADATA_TYPE_CUESHEET: ------------------ | Branch (1870:5): [True: 0, False: 0] ------------------ 1871| 0| if(block.data.cue_sheet.num_tracks > 0 && 0 != block.data.cue_sheet.tracks) ------------------ | Branch (1871:9): [True: 0, False: 0] | Branch (1871:48): [True: 0, False: 0] ------------------ 1872| 0| for(i = 0; i < block.data.cue_sheet.num_tracks; i++) ------------------ | Branch (1872:18): [True: 0, False: 0] ------------------ 1873| 0| if(0 != block.data.cue_sheet.tracks[i].indices) ------------------ | Branch (1873:11): [True: 0, False: 0] ------------------ 1874| 0| free(block.data.cue_sheet.tracks[i].indices); 1875| 0| if(0 != block.data.cue_sheet.tracks) ------------------ | Branch (1875:9): [True: 0, False: 0] ------------------ 1876| 0| free(block.data.cue_sheet.tracks); 1877| 0| break; 1878| 0| case FLAC__METADATA_TYPE_PICTURE: ------------------ | Branch (1878:5): [True: 0, False: 0] ------------------ 1879| 0| if(0 != block.data.picture.mime_type) ------------------ | Branch (1879:9): [True: 0, False: 0] ------------------ 1880| 0| free(block.data.picture.mime_type); 1881| 0| if(0 != block.data.picture.description) ------------------ | Branch (1881:9): [True: 0, False: 0] ------------------ 1882| 0| free(block.data.picture.description); 1883| 0| if(0 != block.data.picture.data) ------------------ | Branch (1883:9): [True: 0, False: 0] ------------------ 1884| 0| free(block.data.picture.data); 1885| 0| break; 1886| 0| case FLAC__METADATA_TYPE_STREAMINFO: ------------------ | Branch (1886:5): [True: 0, False: 0] ------------------ 1887| 0| case FLAC__METADATA_TYPE_SEEKTABLE: ------------------ | Branch (1887:5): [True: 0, False: 0] ------------------ 1888| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 1889| 0| default: ------------------ | Branch (1889:5): [True: 0, False: 0] ------------------ 1890| 0| if(0 != block.data.unknown.data) ------------------ | Branch (1890:9): [True: 0, False: 0] ------------------ 1891| 0| free(block.data.unknown.data); 1892| 0| break; 1893| 0| } 1894| | 1895| 0| if(!ok) /* anything that unsets "ok" should also make sure decoder->protected_->state is updated */ ------------------ | Branch (1895:7): [True: 0, False: 0] ------------------ 1896| 0| return false; 1897| 0| } 1898| 8.16k| } 1899| | 1900| 16.3k| if(is_last) { ------------------ | Branch (1900:5): [True: 8.16k, False: 8.16k] ------------------ 1901| | /* if this fails, it's OK, it's just a hint for the seek routine */ 1902| 8.16k| if(!FLAC__stream_decoder_get_decode_position(decoder, &decoder->private_->first_frame_offset)) ------------------ | Branch (1902:6): [True: 8.16k, False: 0] ------------------ 1903| 8.16k| decoder->private_->first_frame_offset = 0; 1904| 8.16k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 1905| 8.16k| } 1906| | 1907| | return true; 1908| 16.3k|} stream_decoder.c:read_metadata_streaminfo_: 1911| 8.16k|{ 1912| 8.16k| FLAC__uint32 x; 1913| 8.16k| uint32_t bits, used_bits = 0; 1914| | 1915| 8.16k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 1916| | 1917| 8.16k| decoder->private_->stream_info.type = FLAC__METADATA_TYPE_STREAMINFO; 1918| 8.16k| decoder->private_->stream_info.is_last = is_last; 1919| 8.16k| decoder->private_->stream_info.length = length; 1920| | 1921| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; 1922| 8.16k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, bits)) ------------------ | Branch (1922:5): [True: 0, False: 8.16k] ------------------ 1923| 0| return false; /* read_callback_ sets the state for us */ 1924| 8.16k| decoder->private_->stream_info.data.stream_info.min_blocksize = x; 1925| 8.16k| used_bits += bits; 1926| | 1927| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; 1928| 8.16k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)) ------------------ | Branch (1928:5): [True: 0, False: 8.16k] ------------------ 1929| 0| return false; /* read_callback_ sets the state for us */ 1930| 8.16k| decoder->private_->stream_info.data.stream_info.max_blocksize = x; 1931| 8.16k| used_bits += bits; 1932| | 1933| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; 1934| 8.16k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) ------------------ | Branch (1934:5): [True: 0, False: 8.16k] ------------------ 1935| 0| return false; /* read_callback_ sets the state for us */ 1936| 8.16k| decoder->private_->stream_info.data.stream_info.min_framesize = x; 1937| 8.16k| used_bits += bits; 1938| | 1939| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; 1940| 8.16k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) ------------------ | Branch (1940:5): [True: 0, False: 8.16k] ------------------ 1941| 0| return false; /* read_callback_ sets the state for us */ 1942| 8.16k| decoder->private_->stream_info.data.stream_info.max_framesize = x; 1943| 8.16k| used_bits += bits; 1944| | 1945| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; 1946| 8.16k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)) ------------------ | Branch (1946:5): [True: 0, False: 8.16k] ------------------ 1947| 0| return false; /* read_callback_ sets the state for us */ 1948| 8.16k| decoder->private_->stream_info.data.stream_info.sample_rate = x; 1949| 8.16k| used_bits += bits; 1950| | 1951| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; 1952| 8.16k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)) ------------------ | Branch (1952:5): [True: 0, False: 8.16k] ------------------ 1953| 0| return false; /* read_callback_ sets the state for us */ 1954| 8.16k| decoder->private_->stream_info.data.stream_info.channels = x+1; 1955| 8.16k| used_bits += bits; 1956| | 1957| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; 1958| 8.16k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)) ------------------ | Branch (1958:5): [True: 0, False: 8.16k] ------------------ 1959| 0| return false; /* read_callback_ sets the state for us */ 1960| 8.16k| decoder->private_->stream_info.data.stream_info.bits_per_sample = x+1; 1961| 8.16k| used_bits += bits; 1962| | 1963| 8.16k| bits = FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; 1964| 8.16k| if(!FLAC__bitreader_read_raw_uint64(decoder->private_->input, &decoder->private_->stream_info.data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) ------------------ | Branch (1964:5): [True: 0, False: 8.16k] ------------------ 1965| 0| return false; /* read_callback_ sets the state for us */ 1966| 8.16k| used_bits += bits; 1967| | 1968| 8.16k| if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, decoder->private_->stream_info.data.stream_info.md5sum, 16)) ------------------ | Branch (1968:5): [True: 0, False: 8.16k] ------------------ 1969| 0| return false; /* read_callback_ sets the state for us */ 1970| 8.16k| used_bits += 16*8; 1971| | 1972| | /* skip the rest of the block */ 1973| 8.16k| FLAC__ASSERT(used_bits % 8 == 0); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 1974| 8.16k| if (length < (used_bits / 8)) ------------------ | Branch (1974:6): [True: 0, False: 8.16k] ------------------ 1975| 0| return false; /* read_callback_ sets the state for us */ 1976| 8.16k| length -= (used_bits / 8); 1977| 8.16k| if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, length)) ------------------ | Branch (1977:5): [True: 0, False: 8.16k] ------------------ 1978| 0| return false; /* read_callback_ sets the state for us */ 1979| | 1980| 8.16k| return true; 1981| 8.16k|} stream_decoder.c:frame_sync_: 2322| 203k|{ 2323| 203k| FLAC__uint32 x; 2324| 203k| FLAC__bool first = true; 2325| | 2326| | /* make sure we're byte aligned */ 2327| 203k| if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) { ------------------ | Branch (2327:5): [True: 0, False: 203k] ------------------ 2328| 0| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__bitreader_bits_left_for_byte_alignment(decoder->private_->input))) ------------------ | Branch (2328:6): [True: 0, False: 0] ------------------ 2329| 0| return false; /* read_callback_ sets the state for us */ 2330| 0| } 2331| | 2332| 203k| while(1) { ------------------ | Branch (2332:8): [True: 203k, Folded] ------------------ 2333| 203k| if(decoder->private_->cached) { ------------------ | Branch (2333:6): [True: 0, False: 203k] ------------------ 2334| 0| x = (FLAC__uint32)decoder->private_->lookahead; 2335| 0| decoder->private_->cached = false; 2336| 0| } 2337| 203k| else { 2338| 203k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2338:7): [True: 0, False: 203k] ------------------ 2339| 0| return false; /* read_callback_ sets the state for us */ 2340| 203k| } 2341| 203k| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (2341:6): [True: 203k, False: 0] ------------------ 2342| 203k| decoder->private_->header_warmup[0] = (FLAC__byte)x; 2343| 203k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2343:7): [True: 0, False: 203k] ------------------ 2344| 0| return false; /* read_callback_ sets the state for us */ 2345| | 2346| | /* we have to check if we just read two 0xff's in a row; the second may actually be the beginning of the sync code */ 2347| | /* else we have to check if the second byte is the end of a sync code */ 2348| 203k| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (2348:7): [True: 0, False: 203k] ------------------ 2349| 0| decoder->private_->lookahead = (FLAC__byte)x; 2350| 0| decoder->private_->cached = true; 2351| 0| } 2352| 203k| else if(x >> 1 == 0x7c) { /* MAGIC NUMBER for the last 6 sync bits and reserved 7th bit */ ------------------ | Branch (2352:12): [True: 203k, False: 0] ------------------ 2353| 203k| decoder->private_->header_warmup[1] = (FLAC__byte)x; 2354| 203k| decoder->protected_->state = FLAC__STREAM_DECODER_READ_FRAME; 2355| | 2356| | /* Save location so we can rewind in case the frame turns 2357| | * out to be invalid after the header */ 2358| 203k| FLAC__bitreader_set_framesync_location(decoder->private_->input); 2359| 203k| if(!FLAC__stream_decoder_get_decode_position(decoder, &decoder->private_->last_seen_framesync)) ------------------ | Branch (2359:8): [True: 203k, False: 0] ------------------ 2360| 203k| decoder->private_->last_seen_framesync = 0; 2361| 203k| return true; 2362| 203k| } 2363| 203k| } 2364| 0| if(first) { ------------------ | Branch (2364:6): [True: 0, False: 0] ------------------ 2365| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 2366| 0| first = false; 2367| 0| } 2368| 0| } 2369| | 2370| 0| return true; 2371| 203k|} stream_decoder.c:read_frame_: 2374| 203k|{ 2375| 203k| uint32_t channel; 2376| 203k| uint32_t i; 2377| 203k| uint32_t frame_crc; /* the one we calculate from the input stream */ 2378| 203k| FLAC__uint32 x; 2379| | 2380| 203k| *got_a_frame = false; 2381| 203k| decoder->private_->side_subframe_in_use = false; 2382| | 2383| | /* init the CRC */ 2384| 203k| frame_crc = 0; 2385| 203k| frame_crc = FLAC__CRC16_UPDATE(decoder->private_->header_warmup[0], frame_crc); ------------------ | | 50| 203k|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) ------------------ 2386| 203k| frame_crc = FLAC__CRC16_UPDATE(decoder->private_->header_warmup[1], frame_crc); ------------------ | | 50| 203k|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) ------------------ 2387| 203k| FLAC__bitreader_reset_read_crc16(decoder->private_->input, (FLAC__uint16)frame_crc); 2388| | 2389| 203k| if(!read_frame_header_(decoder)) ------------------ | Branch (2389:5): [True: 0, False: 203k] ------------------ 2390| 0| return false; 2391| 203k| if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means we didn't sync on a valid header */ ------------------ | Branch (2391:5): [True: 0, False: 203k] ------------------ 2392| 0| return true; 2393| 203k| if(!allocate_output_(decoder, decoder->private_->frame.header.blocksize, decoder->private_->frame.header.channels, decoder->private_->frame.header.bits_per_sample)) ------------------ | Branch (2393:5): [True: 0, False: 203k] ------------------ 2394| 0| return false; 2395| 473k| for(channel = 0; channel < decoder->private_->frame.header.channels; channel++) { ------------------ | Branch (2395:19): [True: 270k, False: 203k] ------------------ 2396| | /* 2397| | * first figure the correct bits-per-sample of the subframe 2398| | */ 2399| 270k| uint32_t bps = decoder->private_->frame.header.bits_per_sample; 2400| 270k| switch(decoder->private_->frame.header.channel_assignment) { 2401| 198k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (2401:4): [True: 198k, False: 71.6k] ------------------ 2402| | /* no adjustment needed */ 2403| 198k| break; 2404| 34.4k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (2404:4): [True: 34.4k, False: 235k] ------------------ 2405| 34.4k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 34.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 34.4k] | | ------------------ ------------------ 2406| 34.4k| if(channel == 1) ------------------ | Branch (2406:8): [True: 17.2k, False: 17.2k] ------------------ 2407| 17.2k| bps++; 2408| 34.4k| break; 2409| 15.2k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (2409:4): [True: 15.2k, False: 255k] ------------------ 2410| 15.2k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 15.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 15.2k] | | ------------------ ------------------ 2411| 15.2k| if(channel == 0) ------------------ | Branch (2411:8): [True: 7.62k, False: 7.62k] ------------------ 2412| 7.62k| bps++; 2413| 15.2k| break; 2414| 21.9k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (2414:4): [True: 21.9k, False: 248k] ------------------ 2415| 21.9k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 2416| 21.9k| if(channel == 1) ------------------ | Branch (2416:8): [True: 10.9k, False: 10.9k] ------------------ 2417| 10.9k| bps++; 2418| 21.9k| break; 2419| 0| default: ------------------ | Branch (2419:4): [True: 0, False: 270k] ------------------ 2420| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 2421| 270k| } 2422| | /* 2423| | * now read it 2424| | */ 2425| 270k| if(!read_subframe_(decoder, channel, bps, do_full_decode)){ ------------------ | Branch (2425:6): [True: 0, False: 270k] ------------------ 2426| | /* read_callback_ sets the state for us */ 2427| 0| if(decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM) ------------------ | Branch (2427:7): [True: 0, False: 0] ------------------ 2428| 0| break; 2429| 0| else 2430| 0| return false; 2431| 0| } 2432| 270k| if(decoder->protected_->state != FLAC__STREAM_DECODER_READ_FRAME) ------------------ | Branch (2432:6): [True: 0, False: 270k] ------------------ 2433| 0| break; 2434| 270k| } 2435| | 2436| 203k| if(decoder->protected_->state != FLAC__STREAM_DECODER_END_OF_STREAM) ------------------ | Branch (2436:5): [True: 203k, False: 0] ------------------ 2437| 203k| if(!read_zero_padding_(decoder)) ------------------ | Branch (2437:6): [True: 0, False: 203k] ------------------ 2438| 0| return false; 2439| | 2440| | /* 2441| | * Read the frame CRC-16 from the footer and check 2442| | */ 2443| 203k| if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) { ------------------ | Branch (2443:5): [True: 203k, False: 0] ------------------ 2444| 203k| frame_crc = FLAC__bitreader_get_read_crc16(decoder->private_->input); 2445| 203k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__FRAME_FOOTER_CRC_LEN)) { ------------------ | Branch (2445:6): [True: 0, False: 203k] ------------------ 2446| | /* read_callback_ sets the state for us */ 2447| 0| if(decoder->protected_->state != FLAC__STREAM_DECODER_END_OF_STREAM) ------------------ | Branch (2447:7): [True: 0, False: 0] ------------------ 2448| 0| return false; 2449| 0| } 2450| |#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2451| | } 2452| | if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME && frame_crc == x) { 2453| |#endif 2454| 203k| if(do_full_decode) { ------------------ | Branch (2454:6): [True: 203k, False: 0] ------------------ 2455| | /* Undo any special channel coding */ 2456| 203k| undo_channel_coding(decoder); 2457| | /* Check whether decoded data actually fits bps */ 2458| 473k| for(channel = 0; channel < decoder->private_->frame.header.channels; channel++) { ------------------ | Branch (2458:21): [True: 270k, False: 203k] ------------------ 2459| 270k| int shift_bits = 32 - decoder->private_->frame.header.bits_per_sample; 2460| 270k| int lower_limit = INT32_MIN >> shift_bits; 2461| 270k| int upper_limit = INT32_MAX >> shift_bits; 2462| 28.2M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (2462:16): [True: 27.9M, False: 270k] ------------------ 2463| | /* Check whether shift_bits MSBs are 'empty' by shifting up and down */ 2464| 27.9M| if((decoder->private_->output[channel][i] < lower_limit) || ------------------ | Branch (2464:9): [True: 0, False: 27.9M] ------------------ 2465| 27.9M| (decoder->private_->output[channel][i] > upper_limit)) { ------------------ | Branch (2465:9): [True: 0, False: 27.9M] ------------------ 2466| | /* Bad frame, emit error */ 2467| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_OUT_OF_BOUNDS); 2468| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2469| 0| break; 2470| 0| } 2471| 27.9M| } 2472| 270k| } 2473| 203k| } 2474| 203k| } 2475| |#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2476| | else if (decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) { 2477| | /* Bad frame, emit error */ 2478| | send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH); 2479| | decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2480| | } 2481| |#endif 2482| | 2483| | /* Check whether frames are missing, if so, add silence to compensate */ 2484| 203k| if(decoder->private_->last_frame_is_set && decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME && !decoder->private_->is_seeking && do_full_decode) { ------------------ | Branch (2484:5): [True: 195k, False: 7.71k] | Branch (2484:45): [True: 195k, False: 0] | Branch (2484:110): [True: 195k, False: 0] | Branch (2484:144): [True: 195k, False: 0] ------------------ 2485| 195k| FLAC__ASSERT(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 195k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 195k] | | ------------------ ------------------ 2486| 195k| FLAC__ASSERT(decoder->private_->last_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 195k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 195k] | | ------------------ ------------------ 2487| 195k| if(decoder->private_->last_frame.header.number.sample_number + decoder->private_->last_frame.header.blocksize < decoder->private_->frame.header.number.sample_number) { ------------------ | Branch (2487:6): [True: 0, False: 195k] ------------------ 2488| 0| uint32_t padding_samples_needed = decoder->private_->frame.header.number.sample_number - (decoder->private_->last_frame.header.number.sample_number + decoder->private_->last_frame.header.blocksize); 2489| | /* Send an error that we lost sync, but only in case no error 2490| | * has been sent yet. This is the case if exactly one or more 2491| | * frames are missing, and the frames before and after it 2492| | * are complete */ 2493| 0| if(!decoder->private_->error_has_been_sent) ------------------ | Branch (2493:7): [True: 0, False: 0] ------------------ 2494| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_MISSING_FRAME); 2495| | /* Do some extra validation to assure last frame an current frame 2496| | * header are both valid before adding silence inbetween 2497| | * Technically both frames could be valid with differing sample_rates, 2498| | * channels and bits_per_sample, but it is quite rare */ 2499| 0| if(decoder->private_->last_frame.header.sample_rate == decoder->private_->frame.header.sample_rate && ------------------ | Branch (2499:7): [True: 0, False: 0] ------------------ 2500| 0| decoder->private_->last_frame.header.channels == decoder->private_->frame.header.channels && ------------------ | Branch (2500:7): [True: 0, False: 0] ------------------ 2501| 0| decoder->private_->last_frame.header.bits_per_sample == decoder->private_->frame.header.bits_per_sample && ------------------ | Branch (2501:7): [True: 0, False: 0] ------------------ 2502| 0| decoder->private_->last_frame.header.blocksize >= 16) { ------------------ | Branch (2502:7): [True: 0, False: 0] ------------------ 2503| 0| FLAC__Frame empty_frame; 2504| 0| FLAC__int32 * empty_buffer[FLAC__MAX_CHANNELS] = {NULL}; 2505| 0| empty_frame.header = decoder->private_->last_frame.header; 2506| 0| empty_frame.footer.crc = 0; 2507| 0| for(i = 0; i < empty_frame.header.channels; i++) { ------------------ | Branch (2507:16): [True: 0, False: 0] ------------------ 2508| 0| empty_buffer[i] = safe_calloc_(empty_frame.header.blocksize, sizeof(FLAC__int32)); 2509| 0| if(empty_buffer[i] == NULL) { ------------------ | Branch (2509:9): [True: 0, False: 0] ------------------ 2510| 0| for(i = 0; i < empty_frame.header.channels; i++) ------------------ | Branch (2510:18): [True: 0, False: 0] ------------------ 2511| 0| if(empty_buffer[i] != NULL) ------------------ | Branch (2511:11): [True: 0, False: 0] ------------------ 2512| 0| free(empty_buffer[i]); 2513| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 2514| 0| return false; 2515| 0| } 2516| 0| } 2517| | /* No repairs larger than 5 seconds or 50 frames are made, to not 2518| | * unexpectedly create enormous files when one of the headers was 2519| | * corrupt after all */ 2520| 0| if(padding_samples_needed > (5*empty_frame.header.sample_rate)) ------------------ | Branch (2520:8): [True: 0, False: 0] ------------------ 2521| 0| padding_samples_needed = 5*empty_frame.header.sample_rate; 2522| 0| if(padding_samples_needed > (50*empty_frame.header.blocksize)) ------------------ | Branch (2522:8): [True: 0, False: 0] ------------------ 2523| 0| padding_samples_needed = 50*empty_frame.header.blocksize; 2524| 0| while(padding_samples_needed){ ------------------ | Branch (2524:11): [True: 0, False: 0] ------------------ 2525| 0| empty_frame.header.number.sample_number += empty_frame.header.blocksize; 2526| 0| if(padding_samples_needed < empty_frame.header.blocksize) ------------------ | Branch (2526:9): [True: 0, False: 0] ------------------ 2527| 0| empty_frame.header.blocksize = padding_samples_needed; 2528| 0| padding_samples_needed -= empty_frame.header.blocksize; 2529| 0| decoder->protected_->blocksize = empty_frame.header.blocksize; 2530| | 2531| 0| FLAC__ASSERT(empty_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 2532| 0| decoder->private_->samples_decoded = empty_frame.header.number.sample_number + empty_frame.header.blocksize; 2533| | 2534| 0| for(channel = 0; channel < empty_frame.header.channels; channel++) { ------------------ | Branch (2534:23): [True: 0, False: 0] ------------------ 2535| 0| empty_frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_CONSTANT; 2536| 0| empty_frame.subframes[channel].data.constant.value = 0; 2537| 0| empty_frame.subframes[channel].wasted_bits = 0; 2538| 0| } 2539| | 2540| 0| if(write_audio_frame_to_client_(decoder, &empty_frame, (const FLAC__int32 * const *)empty_buffer) != FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE) { ------------------ | Branch (2540:9): [True: 0, False: 0] ------------------ 2541| 0| decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED; 2542| 0| for(i = 0; i < empty_frame.header.channels; i++) ------------------ | Branch (2542:18): [True: 0, False: 0] ------------------ 2543| 0| if(empty_buffer[i] != NULL) ------------------ | Branch (2543:11): [True: 0, False: 0] ------------------ 2544| 0| free(empty_buffer[i]); 2545| 0| return false; 2546| 0| } 2547| 0| } 2548| 0| for(i = 0; i < empty_frame.header.channels; i++) ------------------ | Branch (2548:16): [True: 0, False: 0] ------------------ 2549| 0| if(empty_buffer[i] != NULL) ------------------ | Branch (2549:9): [True: 0, False: 0] ------------------ 2550| 0| free(empty_buffer[i]); 2551| | 2552| 0| } 2553| 0| } 2554| 195k| } 2555| | 2556| 203k| decoder->private_->error_has_been_sent = false; 2557| | 2558| 203k| if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC || decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM) { ------------------ | Branch (2558:5): [True: 0, False: 203k] | Branch (2558:81): [True: 0, False: 203k] ------------------ 2559| 0|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2560| 0| decoder->private_->fuzzing_rewind_count++; /* To stop excessive rewinding, as it causes timeouts */ 2561| 0|#endif 2562| | /* Got corruption, rewind if possible. Return value of seek 2563| | * isn't checked, if the seek fails the decoder will continue anyway */ 2564| 0| if(!FLAC__bitreader_rewind_to_after_last_seen_framesync(decoder->private_->input)){ ------------------ | Branch (2564:6): [True: 0, False: 0] ------------------ 2565| |#ifndef NDEBUG 2566| | flac_fprintf(stderr, "Rewinding, seeking necessary\n"); 2567| |#endif 2568| 0| if(decoder->private_->seek_callback && decoder->private_->last_seen_framesync){ ------------------ | Branch (2568:7): [True: 0, False: 0] | Branch (2568:43): [True: 0, False: 0] ------------------ 2569| | /* Last framesync isn't in bitreader anymore, rewind with seek if possible */ 2570| |#ifndef NDEBUG 2571| | FLAC__uint64 current_decode_position; 2572| | if(FLAC__stream_decoder_get_decode_position(decoder, ¤t_decode_position)) 2573| | flac_fprintf(stderr, "Bitreader was %" PRIu64 " bytes short\n", current_decode_position-decoder->private_->last_seen_framesync); 2574| |#endif 2575| 0| if(decoder->private_->seek_callback(decoder, decoder->private_->last_seen_framesync, decoder->private_->client_data) == FLAC__STREAM_DECODER_SEEK_STATUS_ERROR) { ------------------ | Branch (2575:8): [True: 0, False: 0] ------------------ 2576| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR; 2577| 0| return false; 2578| 0| } 2579| 0| if(!FLAC__bitreader_clear(decoder->private_->input)) { ------------------ | Branch (2579:8): [True: 0, False: 0] ------------------ 2580| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 2581| 0| return false; 2582| 0| } 2583| 0| } 2584| 0| } 2585| |#ifndef NDEBUG 2586| | else{ 2587| | flac_fprintf(stderr, "Rewinding, seeking not necessary\n"); 2588| | } 2589| |#endif 2590| 0| } 2591| 203k| else { 2592| 203k| *got_a_frame = true; 2593| 203k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2594| 203k| decoder->private_->fuzzing_rewind_count = 0; 2595| 203k|#endif 2596| | 2597| | /* we wait to update fixed_block_size until here, when we're sure we've got a proper frame and hence a correct blocksize */ 2598| 203k| if(decoder->private_->next_fixed_block_size) ------------------ | Branch (2598:6): [True: 7.71k, False: 195k] ------------------ 2599| 7.71k| decoder->private_->fixed_block_size = decoder->private_->next_fixed_block_size; 2600| | 2601| | /* put the latest values into the public section of the decoder instance */ 2602| 203k| decoder->protected_->channels = decoder->private_->frame.header.channels; 2603| 203k| decoder->protected_->channel_assignment = decoder->private_->frame.header.channel_assignment; 2604| 203k| decoder->protected_->bits_per_sample = decoder->private_->frame.header.bits_per_sample; 2605| 203k| decoder->protected_->sample_rate = decoder->private_->frame.header.sample_rate; 2606| 203k| decoder->protected_->blocksize = decoder->private_->frame.header.blocksize; 2607| | 2608| 203k| FLAC__ASSERT(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 2609| 203k| decoder->private_->samples_decoded = decoder->private_->frame.header.number.sample_number + decoder->private_->frame.header.blocksize; 2610| | 2611| | /* write it */ 2612| 203k| if(do_full_decode) { ------------------ | Branch (2612:6): [True: 203k, False: 0] ------------------ 2613| 203k| if(write_audio_frame_to_client_(decoder, &decoder->private_->frame, (const FLAC__int32 * const *)decoder->private_->output) != FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE) { ------------------ | Branch (2613:7): [True: 0, False: 203k] ------------------ 2614| 0| decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED; 2615| 0| return false; 2616| 0| } 2617| 203k| } 2618| 203k| } 2619| | 2620| 203k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2621| | return true; 2622| 203k|} stream_decoder.c:read_frame_header_: 2625| 203k|{ 2626| 203k| FLAC__uint32 x; 2627| 203k| FLAC__uint64 xx; 2628| 203k| uint32_t i, blocksize_hint = 0, sample_rate_hint = 0; 2629| 203k| FLAC__byte crc8, raw_header[16]; /* MAGIC NUMBER based on the maximum frame header size, including CRC */ 2630| 203k| uint32_t raw_header_len; 2631| 203k| FLAC__bool is_unparseable = false; 2632| | 2633| 203k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 203k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 203k] | | ------------------ ------------------ 2634| | 2635| | /* init the raw header with the saved bits from synchronization */ 2636| 203k| raw_header[0] = decoder->private_->header_warmup[0]; 2637| 203k| raw_header[1] = decoder->private_->header_warmup[1]; 2638| 203k| raw_header_len = 2; 2639| | 2640| | /* check to make sure that reserved bit is 0 */ 2641| 203k| if(raw_header[1] & 0x02) /* MAGIC NUMBER */ ------------------ | Branch (2641:5): [True: 0, False: 203k] ------------------ 2642| 0| is_unparseable = true; 2643| | 2644| | /* 2645| | * Note that along the way as we read the header, we look for a sync 2646| | * code inside. If we find one it would indicate that our original 2647| | * sync was bad since there cannot be a sync code in a valid header. 2648| | * 2649| | * Three kinds of things can go wrong when reading the frame header: 2650| | * 1) We may have sync'ed incorrectly and not landed on a frame header. 2651| | * If we don't find a sync code, it can end up looking like we read 2652| | * a valid but unparseable header, until getting to the frame header 2653| | * CRC. Even then we could get a false positive on the CRC. 2654| | * 2) We may have sync'ed correctly but on an unparseable frame (from a 2655| | * future encoder). 2656| | * 3) We may be on a damaged frame which appears valid but unparseable. 2657| | * 2658| | * For all these reasons, we try and read a complete frame header as 2659| | * long as it seems valid, even if unparseable, up until the frame 2660| | * header CRC. 2661| | */ 2662| | 2663| | /* 2664| | * read in the raw header as bytes so we can CRC it, and parse it on the way 2665| | */ 2666| 610k| for(i = 0; i < 2; i++) { ------------------ | Branch (2666:13): [True: 407k, False: 203k] ------------------ 2667| 407k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2667:6): [True: 0, False: 407k] ------------------ 2668| 0| return false; /* read_callback_ sets the state for us */ 2669| 407k| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (2669:6): [True: 0, False: 407k] ------------------ 2670| | /* if we get here it means our original sync was erroneous since the sync code cannot appear in the header */ 2671| 0| decoder->private_->lookahead = (FLAC__byte)x; 2672| 0| decoder->private_->cached = true; 2673| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER); 2674| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2675| 0| return true; 2676| 0| } 2677| 407k| raw_header[raw_header_len++] = (FLAC__byte)x; 2678| 407k| } 2679| | 2680| 203k| switch(x = raw_header[2] >> 4) { 2681| 0| case 0: ------------------ | Branch (2681:3): [True: 0, False: 203k] ------------------ 2682| 0| is_unparseable = true; 2683| 0| break; 2684| 196| case 1: ------------------ | Branch (2684:3): [True: 196, False: 203k] ------------------ 2685| 196| decoder->private_->frame.header.blocksize = 192; 2686| 196| break; 2687| 201| case 2: ------------------ | Branch (2687:3): [True: 201, False: 203k] ------------------ 2688| 322| case 3: ------------------ | Branch (2688:3): [True: 121, False: 203k] ------------------ 2689| 390| case 4: ------------------ | Branch (2689:3): [True: 68, False: 203k] ------------------ 2690| 439| case 5: ------------------ | Branch (2690:3): [True: 49, False: 203k] ------------------ 2691| 439| decoder->private_->frame.header.blocksize = 576 << (x-2); 2692| 439| break; 2693| 200k| case 6: ------------------ | Branch (2693:3): [True: 200k, False: 3.42k] ------------------ 2694| 201k| case 7: ------------------ | Branch (2694:3): [True: 1.84k, False: 201k] ------------------ 2695| 201k| blocksize_hint = x; 2696| 201k| break; 2697| 225| case 8: ------------------ | Branch (2697:3): [True: 225, False: 203k] ------------------ 2698| 467| case 9: ------------------ | Branch (2698:3): [True: 242, False: 203k] ------------------ 2699| 616| case 10: ------------------ | Branch (2699:3): [True: 149, False: 203k] ------------------ 2700| 700| case 11: ------------------ | Branch (2700:3): [True: 84, False: 203k] ------------------ 2701| 871| case 12: ------------------ | Branch (2701:3): [True: 171, False: 203k] ------------------ 2702| 897| case 13: ------------------ | Branch (2702:3): [True: 26, False: 203k] ------------------ 2703| 929| case 14: ------------------ | Branch (2703:3): [True: 32, False: 203k] ------------------ 2704| 950| case 15: ------------------ | Branch (2704:3): [True: 21, False: 203k] ------------------ 2705| 950| decoder->private_->frame.header.blocksize = 256 << (x-8); 2706| 950| break; 2707| 0| default: ------------------ | Branch (2707:3): [True: 0, False: 203k] ------------------ 2708| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 2709| 0| break; 2710| 203k| } 2711| | 2712| 203k| switch(x = raw_header[2] & 0x0f) { 2713| 16.0k| case 0: ------------------ | Branch (2713:3): [True: 16.0k, False: 187k] ------------------ 2714| 16.0k| if(decoder->private_->has_stream_info) ------------------ | Branch (2714:7): [True: 16.0k, False: 0] ------------------ 2715| 16.0k| decoder->private_->frame.header.sample_rate = decoder->private_->stream_info.data.stream_info.sample_rate; 2716| 0| else 2717| 0| is_unparseable = true; 2718| 16.0k| break; 2719| 413| case 1: ------------------ | Branch (2719:3): [True: 413, False: 203k] ------------------ 2720| 413| decoder->private_->frame.header.sample_rate = 88200; 2721| 413| break; 2722| 637| case 2: ------------------ | Branch (2722:3): [True: 637, False: 202k] ------------------ 2723| 637| decoder->private_->frame.header.sample_rate = 176400; 2724| 637| break; 2725| 1.39k| case 3: ------------------ | Branch (2725:3): [True: 1.39k, False: 202k] ------------------ 2726| 1.39k| decoder->private_->frame.header.sample_rate = 192000; 2727| 1.39k| break; 2728| 1.37k| case 4: ------------------ | Branch (2728:3): [True: 1.37k, False: 202k] ------------------ 2729| 1.37k| decoder->private_->frame.header.sample_rate = 8000; 2730| 1.37k| break; 2731| 88| case 5: ------------------ | Branch (2731:3): [True: 88, False: 203k] ------------------ 2732| 88| decoder->private_->frame.header.sample_rate = 16000; 2733| 88| break; 2734| 1.05k| case 6: ------------------ | Branch (2734:3): [True: 1.05k, False: 202k] ------------------ 2735| 1.05k| decoder->private_->frame.header.sample_rate = 22050; 2736| 1.05k| break; 2737| 221| case 7: ------------------ | Branch (2737:3): [True: 221, False: 203k] ------------------ 2738| 221| decoder->private_->frame.header.sample_rate = 24000; 2739| 221| break; 2740| 2.52k| case 8: ------------------ | Branch (2740:3): [True: 2.52k, False: 201k] ------------------ 2741| 2.52k| decoder->private_->frame.header.sample_rate = 32000; 2742| 2.52k| break; 2743| 40.2k| case 9: ------------------ | Branch (2743:3): [True: 40.2k, False: 163k] ------------------ 2744| 40.2k| decoder->private_->frame.header.sample_rate = 44100; 2745| 40.2k| break; 2746| 420| case 10: ------------------ | Branch (2746:3): [True: 420, False: 203k] ------------------ 2747| 420| decoder->private_->frame.header.sample_rate = 48000; 2748| 420| break; 2749| 5.77k| case 11: ------------------ | Branch (2749:3): [True: 5.77k, False: 197k] ------------------ 2750| 5.77k| decoder->private_->frame.header.sample_rate = 96000; 2751| 5.77k| break; 2752| 11.1k| case 12: ------------------ | Branch (2752:3): [True: 11.1k, False: 192k] ------------------ 2753| 88.1k| case 13: ------------------ | Branch (2753:3): [True: 76.9k, False: 126k] ------------------ 2754| 133k| case 14: ------------------ | Branch (2754:3): [True: 45.1k, False: 158k] ------------------ 2755| 133k| sample_rate_hint = x; 2756| 133k| break; 2757| 0| case 15: ------------------ | Branch (2757:3): [True: 0, False: 203k] ------------------ 2758| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER); 2759| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2760| 0| return true; 2761| 0| default: ------------------ | Branch (2761:3): [True: 0, False: 203k] ------------------ 2762| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 2763| 203k| } 2764| | 2765| 203k| x = (uint32_t)(raw_header[3] >> 4); 2766| 203k| if(x & 8) { ------------------ | Branch (2766:5): [True: 35.8k, False: 167k] ------------------ 2767| 35.8k| decoder->private_->frame.header.channels = 2; 2768| 35.8k| switch(x & 7) { 2769| 17.2k| case 0: ------------------ | Branch (2769:4): [True: 17.2k, False: 18.6k] ------------------ 2770| 17.2k| decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE; 2771| 17.2k| break; 2772| 7.62k| case 1: ------------------ | Branch (2772:4): [True: 7.62k, False: 28.1k] ------------------ 2773| 7.62k| decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE; 2774| 7.62k| break; 2775| 10.9k| case 2: ------------------ | Branch (2775:4): [True: 10.9k, False: 24.8k] ------------------ 2776| 10.9k| decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE; 2777| 10.9k| break; 2778| 0| default: ------------------ | Branch (2778:4): [True: 0, False: 35.8k] ------------------ 2779| 0| is_unparseable = true; 2780| 0| break; 2781| 35.8k| } 2782| 35.8k| } 2783| 167k| else { 2784| 167k| decoder->private_->frame.header.channels = (uint32_t)x + 1; 2785| 167k| decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; 2786| 167k| } 2787| | 2788| 203k| switch(x = (uint32_t)(raw_header[3] & 0x0e) >> 1) { 2789| 4.40k| case 0: ------------------ | Branch (2789:3): [True: 4.40k, False: 199k] ------------------ 2790| 4.40k| if(decoder->private_->has_stream_info) ------------------ | Branch (2790:7): [True: 4.40k, False: 0] ------------------ 2791| 4.40k| decoder->private_->frame.header.bits_per_sample = decoder->private_->stream_info.data.stream_info.bits_per_sample; 2792| 0| else 2793| 0| is_unparseable = true; 2794| 4.40k| break; 2795| 3.01k| case 1: ------------------ | Branch (2795:3): [True: 3.01k, False: 200k] ------------------ 2796| 3.01k| decoder->private_->frame.header.bits_per_sample = 8; 2797| 3.01k| break; 2798| 249| case 2: ------------------ | Branch (2798:3): [True: 249, False: 203k] ------------------ 2799| 249| decoder->private_->frame.header.bits_per_sample = 12; 2800| 249| break; 2801| 0| case 3: ------------------ | Branch (2801:3): [True: 0, False: 203k] ------------------ 2802| 0| is_unparseable = true; 2803| 0| break; 2804| 5.70k| case 4: ------------------ | Branch (2804:3): [True: 5.70k, False: 197k] ------------------ 2805| 5.70k| decoder->private_->frame.header.bits_per_sample = 16; 2806| 5.70k| break; 2807| 410| case 5: ------------------ | Branch (2807:3): [True: 410, False: 203k] ------------------ 2808| 410| decoder->private_->frame.header.bits_per_sample = 20; 2809| 410| break; 2810| 10.8k| case 6: ------------------ | Branch (2810:3): [True: 10.8k, False: 192k] ------------------ 2811| 10.8k| decoder->private_->frame.header.bits_per_sample = 24; 2812| 10.8k| break; 2813| 178k| case 7: ------------------ | Branch (2813:3): [True: 178k, False: 24.6k] ------------------ 2814| 178k| decoder->private_->frame.header.bits_per_sample = 32; 2815| 178k| break; 2816| 0| default: ------------------ | Branch (2816:3): [True: 0, False: 203k] ------------------ 2817| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 2818| 0| break; 2819| 203k| } 2820| | 2821| |#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2822| | /* check to make sure that reserved bit is 0 */ 2823| | if(raw_header[3] & 0x01) /* MAGIC NUMBER */ 2824| | is_unparseable = true; 2825| |#endif 2826| | 2827| | /* read the frame's starting sample number (or frame number as the case may be) */ 2828| 203k| if( 2829| 203k| raw_header[1] & 0x01 || ------------------ | Branch (2829:3): [True: 0, False: 203k] ------------------ 2830| | /*@@@ this clause is a concession to the old way of doing variable blocksize; the only known implementation is flake and can probably be removed without inconveniencing anyone */ 2831| 203k| (decoder->private_->has_stream_info && decoder->private_->stream_info.data.stream_info.min_blocksize != decoder->private_->stream_info.data.stream_info.max_blocksize) ------------------ | Branch (2831:4): [True: 203k, False: 0] | Branch (2831:42): [True: 0, False: 203k] ------------------ 2832| 203k| ) { /* variable blocksize */ 2833| 0| if(!FLAC__bitreader_read_utf8_uint64(decoder->private_->input, &xx, raw_header, &raw_header_len)) ------------------ | Branch (2833:6): [True: 0, False: 0] ------------------ 2834| 0| return false; /* read_callback_ sets the state for us */ 2835| 0| if(xx == FLAC__U64L(0xffffffffffffffff)) { /* i.e. non-UTF8 code... */ ------------------ | | 102| 0|#define FLAC__U64L(x) x##ULL ------------------ | Branch (2835:6): [True: 0, False: 0] ------------------ 2836| 0| decoder->private_->lookahead = raw_header[raw_header_len-1]; /* back up as much as we can */ 2837| 0| decoder->private_->cached = true; 2838| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER); 2839| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2840| 0| return true; 2841| 0| } 2842| 0| decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER; 2843| 0| decoder->private_->frame.header.number.sample_number = xx; 2844| 0| } 2845| 203k| else { /* fixed blocksize */ 2846| 203k| if(!FLAC__bitreader_read_utf8_uint32(decoder->private_->input, &x, raw_header, &raw_header_len)) ------------------ | Branch (2846:6): [True: 0, False: 203k] ------------------ 2847| 0| return false; /* read_callback_ sets the state for us */ 2848| 203k| if(x == 0xffffffff) { /* i.e. non-UTF8 code... */ ------------------ | Branch (2848:6): [True: 0, False: 203k] ------------------ 2849| 0| decoder->private_->lookahead = raw_header[raw_header_len-1]; /* back up as much as we can */ 2850| 0| decoder->private_->cached = true; 2851| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER); 2852| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2853| 0| return true; 2854| 0| } 2855| 203k| decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER; 2856| 203k| decoder->private_->frame.header.number.frame_number = x; 2857| 203k| } 2858| | 2859| 203k| if(blocksize_hint) { ------------------ | Branch (2859:5): [True: 201k, False: 1.58k] ------------------ 2860| 201k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2860:6): [True: 0, False: 201k] ------------------ 2861| 0| return false; /* read_callback_ sets the state for us */ 2862| 201k| raw_header[raw_header_len++] = (FLAC__byte)x; 2863| 201k| if(blocksize_hint == 7) { ------------------ | Branch (2863:6): [True: 1.84k, False: 200k] ------------------ 2864| 1.84k| FLAC__uint32 _x; 2865| 1.84k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &_x, 8)) ------------------ | Branch (2865:7): [True: 0, False: 1.84k] ------------------ 2866| 0| return false; /* read_callback_ sets the state for us */ 2867| 1.84k| raw_header[raw_header_len++] = (FLAC__byte)_x; 2868| 1.84k| x = (x << 8) | _x; 2869| 1.84k| } 2870| 201k| decoder->private_->frame.header.blocksize = x+1; 2871| 201k| if(decoder->private_->frame.header.blocksize > 65535) { /* invalid blocksize (65536) specified */ ------------------ | Branch (2871:6): [True: 0, False: 201k] ------------------ 2872| 0| decoder->private_->lookahead = raw_header[raw_header_len-1]; /* back up as much as we can */ 2873| 0| decoder->private_->cached = true; 2874| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER); 2875| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2876| 0| return true; 2877| 0| } 2878| | 2879| 201k| } 2880| | 2881| 203k| if(sample_rate_hint) { ------------------ | Branch (2881:5): [True: 133k, False: 70.2k] ------------------ 2882| 133k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2882:6): [True: 0, False: 133k] ------------------ 2883| 0| return false; /* read_callback_ sets the state for us */ 2884| 133k| raw_header[raw_header_len++] = (FLAC__byte)x; 2885| 133k| if(sample_rate_hint != 12) { ------------------ | Branch (2885:6): [True: 122k, False: 11.1k] ------------------ 2886| 122k| FLAC__uint32 _x; 2887| 122k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &_x, 8)) ------------------ | Branch (2887:7): [True: 0, False: 122k] ------------------ 2888| 0| return false; /* read_callback_ sets the state for us */ 2889| 122k| raw_header[raw_header_len++] = (FLAC__byte)_x; 2890| 122k| x = (x << 8) | _x; 2891| 122k| } 2892| 133k| if(sample_rate_hint == 12) ------------------ | Branch (2892:6): [True: 11.1k, False: 122k] ------------------ 2893| 11.1k| decoder->private_->frame.header.sample_rate = x*1000; 2894| 122k| else if(sample_rate_hint == 13) ------------------ | Branch (2894:11): [True: 76.9k, False: 45.1k] ------------------ 2895| 76.9k| decoder->private_->frame.header.sample_rate = x; 2896| 45.1k| else 2897| 45.1k| decoder->private_->frame.header.sample_rate = x*10; 2898| 133k| } 2899| | 2900| | /* read the CRC-8 byte */ 2901| 203k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2901:5): [True: 0, False: 203k] ------------------ 2902| 0| return false; /* read_callback_ sets the state for us */ 2903| 203k| crc8 = (FLAC__byte)x; 2904| | 2905| |#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2906| | if(FLAC__crc8(raw_header, raw_header_len) != crc8) { 2907| |#else 2908| 203k| if(decoder->private_->fuzzing_rewind_count > 8 && (FLAC__crc8(raw_header, raw_header_len) << 4) != (crc8 << 4)) { ------------------ | Branch (2908:5): [True: 0, False: 203k] | Branch (2908:52): [True: 0, False: 0] ------------------ 2909| 0|#endif 2910| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER); 2911| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2912| 0| return true; 2913| 0| } 2914| | 2915| | /* calculate the sample number from the frame number if needed */ 2916| 203k| decoder->private_->next_fixed_block_size = 0; 2917| 203k| if(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) { ------------------ | Branch (2917:5): [True: 203k, False: 0] ------------------ 2918| 203k| x = decoder->private_->frame.header.number.frame_number; 2919| 203k| decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER; 2920| 203k| if(decoder->private_->fixed_block_size) ------------------ | Branch (2920:6): [True: 195k, False: 7.71k] ------------------ 2921| 195k| decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->fixed_block_size * (FLAC__uint64)x; 2922| 7.71k| else if(decoder->private_->has_stream_info) { ------------------ | Branch (2922:11): [True: 7.71k, False: 0] ------------------ 2923| 7.71k| if(decoder->private_->stream_info.data.stream_info.min_blocksize == decoder->private_->stream_info.data.stream_info.max_blocksize) { ------------------ | Branch (2923:7): [True: 7.71k, False: 0] ------------------ 2924| 7.71k| decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->stream_info.data.stream_info.min_blocksize * (FLAC__uint64)x; 2925| 7.71k| decoder->private_->next_fixed_block_size = decoder->private_->stream_info.data.stream_info.max_blocksize; 2926| 7.71k| } 2927| 0| else 2928| 0| is_unparseable = true; 2929| 7.71k| } 2930| 0| else if(x == 0) { ------------------ | Branch (2930:11): [True: 0, False: 0] ------------------ 2931| 0| decoder->private_->frame.header.number.sample_number = 0; 2932| 0| decoder->private_->next_fixed_block_size = decoder->private_->frame.header.blocksize; 2933| 0| } 2934| 0| else { 2935| | /* can only get here if the stream has invalid frame numbering and no STREAMINFO, so assume it's not the last (possibly short) frame */ 2936| 0| decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->frame.header.blocksize * (FLAC__uint64)x; 2937| 0| } 2938| 203k| } 2939| | 2940| 203k| if(is_unparseable) { ------------------ | Branch (2940:5): [True: 0, False: 203k] ------------------ 2941| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM); 2942| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2943| 0| return true; 2944| 0| } 2945| | 2946| 203k| return true; 2947| 203k|} stream_decoder.c:allocate_output_: 1574| 203k|{ 1575| 203k| uint32_t i; 1576| 203k| FLAC__int32 *tmp; 1577| | 1578| 203k| if(size <= decoder->private_->output_capacity && channels <= decoder->private_->output_channels && ------------------ | Branch (1578:5): [True: 195k, False: 7.71k] | Branch (1578:51): [True: 195k, False: 0] ------------------ 1579| 195k| (bps < 32 || decoder->private_->side_subframe != 0)) ------------------ | Branch (1579:6): [True: 22.0k, False: 173k] | Branch (1579:18): [True: 173k, False: 0] ------------------ 1580| 195k| return true; 1581| | 1582| | /* simply using realloc() is not practical because the number of channels may change mid-stream */ 1583| | 1584| 69.4k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 69.4k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1584:13): [True: 61.6k, False: 7.71k] ------------------ 1585| 61.6k| if(0 != decoder->private_->output[i]) { ------------------ | Branch (1585:6): [True: 0, False: 61.6k] ------------------ 1586| 0| free(decoder->private_->output[i]-4); 1587| 0| decoder->private_->output[i] = 0; 1588| 0| } 1589| 61.6k| if(0 != decoder->private_->residual_unaligned[i]) { ------------------ | Branch (1589:6): [True: 0, False: 61.6k] ------------------ 1590| 0| free(decoder->private_->residual_unaligned[i]); 1591| 0| decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0; 1592| 0| } 1593| 61.6k| } 1594| | 1595| 7.71k| if(0 != decoder->private_->side_subframe) { ------------------ | Branch (1595:5): [True: 0, False: 7.71k] ------------------ 1596| 0| free(decoder->private_->side_subframe); 1597| 0| decoder->private_->side_subframe = 0; 1598| 0| } 1599| | 1600| | /* Only grow per-channel buffers, even if number of channels increases */ 1601| 7.71k| if(decoder->private_->output_capacity > size) { ------------------ | Branch (1601:5): [True: 0, False: 7.71k] ------------------ 1602| 0| size = decoder->private_->output_capacity; 1603| 0| } 1604| | 1605| 21.1k| for(i = 0; i < channels; i++) { ------------------ | Branch (1605:13): [True: 13.3k, False: 7.71k] ------------------ 1606| | /* WATCHOUT: 1607| | * FLAC__lpc_restore_signal_asm_ia32_mmx() and ..._intrin_sseN() 1608| | * require that the output arrays have a buffer of up to 3 zeroes 1609| | * in front (at negative indices) for alignment purposes; 1610| | * we use 4 to keep the data well-aligned. 1611| | */ 1612| 13.3k| tmp = safe_malloc_muladd2_(sizeof(FLAC__int32), /*times (*/size, /*+*/4/*)*/); 1613| 13.3k| if(tmp == 0) { ------------------ | Branch (1613:6): [True: 0, False: 13.3k] ------------------ 1614| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1615| 0| return false; 1616| 0| } 1617| 13.3k| memset(tmp, 0, sizeof(FLAC__int32)*4); 1618| 13.3k| decoder->private_->output[i] = tmp + 4; 1619| | 1620| 13.3k| if(!FLAC__memory_alloc_aligned_int32_array(size, &decoder->private_->residual_unaligned[i], &decoder->private_->residual[i])) { ------------------ | Branch (1620:6): [True: 0, False: 13.3k] ------------------ 1621| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1622| 0| return false; 1623| 0| } 1624| 13.3k| } 1625| | 1626| 7.71k| if(bps == 32) { ------------------ | Branch (1626:5): [True: 5.06k, False: 2.64k] ------------------ 1627| 5.06k| decoder->private_->side_subframe = safe_malloc_mul_2op_p(sizeof(FLAC__int64), /*times (*/size); 1628| 5.06k| if(decoder->private_->side_subframe == NULL) { ------------------ | Branch (1628:6): [True: 0, False: 5.06k] ------------------ 1629| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1630| 0| return false; 1631| 0| } 1632| 5.06k| } 1633| | 1634| 7.71k| decoder->private_->output_capacity = size; 1635| 7.71k| decoder->private_->output_channels = channels; 1636| | 1637| | return true; 1638| 7.71k|} stream_decoder.c:read_subframe_: 2950| 270k|{ 2951| 270k| FLAC__uint32 x; 2952| 270k| FLAC__bool wasted_bits; 2953| 270k| uint32_t i; 2954| | 2955| 270k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) /* MAGIC NUMBER */ ------------------ | Branch (2955:5): [True: 0, False: 270k] ------------------ 2956| 0| return false; /* read_callback_ sets the state for us */ 2957| | 2958| 270k| wasted_bits = (x & 1); 2959| 270k| x &= 0xfe; 2960| | 2961| 270k| if(wasted_bits) { ------------------ | Branch (2961:5): [True: 31.7k, False: 238k] ------------------ 2962| 31.7k| uint32_t u; 2963| 31.7k| if(!FLAC__bitreader_read_unary_unsigned(decoder->private_->input, &u)) ------------------ | Branch (2963:6): [True: 0, False: 31.7k] ------------------ 2964| 0| return false; /* read_callback_ sets the state for us */ 2965| 31.7k| decoder->private_->frame.subframes[channel].wasted_bits = u+1; 2966| 31.7k| if (decoder->private_->frame.subframes[channel].wasted_bits >= bps) { ------------------ | Branch (2966:7): [True: 0, False: 31.7k] ------------------ 2967| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 2968| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2969| 0| return true; 2970| 0| } 2971| 31.7k| bps -= decoder->private_->frame.subframes[channel].wasted_bits; 2972| 31.7k| } 2973| 238k| else 2974| 238k| decoder->private_->frame.subframes[channel].wasted_bits = 0; 2975| | 2976| | /* 2977| | * Lots of magic numbers here 2978| | */ 2979| 270k| if(x & 0x80) { ------------------ | Branch (2979:5): [True: 0, False: 270k] ------------------ 2980| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 2981| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2982| 0| return true; 2983| 0| } 2984| 270k| else if(x == 0) { ------------------ | Branch (2984:10): [True: 89.2k, False: 181k] ------------------ 2985| 89.2k| if(!read_subframe_constant_(decoder, channel, bps, do_full_decode)) ------------------ | Branch (2985:6): [True: 0, False: 89.2k] ------------------ 2986| 0| return false; 2987| 89.2k| } 2988| 181k| else if(x == 2) { ------------------ | Branch (2988:10): [True: 37.3k, False: 143k] ------------------ 2989| 37.3k| if(!read_subframe_verbatim_(decoder, channel, bps, do_full_decode)) ------------------ | Branch (2989:6): [True: 0, False: 37.3k] ------------------ 2990| 0| return false; 2991| 37.3k| } 2992| 143k| else if(x < 16) { ------------------ | Branch (2992:10): [True: 0, False: 143k] ------------------ 2993| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM); 2994| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2995| 0| return true; 2996| 0| } 2997| 143k| else if(x <= 24) { ------------------ | Branch (2997:10): [True: 124k, False: 18.9k] ------------------ 2998| 124k| uint32_t predictor_order = (x>>1)&7; 2999| 124k| if(decoder->private_->frame.header.blocksize <= predictor_order){ ------------------ | Branch (2999:6): [True: 0, False: 124k] ------------------ 3000| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3001| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3002| 0| return true; 3003| 0| } 3004| 124k| if(!read_subframe_fixed_(decoder, channel, bps, predictor_order, do_full_decode)) ------------------ | Branch (3004:6): [True: 0, False: 124k] ------------------ 3005| 0| return false; 3006| 124k| if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */ ------------------ | Branch (3006:6): [True: 0, False: 124k] ------------------ 3007| 0| return true; 3008| 124k| } 3009| 18.9k| else if(x < 64) { ------------------ | Branch (3009:10): [True: 0, False: 18.9k] ------------------ 3010| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM); 3011| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3012| 0| return true; 3013| 0| } 3014| 18.9k| else { 3015| 18.9k| uint32_t predictor_order = ((x>>1)&31)+1; 3016| 18.9k| if(decoder->private_->frame.header.blocksize <= predictor_order){ ------------------ | Branch (3016:6): [True: 0, False: 18.9k] ------------------ 3017| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3018| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3019| 0| return true; 3020| 0| } 3021| 18.9k| if(!read_subframe_lpc_(decoder, channel, bps, predictor_order, do_full_decode)) ------------------ | Branch (3021:6): [True: 0, False: 18.9k] ------------------ 3022| 0| return false; 3023| 18.9k| if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */ ------------------ | Branch (3023:6): [True: 0, False: 18.9k] ------------------ 3024| 0| return true; 3025| 18.9k| } 3026| | 3027| 270k| if(wasted_bits && do_full_decode) { ------------------ | Branch (3027:5): [True: 31.7k, False: 238k] | Branch (3027:20): [True: 31.7k, False: 0] ------------------ 3028| 31.7k| x = decoder->private_->frame.subframes[channel].wasted_bits; 3029| 31.7k| if((bps + x) < 33) { ------------------ | Branch (3029:6): [True: 15.8k, False: 15.8k] ------------------ 3030| 327k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3030:15): [True: 312k, False: 15.8k] ------------------ 3031| 312k| uint32_t val = decoder->private_->output[channel][i]; 3032| 312k| decoder->private_->output[channel][i] = (val << x); 3033| 312k| } 3034| 15.8k| } 3035| 15.8k| else { 3036| | /* When there are wasted bits, bps is never 33 and so 3037| | * side_subframe is never already in use */ 3038| 15.8k| FLAC__ASSERT(!decoder->private_->side_subframe_in_use); ------------------ | | 38| 15.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 15.8k] | | ------------------ ------------------ 3039| 15.8k| decoder->private_->side_subframe_in_use = true; 3040| 432k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3040:15): [True: 416k, False: 15.8k] ------------------ 3041| 416k| uint64_t val = decoder->private_->output[channel][i]; 3042| 416k| decoder->private_->side_subframe[i] = (val << x); 3043| 416k| } 3044| 15.8k| } 3045| 31.7k| } 3046| | 3047| 270k| return true; 3048| 270k|} stream_decoder.c:read_subframe_constant_: 3051| 89.2k|{ 3052| 89.2k| FLAC__Subframe_Constant *subframe = &decoder->private_->frame.subframes[channel].data.constant; 3053| 89.2k| FLAC__int64 x; 3054| 89.2k| uint32_t i; 3055| | 3056| 89.2k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_CONSTANT; 3057| | 3058| 89.2k| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &x, bps)) ------------------ | Branch (3058:5): [True: 0, False: 89.2k] ------------------ 3059| 0| return false; /* read_callback_ sets the state for us */ 3060| | 3061| 89.2k| subframe->value = x; 3062| | 3063| | /* decode the subframe */ 3064| 89.2k| if(do_full_decode) { ------------------ | Branch (3064:5): [True: 89.2k, False: 0] ------------------ 3065| 89.2k| if(bps <= 32) { ------------------ | Branch (3065:6): [True: 88.3k, False: 890] ------------------ 3066| 88.3k| FLAC__int32 *output = decoder->private_->output[channel]; 3067| 1.65M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) ------------------ | Branch (3067:15): [True: 1.56M, False: 88.3k] ------------------ 3068| 1.56M| output[i] = x; 3069| 88.3k| } else { 3070| 890| FLAC__int64 *output = decoder->private_->side_subframe; 3071| 890| decoder->private_->side_subframe_in_use = true; 3072| 16.0k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) ------------------ | Branch (3072:15): [True: 15.1k, False: 890] ------------------ 3073| 15.1k| output[i] = x; 3074| 890| } 3075| 89.2k| } 3076| | 3077| | return true; 3078| 89.2k|} stream_decoder.c:read_subframe_verbatim_: 3260| 37.3k|{ 3261| 37.3k| FLAC__Subframe_Verbatim *subframe = &decoder->private_->frame.subframes[channel].data.verbatim; 3262| 37.3k| uint32_t i; 3263| | 3264| 37.3k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_VERBATIM; 3265| | 3266| 37.3k| if(bps < 33) { ------------------ | Branch (3266:5): [True: 36.5k, False: 733] ------------------ 3267| 36.5k| FLAC__int32 x, *residual = decoder->private_->residual[channel]; 3268| | 3269| 36.5k| subframe->data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32; 3270| 36.5k| subframe->data.int32 = residual; 3271| | 3272| 2.70M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3272:14): [True: 2.66M, False: 36.5k] ------------------ 3273| 2.66M| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &x, bps)) ------------------ | Branch (3273:7): [True: 0, False: 2.66M] ------------------ 3274| 0| return false; /* read_callback_ sets the state for us */ 3275| 2.66M| residual[i] = x; 3276| 2.66M| } 3277| | 3278| | /* decode the subframe */ 3279| 36.5k| if(do_full_decode) ------------------ | Branch (3279:6): [True: 36.5k, False: 0] ------------------ 3280| 36.5k| memcpy(decoder->private_->output[channel], subframe->data.int32, sizeof(FLAC__int32) * decoder->private_->frame.header.blocksize); 3281| 36.5k| } 3282| 733| else { 3283| 733| FLAC__int64 x, *side = decoder->private_->side_subframe; 3284| | 3285| 733| subframe->data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64; 3286| 733| subframe->data.int64 = side; 3287| 733| decoder->private_->side_subframe_in_use = true; 3288| | 3289| 1.62M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3289:14): [True: 1.62M, False: 733] ------------------ 3290| 1.62M| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &x, bps)) ------------------ | Branch (3290:7): [True: 0, False: 1.62M] ------------------ 3291| 0| return false; /* read_callback_ sets the state for us */ 3292| 1.62M| side[i] = x; 3293| 1.62M| } 3294| 733| } 3295| | 3296| 37.3k| return true; 3297| 37.3k|} stream_decoder.c:read_subframe_fixed_: 3081| 124k|{ 3082| 124k| FLAC__Subframe_Fixed *subframe = &decoder->private_->frame.subframes[channel].data.fixed; 3083| 124k| FLAC__int64 i64; 3084| 124k| FLAC__uint32 u32; 3085| 124k| uint32_t u; 3086| | 3087| 124k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_FIXED; 3088| | 3089| 124k| subframe->residual = decoder->private_->residual[channel]; 3090| 124k| subframe->order = order; 3091| | 3092| | /* read warm-up samples */ 3093| 211k| for(u = 0; u < order; u++) { ------------------ | Branch (3093:13): [True: 86.0k, False: 124k] ------------------ 3094| 86.0k| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &i64, bps)) ------------------ | Branch (3094:6): [True: 0, False: 86.0k] ------------------ 3095| 0| return false; /* read_callback_ sets the state for us */ 3096| 86.0k| subframe->warmup[u] = i64; 3097| 86.0k| } 3098| | 3099| | /* read entropy coding method info */ 3100| 124k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN)) ------------------ | Branch (3100:5): [True: 0, False: 124k] ------------------ 3101| 0| return false; /* read_callback_ sets the state for us */ 3102| 124k| subframe->entropy_coding_method.type = (FLAC__EntropyCodingMethodType)u32; 3103| 124k| switch(subframe->entropy_coding_method.type) { 3104| 48.2k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3104:3): [True: 48.2k, False: 76.7k] ------------------ 3105| 124k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3105:3): [True: 76.7k, False: 48.2k] ------------------ 3106| 124k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) ------------------ | Branch (3106:7): [True: 0, False: 124k] ------------------ 3107| 0| return false; /* read_callback_ sets the state for us */ 3108| 124k| if((decoder->private_->frame.header.blocksize >> u32 < order) || ------------------ | Branch (3108:7): [True: 0, False: 124k] ------------------ 3109| 124k| (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) { ------------------ | Branch (3109:7): [True: 0, False: 124k] ------------------ 3110| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3111| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3112| 0| return true; 3113| 0| } 3114| 124k| subframe->entropy_coding_method.data.partitioned_rice.order = u32; 3115| 124k| subframe->entropy_coding_method.data.partitioned_rice.contents = &decoder->private_->partitioned_rice_contents[channel]; 3116| 124k| break; 3117| 0| default: ------------------ | Branch (3117:3): [True: 0, False: 124k] ------------------ 3118| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM); 3119| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3120| 0| return true; 3121| 124k| } 3122| | 3123| | /* read residual */ 3124| 124k| switch(subframe->entropy_coding_method.type) { 3125| 48.2k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3125:3): [True: 48.2k, False: 76.7k] ------------------ 3126| 124k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3126:3): [True: 76.7k, False: 48.2k] ------------------ 3127| 124k| if(!read_residual_partitioned_rice_(decoder, order, subframe->entropy_coding_method.data.partitioned_rice.order, &decoder->private_->partitioned_rice_contents[channel], decoder->private_->residual[channel], /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2)) ------------------ | Branch (3127:7): [True: 0, False: 124k] ------------------ 3128| 0| return false; 3129| 124k| break; 3130| 124k| default: ------------------ | Branch (3130:3): [True: 0, False: 124k] ------------------ 3131| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 3132| 124k| } 3133| | 3134| | /* decode the subframe */ 3135| 124k| if(do_full_decode) { ------------------ | Branch (3135:5): [True: 124k, False: 0] ------------------ 3136| 124k| if(bps < 33){ ------------------ | Branch (3136:6): [True: 120k, False: 4.96k] ------------------ 3137| 120k| uint32_t i; 3138| 203k| for(i = 0; i < order; i++) ------------------ | Branch (3138:15): [True: 83.1k, False: 120k] ------------------ 3139| 83.1k| decoder->private_->output[channel][i] = subframe->warmup[i]; 3140| 120k| if(bps+order <= 32) ------------------ | Branch (3140:7): [True: 71.6k, False: 48.3k] ------------------ 3141| 71.6k| FLAC__fixed_restore_signal(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->output[channel]+order); 3142| 48.3k| else 3143| 48.3k| FLAC__fixed_restore_signal_wide(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->output[channel]+order); 3144| 120k| } 3145| 4.96k| else { 3146| 4.96k| decoder->private_->side_subframe_in_use = true; 3147| 4.96k| memcpy(decoder->private_->side_subframe, subframe->warmup, sizeof(FLAC__int64) * order); 3148| 4.96k| FLAC__fixed_restore_signal_wide_33bit(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->side_subframe+order); 3149| 4.96k| } 3150| 124k| } 3151| | 3152| | return true; 3153| 124k|} stream_decoder.c:read_residual_partitioned_rice_: 3300| 143k|{ 3301| 143k| FLAC__uint32 rice_parameter; 3302| 143k| int i; 3303| 143k| uint32_t partition, sample, u; 3304| 143k| const uint32_t partitions = 1u << partition_order; 3305| 143k| const uint32_t partition_samples = decoder->private_->frame.header.blocksize >> partition_order; 3306| 143k| const uint32_t plen = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; ------------------ | Branch (3306:24): [True: 82.4k, False: 61.4k] ------------------ 3307| 143k| const uint32_t pesc = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; ------------------ | Branch (3307:24): [True: 82.4k, False: 61.4k] ------------------ 3308| | 3309| | /* invalid predictor and partition orders mush be handled in the callers */ 3310| 143k| FLAC__ASSERT(partition_order > 0? partition_samples >= predictor_order : decoder->private_->frame.header.blocksize >= predictor_order); ------------------ | | 38| 287k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 143k] | | | Branch (38:30): [True: 57.2k, False: 86.6k] | | ------------------ ------------------ 3311| | 3312| 143k| if(!FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents, flac_max(6u, partition_order))) { ------------------ | | 55| 143k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (3312:5): [True: 0, False: 143k] | Branch (3312:106): [True: 142k, False: 1.10k] ------------------ 3313| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 3314| 0| return false; 3315| 0| } 3316| | 3317| 143k| sample = 0; 3318| 1.56M| for(partition = 0; partition < partitions; partition++) { ------------------ | Branch (3318:21): [True: 1.42M, False: 143k] ------------------ 3319| 1.42M| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &rice_parameter, plen)) ------------------ | Branch (3319:6): [True: 0, False: 1.42M] ------------------ 3320| 0| return false; /* read_callback_ sets the state for us */ 3321| 1.42M| partitioned_rice_contents->parameters[partition] = rice_parameter; 3322| 1.42M| if(rice_parameter < pesc) { ------------------ | Branch (3322:6): [True: 1.39M, False: 31.3k] ------------------ 3323| 1.39M| partitioned_rice_contents->raw_bits[partition] = 0; 3324| 1.39M| u = (partition == 0) ? partition_samples - predictor_order : partition_samples; ------------------ | Branch (3324:8): [True: 134k, False: 1.25M] ------------------ 3325| 1.39M| if(!decoder->private_->local_bitreader_read_rice_signed_block(decoder->private_->input, residual + sample, u, rice_parameter)){ ------------------ | Branch (3325:7): [True: 0, False: 1.39M] ------------------ 3326| 0| if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) { ------------------ | Branch (3326:8): [True: 0, False: 0] ------------------ 3327| | /* no error was set, read_callback_ didn't set it, so 3328| | * invalid rice symbol was found */ 3329| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3330| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3331| 0| return true; 3332| 0| } 3333| 0| else 3334| 0| return false; /* read_callback_ sets the state for us */ 3335| 0| } 3336| 1.39M| sample += u; 3337| 1.39M| } 3338| 31.3k| else { 3339| 31.3k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN)) ------------------ | Branch (3339:7): [True: 0, False: 31.3k] ------------------ 3340| 0| return false; /* read_callback_ sets the state for us */ 3341| 31.3k| partitioned_rice_contents->raw_bits[partition] = rice_parameter; 3342| 31.3k| if(rice_parameter == 0) { ------------------ | Branch (3342:7): [True: 0, False: 31.3k] ------------------ 3343| 0| for(u = (partition == 0)? predictor_order : 0; u < partition_samples; u++, sample++) ------------------ | Branch (3343:13): [True: 0, False: 0] | Branch (3343:52): [True: 0, False: 0] ------------------ 3344| 0| residual[sample] = 0; 3345| 0| } 3346| 31.3k| else{ 3347| 707k| for(u = (partition == 0)? predictor_order : 0; u < partition_samples; u++, sample++) { ------------------ | Branch (3347:13): [True: 9.27k, False: 22.0k] | Branch (3347:52): [True: 676k, False: 31.3k] ------------------ 3348| 676k| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i, rice_parameter)) ------------------ | Branch (3348:9): [True: 0, False: 676k] ------------------ 3349| 0| return false; /* read_callback_ sets the state for us */ 3350| 676k| residual[sample] = i; 3351| 676k| } 3352| 31.3k| } 3353| 31.3k| } 3354| 1.42M| } 3355| | 3356| 143k| return true; 3357| 143k|} stream_decoder.c:read_subframe_lpc_: 3156| 18.9k|{ 3157| 18.9k| FLAC__Subframe_LPC *subframe = &decoder->private_->frame.subframes[channel].data.lpc; 3158| 18.9k| FLAC__int32 i32; 3159| 18.9k| FLAC__int64 i64; 3160| 18.9k| FLAC__uint32 u32; 3161| 18.9k| uint32_t u; 3162| | 3163| 18.9k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_LPC; 3164| | 3165| 18.9k| subframe->residual = decoder->private_->residual[channel]; 3166| 18.9k| subframe->order = order; 3167| | 3168| | /* read warm-up samples */ 3169| 124k| for(u = 0; u < order; u++) { ------------------ | Branch (3169:13): [True: 105k, False: 18.9k] ------------------ 3170| 105k| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &i64, bps)) ------------------ | Branch (3170:6): [True: 0, False: 105k] ------------------ 3171| 0| return false; /* read_callback_ sets the state for us */ 3172| 105k| subframe->warmup[u] = i64; 3173| 105k| } 3174| | 3175| | /* read qlp coeff precision */ 3176| 18.9k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN)) ------------------ | Branch (3176:5): [True: 0, False: 18.9k] ------------------ 3177| 0| return false; /* read_callback_ sets the state for us */ 3178| 18.9k| if(u32 == (1u << FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN) - 1) { ------------------ | Branch (3178:5): [True: 0, False: 18.9k] ------------------ 3179| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3180| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3181| 0| return true; 3182| 0| } 3183| 18.9k| subframe->qlp_coeff_precision = u32+1; 3184| | 3185| | /* read qlp shift */ 3186| 18.9k| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i32, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN)) ------------------ | Branch (3186:5): [True: 0, False: 18.9k] ------------------ 3187| 0| return false; /* read_callback_ sets the state for us */ 3188| 18.9k| if(i32 < 0) { ------------------ | Branch (3188:5): [True: 0, False: 18.9k] ------------------ 3189| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3190| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3191| 0| return true; 3192| 0| } 3193| 18.9k| subframe->quantization_level = i32; 3194| | 3195| | /* read quantized lp coefficiencts */ 3196| 124k| for(u = 0; u < order; u++) { ------------------ | Branch (3196:13): [True: 105k, False: 18.9k] ------------------ 3197| 105k| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i32, subframe->qlp_coeff_precision)) ------------------ | Branch (3197:6): [True: 0, False: 105k] ------------------ 3198| 0| return false; /* read_callback_ sets the state for us */ 3199| 105k| subframe->qlp_coeff[u] = i32; 3200| 105k| } 3201| | 3202| | /* read entropy coding method info */ 3203| 18.9k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN)) ------------------ | Branch (3203:5): [True: 0, False: 18.9k] ------------------ 3204| 0| return false; /* read_callback_ sets the state for us */ 3205| 18.9k| subframe->entropy_coding_method.type = (FLAC__EntropyCodingMethodType)u32; 3206| 18.9k| switch(subframe->entropy_coding_method.type) { 3207| 13.1k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3207:3): [True: 13.1k, False: 5.74k] ------------------ 3208| 18.9k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3208:3): [True: 5.74k, False: 13.1k] ------------------ 3209| 18.9k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) ------------------ | Branch (3209:7): [True: 0, False: 18.9k] ------------------ 3210| 0| return false; /* read_callback_ sets the state for us */ 3211| 18.9k| if((decoder->private_->frame.header.blocksize >> u32 < order) || ------------------ | Branch (3211:7): [True: 0, False: 18.9k] ------------------ 3212| 18.9k| (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) { ------------------ | Branch (3212:7): [True: 0, False: 18.9k] ------------------ 3213| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3214| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3215| 0| return true; 3216| 0| } 3217| 18.9k| subframe->entropy_coding_method.data.partitioned_rice.order = u32; 3218| 18.9k| subframe->entropy_coding_method.data.partitioned_rice.contents = &decoder->private_->partitioned_rice_contents[channel]; 3219| 18.9k| break; 3220| 0| default: ------------------ | Branch (3220:3): [True: 0, False: 18.9k] ------------------ 3221| 0| send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM); 3222| 0| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3223| 0| return true; 3224| 18.9k| } 3225| | 3226| | /* read residual */ 3227| 18.9k| switch(subframe->entropy_coding_method.type) { 3228| 13.1k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3228:3): [True: 13.1k, False: 5.74k] ------------------ 3229| 18.9k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3229:3): [True: 5.74k, False: 13.1k] ------------------ 3230| 18.9k| if(!read_residual_partitioned_rice_(decoder, order, subframe->entropy_coding_method.data.partitioned_rice.order, &decoder->private_->partitioned_rice_contents[channel], decoder->private_->residual[channel], /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2)) ------------------ | Branch (3230:7): [True: 0, False: 18.9k] ------------------ 3231| 0| return false; 3232| 18.9k| break; 3233| 18.9k| default: ------------------ | Branch (3233:3): [True: 0, False: 18.9k] ------------------ 3234| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 3235| 18.9k| } 3236| | 3237| | /* decode the subframe */ 3238| 18.9k| if(do_full_decode) { ------------------ | Branch (3238:5): [True: 18.9k, False: 0] ------------------ 3239| 18.9k| if(bps <= 32) { ------------------ | Branch (3239:6): [True: 17.4k, False: 1.50k] ------------------ 3240| 17.4k| uint32_t i; 3241| 113k| for(i = 0; i < order; i++) ------------------ | Branch (3241:15): [True: 95.8k, False: 17.4k] ------------------ 3242| 95.8k| decoder->private_->output[channel][i] = subframe->warmup[i]; 3243| 17.4k| if(FLAC__lpc_max_residual_bps(bps, subframe->qlp_coeff, order, subframe->quantization_level) <= 32 && ------------------ | Branch (3243:7): [True: 7.84k, False: 9.56k] ------------------ 3244| 7.84k| FLAC__lpc_max_prediction_before_shift_bps(bps, subframe->qlp_coeff, order) <= 32) ------------------ | Branch (3244:7): [True: 6.81k, False: 1.03k] ------------------ 3245| 6.81k| FLAC__lpc_restore_signal(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private_->output[channel]+order); 3246| 10.5k| else 3247| 10.5k| FLAC__lpc_restore_signal_wide(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private_->output[channel]+order); 3248| 17.4k| } 3249| 1.50k| else { 3250| 1.50k| decoder->private_->side_subframe_in_use = true; 3251| 1.50k| memcpy(decoder->private_->side_subframe, subframe->warmup, sizeof(FLAC__int64) * order); 3252| 1.50k| FLAC__lpc_restore_signal_wide_33bit(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private_->side_subframe+order); 3253| 1.50k| } 3254| 18.9k| } 3255| | 3256| | return true; 3257| 18.9k|} stream_decoder.c:read_zero_padding_: 3360| 203k|{ 3361| 203k| if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) { ------------------ | Branch (3361:5): [True: 99.0k, False: 104k] ------------------ 3362| 99.0k| FLAC__uint32 zero = 0; 3363| 99.0k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &zero, FLAC__bitreader_bits_left_for_byte_alignment(decoder->private_->input))) ------------------ | Branch (3363:6): [True: 0, False: 99.0k] ------------------ 3364| 0| return false; /* read_callback_ sets the state for us */ 3365| |#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 3366| | if(zero != 0) { 3367| | send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); 3368| | decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 3369| | } 3370| |#endif 3371| 99.0k| } 3372| 203k| return true; 3373| 203k|} stream_decoder.c:undo_channel_coding: 3476| 203k|void undo_channel_coding(FLAC__StreamDecoder *decoder) { 3477| 203k| uint32_t i; 3478| 203k| switch(decoder->private_->frame.header.channel_assignment) { 3479| 167k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (3479:2): [True: 167k, False: 35.8k] ------------------ 3480| | /* do nothing */ 3481| 167k| break; 3482| 17.2k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (3482:2): [True: 17.2k, False: 186k] ------------------ 3483| 17.2k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 17.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.2k] | | ------------------ ------------------ 3484| 17.2k| FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32)); ------------------ | | 38| 17.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.2k] | | ------------------ ------------------ 3485| 449k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) ------------------ | Branch (3485:14): [True: 432k, False: 17.2k] ------------------ 3486| 432k| if(decoder->private_->side_subframe_in_use) ------------------ | Branch (3486:7): [True: 268k, False: 163k] ------------------ 3487| 268k| decoder->private_->output[1][i] = decoder->private_->output[0][i] - decoder->private_->side_subframe[i]; 3488| 163k| else 3489| 163k| decoder->private_->output[1][i] = decoder->private_->output[0][i] - decoder->private_->output[1][i]; 3490| 17.2k| break; 3491| 7.62k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (3491:2): [True: 7.62k, False: 195k] ------------------ 3492| 7.62k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 7.62k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 7.62k] | | ------------------ ------------------ 3493| 7.62k| FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32)); ------------------ | | 38| 7.62k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 7.62k] | | ------------------ ------------------ 3494| 315k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) ------------------ | Branch (3494:14): [True: 307k, False: 7.62k] ------------------ 3495| 307k| if(decoder->private_->side_subframe_in_use) ------------------ | Branch (3495:7): [True: 234k, False: 73.2k] ------------------ 3496| 234k| decoder->private_->output[0][i] = decoder->private_->output[1][i] + decoder->private_->side_subframe[i]; 3497| 73.2k| else 3498| 73.2k| decoder->private_->output[0][i] += decoder->private_->output[1][i]; 3499| 7.62k| break; 3500| 10.9k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (3500:2): [True: 10.9k, False: 192k] ------------------ 3501| 10.9k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 10.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.9k] | | ------------------ ------------------ 3502| 10.9k| FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32)); ------------------ | | 38| 10.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.9k] | | ------------------ ------------------ 3503| 2.10M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3503:14): [True: 2.09M, False: 10.9k] ------------------ 3504| 2.09M| if(!decoder->private_->side_subframe_in_use){ ------------------ | Branch (3504:7): [True: 66.1k, False: 2.02M] ------------------ 3505| 66.1k| FLAC__int32 mid, side; 3506| 66.1k| mid = decoder->private_->output[0][i]; 3507| 66.1k| side = decoder->private_->output[1][i]; 3508| 66.1k| mid = ((uint32_t) mid) << 1; 3509| 66.1k| mid |= (side & 1); /* i.e. if 'side' is odd... */ 3510| 66.1k| decoder->private_->output[0][i] = (mid + side) >> 1; 3511| 66.1k| decoder->private_->output[1][i] = (mid - side) >> 1; 3512| 66.1k| } 3513| 2.02M| else { /* bps == 32 */ 3514| 2.02M| FLAC__int64 mid; 3515| 2.02M| mid = ((uint64_t)decoder->private_->output[0][i]) << 1; 3516| 2.02M| mid |= (decoder->private_->side_subframe[i] & 1); /* i.e. if 'side' is odd... */ 3517| 2.02M| decoder->private_->output[0][i] = (mid + decoder->private_->side_subframe[i]) >> 1; 3518| 2.02M| decoder->private_->output[1][i] = (mid - decoder->private_->side_subframe[i]) >> 1; 3519| 2.02M| } 3520| 2.09M| } 3521| 10.9k| break; 3522| 0| default: ------------------ | Branch (3522:2): [True: 0, False: 203k] ------------------ 3523| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 3524| 0| break; 3525| 203k| } 3526| 203k|} stream_decoder.c:write_audio_frame_to_client_: 3579| 203k|{ 3580| 203k| decoder->private_->last_frame = *frame; /* save the frame */ 3581| 203k| decoder->private_->last_frame_is_set = true; 3582| 203k| if(decoder->private_->is_seeking && !decoder->private_->is_indexing) { ------------------ | Branch (3582:5): [True: 0, False: 203k] | Branch (3582:38): [True: 0, False: 0] ------------------ 3583| 0| FLAC__uint64 this_frame_sample = frame->header.number.sample_number; 3584| 0| FLAC__uint64 next_frame_sample = this_frame_sample + (FLAC__uint64)frame->header.blocksize; 3585| 0| FLAC__uint64 target_sample = decoder->private_->target_sample; 3586| | 3587| 0| FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 3588| | 3589| 0| decoder->private_->got_a_frame = true; 3590| | 3591| 0| if(this_frame_sample <= target_sample && target_sample < next_frame_sample) { /* we hit our target frame */ ------------------ | Branch (3591:6): [True: 0, False: 0] | Branch (3591:44): [True: 0, False: 0] ------------------ 3592| 0| uint32_t delta = (uint32_t)(target_sample - this_frame_sample); 3593| | /* kick out of seek mode */ 3594| 0| decoder->private_->is_seeking = false; 3595| | /* shift out the samples before target_sample */ 3596| 0| if(delta > 0) { ------------------ | Branch (3596:7): [True: 0, False: 0] ------------------ 3597| 0| uint32_t channel; 3598| 0| const FLAC__int32 *newbuffer[FLAC__MAX_CHANNELS]; 3599| 0| for(channel = 0; channel < frame->header.channels; channel++) { ------------------ | Branch (3599:22): [True: 0, False: 0] ------------------ 3600| 0| newbuffer[channel] = buffer[channel] + delta; 3601| 0| decoder->private_->last_frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_VERBATIM; 3602| 0| decoder->private_->last_frame.subframes[channel].data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32; 3603| 0| decoder->private_->last_frame.subframes[channel].data.verbatim.data.int32 = newbuffer[channel]; 3604| 0| } 3605| 0| decoder->private_->last_frame.header.blocksize -= delta; 3606| 0| decoder->private_->last_frame.header.number.sample_number += (FLAC__uint64)delta; 3607| | /* write the relevant samples */ 3608| 0| return decoder->private_->write_callback(decoder, &decoder->private_->last_frame, newbuffer, decoder->private_->client_data); 3609| 0| } 3610| 0| else { 3611| | /* write the relevant samples */ 3612| 0| return decoder->private_->write_callback(decoder, frame, buffer, decoder->private_->client_data); 3613| 0| } 3614| 0| } 3615| 0| else { 3616| 0| return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 3617| 0| } 3618| 0| } 3619| 203k| else if(!decoder->private_->is_indexing) { ------------------ | Branch (3619:10): [True: 203k, False: 0] ------------------ 3620| | /* 3621| | * If we never got STREAMINFO, turn off MD5 checking to save 3622| | * cycles since we don't have a sum to compare to anyway 3623| | */ 3624| 203k| if(!decoder->private_->has_stream_info) ------------------ | Branch (3624:6): [True: 0, False: 203k] ------------------ 3625| 0| decoder->private_->do_md5_checking = false; 3626| 203k| if(decoder->private_->do_md5_checking) { ------------------ | Branch (3626:6): [True: 0, False: 203k] ------------------ 3627| 0| if(!FLAC__MD5Accumulate(&decoder->private_->md5context, buffer, frame->header.channels, frame->header.blocksize, (frame->header.bits_per_sample+7) / 8)) ------------------ | Branch (3627:7): [True: 0, False: 0] ------------------ 3628| 0| return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 3629| 0| } 3630| 203k| return decoder->private_->write_callback(decoder, frame, buffer, decoder->private_->client_data); 3631| 203k| } 3632| 0| else { /* decoder->private_->is_indexing == true */ 3633| 0| return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 3634| 0| } 3635| 203k|} FLAC__stream_encoder_new: 584| 11.5k|{ 585| 11.5k| FLAC__StreamEncoder *encoder; 586| 11.5k| uint32_t i; 587| | 588| 11.5k| FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ ------------------ | | 38| 11.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 11.5k] | | ------------------ ------------------ 589| | 590| 11.5k| encoder = safe_calloc_(1, sizeof(FLAC__StreamEncoder)); 591| 11.5k| if(encoder == 0) { ------------------ | Branch (591:5): [True: 0, False: 11.5k] ------------------ 592| 0| return 0; 593| 0| } 594| | 595| 11.5k| encoder->protected_ = safe_calloc_(1, sizeof(FLAC__StreamEncoderProtected)); 596| 11.5k| if(encoder->protected_ == 0) { ------------------ | Branch (596:5): [True: 0, False: 11.5k] ------------------ 597| 0| free(encoder); 598| 0| return 0; 599| 0| } 600| | 601| 11.5k| encoder->private_ = safe_calloc_(1, sizeof(FLAC__StreamEncoderPrivate)); 602| 11.5k| if(encoder->private_ == 0) { ------------------ | Branch (602:5): [True: 0, False: 11.5k] ------------------ 603| 0| free(encoder->protected_); 604| 0| free(encoder); 605| 0| return 0; 606| 0| } 607| | 608| 11.5k| encoder->private_->threadtask[0] = safe_calloc_(1, sizeof(FLAC__StreamEncoderThreadTask)); 609| 11.5k| if(encoder->private_->threadtask[0] == 0) { ------------------ | Branch (609:5): [True: 0, False: 11.5k] ------------------ 610| 0| free(encoder->private_); 611| 0| free(encoder->protected_); 612| 0| free(encoder); 613| 0| return 0; 614| 0| } 615| | 616| 11.5k| encoder->private_->threadtask[0]->frame = FLAC__bitwriter_new(); 617| 11.5k| if(encoder->private_->threadtask[0]->frame == 0) { ------------------ | Branch (617:5): [True: 0, False: 11.5k] ------------------ 618| 0| free(encoder->private_->threadtask[0]); 619| 0| free(encoder->private_); 620| 0| free(encoder->protected_); 621| 0| free(encoder); 622| 0| return 0; 623| 0| } 624| | 625| 11.5k| encoder->private_->file = 0; 626| | 627| 11.5k| encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; 628| | 629| 11.5k| set_defaults_(encoder); 630| | 631| 11.5k| encoder->private_->is_being_deleted = false; 632| | 633| 104k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 104k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (633:13): [True: 92.6k, False: 11.5k] ------------------ 634| 92.6k| encoder->private_->threadtask[0]->subframe_workspace_ptr[i][0] = &encoder->private_->threadtask[0]->subframe_workspace[i][0]; 635| 92.6k| encoder->private_->threadtask[0]->subframe_workspace_ptr[i][1] = &encoder->private_->threadtask[0]->subframe_workspace[i][1]; 636| 92.6k| } 637| 34.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (637:13): [True: 23.1k, False: 11.5k] ------------------ 638| 23.1k| encoder->private_->threadtask[0]->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->threadtask[0]->subframe_workspace_mid_side[i][0]; 639| 23.1k| encoder->private_->threadtask[0]->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->threadtask[0]->subframe_workspace_mid_side[i][1]; 640| 23.1k| } 641| 104k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 104k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (641:13): [True: 92.6k, False: 11.5k] ------------------ 642| 92.6k| encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][0]; 643| 92.6k| encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][1]; 644| 92.6k| } 645| 34.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (645:13): [True: 23.1k, False: 11.5k] ------------------ 646| 23.1k| encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][0]; 647| 23.1k| encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][1]; 648| 23.1k| } 649| | 650| 104k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 104k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (650:13): [True: 92.6k, False: 11.5k] ------------------ 651| 92.6k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][0]); 652| 92.6k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][1]); 653| 92.6k| } 654| 34.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (654:13): [True: 23.1k, False: 11.5k] ------------------ 655| 23.1k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][0]); 656| 23.1k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][1]); 657| 23.1k| } 658| 34.7k| for(i = 0; i < 2; i++) ------------------ | Branch (658:13): [True: 23.1k, False: 11.5k] ------------------ 659| 23.1k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_extra[i]); 660| | 661| 11.5k| return encoder; 662| 11.5k|} FLAC__stream_encoder_delete: 665| 11.5k|{ 666| 11.5k| uint32_t i; 667| | 668| 11.5k| if (encoder == NULL) ------------------ | Branch (668:6): [True: 0, False: 11.5k] ------------------ 669| 0| return ; 670| | 671| 11.5k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 11.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5k] | | ------------------ ------------------ 672| 11.5k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 11.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5k] | | ------------------ ------------------ 673| 11.5k| FLAC__ASSERT(0 != encoder->private_->threadtask[0]); ------------------ | | 38| 11.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5k] | | ------------------ ------------------ 674| 11.5k| FLAC__ASSERT(0 != encoder->private_->threadtask[0]->frame); ------------------ | | 38| 11.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.5k] | | ------------------ ------------------ 675| | 676| 11.5k| encoder->private_->is_being_deleted = true; 677| | 678| 11.5k| (void)FLAC__stream_encoder_finish(encoder); 679| | 680| 11.5k| if(0 != encoder->private_->verify.decoder) ------------------ | Branch (680:5): [True: 8.16k, False: 3.41k] ------------------ 681| 8.16k| FLAC__stream_decoder_delete(encoder->private_->verify.decoder); 682| | 683| 104k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 104k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (683:13): [True: 92.6k, False: 11.5k] ------------------ 684| 92.6k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][0]); 685| 92.6k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][1]); 686| 92.6k| } 687| 34.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (687:13): [True: 23.1k, False: 11.5k] ------------------ 688| 23.1k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][0]); 689| 23.1k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][1]); 690| 23.1k| } 691| 34.7k| for(i = 0; i < 2; i++) ------------------ | Branch (691:13): [True: 23.1k, False: 11.5k] ------------------ 692| 23.1k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_extra[i]); 693| | 694| 11.5k| FLAC__bitwriter_delete(encoder->private_->threadtask[0]->frame); 695| 11.5k| free(encoder->private_->threadtask[0]); 696| 11.5k| free(encoder->private_); 697| 11.5k| free(encoder->protected_); 698| 11.5k| free(encoder); 699| 11.5k|} FLAC__stream_encoder_init_stream: 1450| 6.64k|{ 1451| 6.64k| return init_stream_internal_( 1452| 6.64k| encoder, 1453| 6.64k| /*read_callback=*/0, 1454| 6.64k| write_callback, 1455| 6.64k| seek_callback, 1456| 6.64k| tell_callback, 1457| 6.64k| metadata_callback, 1458| 6.64k| client_data, 1459| | /*is_ogg=*/false 1460| 6.64k| ); 1461| 6.64k|} FLAC__stream_encoder_init_ogg_stream: 1472| 3.00k|{ 1473| 3.00k| return init_stream_internal_( 1474| 3.00k| encoder, 1475| 3.00k| read_callback, 1476| 3.00k| write_callback, 1477| 3.00k| seek_callback, 1478| 3.00k| tell_callback, 1479| 3.00k| metadata_callback, 1480| 3.00k| client_data, 1481| | /*is_ogg=*/true 1482| 3.00k| ); 1483| 3.00k|} FLAC__stream_encoder_finish: 1626| 34.7k|{ 1627| 34.7k| FLAC__bool error = false; 1628| | 1629| 34.7k| if (encoder == NULL) ------------------ | Branch (1629:6): [True: 0, False: 34.7k] ------------------ 1630| 0| return false; 1631| | 1632| 34.7k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 34.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 34.7k] | | ------------------ ------------------ 1633| 34.7k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 34.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 34.7k] | | ------------------ ------------------ 1634| | 1635| 34.7k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED){ ------------------ | Branch (1635:5): [True: 25.3k, False: 9.37k] ------------------ 1636| 25.3k| if(encoder->protected_->metadata){ // True in case FLAC__stream_encoder_set_metadata was used but init failed ------------------ | Branch (1636:6): [True: 0, False: 25.3k] ------------------ 1637| 0| free(encoder->protected_->metadata); 1638| 0| encoder->protected_->metadata = 0; 1639| 0| encoder->protected_->num_metadata_blocks = 0; 1640| 0| } 1641| 25.3k| if(0 != encoder->private_->file) { ------------------ | Branch (1641:6): [True: 0, False: 25.3k] ------------------ 1642| 0| if(encoder->private_->file != stdout) ------------------ | Branch (1642:7): [True: 0, False: 0] ------------------ 1643| 0| fclose(encoder->private_->file); 1644| 0| encoder->private_->file = 0; 1645| 0| } 1646| 25.3k| return true; 1647| 25.3k| } 1648| | 1649| 9.37k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) { ------------------ | Branch (1649:5): [True: 9.30k, False: 75] | Branch (1649:62): [True: 9.30k, False: 0] ------------------ 1650| 9.30k| FLAC__bool ok = true; 1651| | /* first finish threads */ 1652| 9.30k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (1652:6): [True: 794, False: 8.50k] ------------------ 1653| 794|#ifdef FLAC__USE_THREADS 1654| | /* This is quite complicated, so here is an explanation on what is supposed to happen 1655| | * 1656| | * Thread no.0 and threadtask no.0 are reserved for non-threaded operation, so counting 1657| | * here starts at 1, which makes things slightly more complicated. 1658| | * 1659| | * If the file processed was very short compared to the requested number of threadtasks, 1660| | * not all threadtasks have been populated yet. Handling that is easy: threadtask no.1 needs 1661| | * to be processed first, monotonically increasing until the last populated threadtask is 1662| | * processed. This number is stored in encoder->private_->num_started_threadtasks 1663| | * 1664| | * If the file is longer, the next due frame chronologically might not be in threadtasks 1665| | * number 1, because the threadtasks work like a ringbuffer. To access this, the variable 1666| | * twrap starts counting at the next due frame, and the modulo operator (%) is used to 1667| | * "wrap" the number with the number of threadtasks. So, if the next due task is 3 1668| | * and 4 tasks are started, twrap increases 3, 4, 5, 6, and t follows with values 3, 4, 1, 2. 1669| | */ 1670| 794| uint32_t start, end, t, twrap; 1671| 794| if(encoder->private_->num_started_threadtasks < encoder->private_->num_threadtasks) { ------------------ | Branch (1671:7): [True: 480, False: 314] ------------------ 1672| 480| start = 1; 1673| 480| end = encoder->private_->num_started_threadtasks; 1674| 480| } 1675| 314| else { 1676| 314| start = encoder->private_->next_thread; 1677| 314| end = encoder->private_->next_thread + encoder->private_->num_threadtasks - 1; 1678| 314| } 1679| 6.27k| for(twrap = start; twrap < end; twrap++) { ------------------ | Branch (1679:23): [True: 5.48k, False: 794] ------------------ 1680| 5.48k| FLAC__ASSERT(twrap > 0); ------------------ | | 38| 5.48k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 5.48k] | | ------------------ ------------------ 1681| 5.48k| t = (twrap - 1) % (encoder->private_->num_threadtasks - 1) + 1; 1682| | /* Lock mutex, if task isn't done yet, wait for condition */ 1683| 5.48k| FLAC__mtx_lock(&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 105| 5.48k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 1684| 5.61k| while(!encoder->private_->threadtask[t]->task_done) ------------------ | Branch (1684:11): [True: 137, False: 5.48k] ------------------ 1685| 137| FLAC__cnd_wait(&encoder->private_->threadtask[t]->cond_task_done,&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 113| 5.61k|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 1686| | 1687| 5.48k| if(!encoder->private_->threadtask[t]->returnvalue) ------------------ | Branch (1687:8): [True: 0, False: 5.48k] ------------------ 1688| 0| ok = false; 1689| 5.48k| if(ok && !write_bitbuffer_(encoder, encoder->private_->threadtask[t], encoder->protected_->blocksize, 0)) ------------------ | Branch (1689:8): [True: 5.48k, False: 0] | Branch (1689:14): [True: 0, False: 5.48k] ------------------ 1690| 0| ok = false; 1691| 5.48k| FLAC__mtx_unlock(&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 106| 5.48k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 1692| 5.48k| } 1693| | /* Wait for MD5 calculation to finish */ 1694| 794| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 794|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 1695| 799| while(encoder->private_->md5_active || encoder->private_->md5_fifo.tail > 0) { ------------------ | Branch (1695:10): [True: 5, False: 794] | Branch (1695:43): [True: 0, False: 794] ------------------ 1696| 5| FLAC__cnd_wait(&encoder->private_->cond_md5_emptied, &encoder->private_->mutex_work_queue); ------------------ | | 113| 5|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 1697| 5| } 1698| 794| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 794|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 1699| |#else 1700| | FLAC__ASSERT(0); 1701| |#endif 1702| 794| } 1703| 9.30k| if(ok && encoder->private_->current_sample_number != 0) { ------------------ | Branch (1703:6): [True: 9.30k, False: 0] | Branch (1703:12): [True: 8.50k, False: 793] ------------------ 1704| 8.50k| encoder->protected_->blocksize = encoder->private_->current_sample_number; 1705| 8.50k| if(!resize_buffers_(encoder, encoder->protected_->blocksize)) { ------------------ | Branch (1705:7): [True: 0, False: 8.50k] ------------------ 1706| | /* the above function sets the state for us in case of an error */ 1707| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1708| 0| } 1709| 8.50k| if(!process_frame_(encoder, /*is_last_block=*/true)) ------------------ | Branch (1709:7): [True: 0, False: 8.50k] ------------------ 1710| 0| error = true; 1711| 8.50k| } 1712| 9.30k| } 1713| | 1714| 9.37k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (1714:5): [True: 806, False: 8.56k] ------------------ 1715| 806|#ifdef FLAC__USE_THREADS 1716| | /* Properly finish all threads */ 1717| 806| uint32_t t; 1718| 806| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 806|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 1719| 3.53k| for(t = 1; t < encoder->private_->num_created_threads; t++) ------------------ | Branch (1719:14): [True: 2.72k, False: 806] ------------------ 1720| 2.72k| encoder->private_->finish_work_threads = true; 1721| 806| FLAC__cnd_broadcast(&encoder->private_->cond_wake_up_thread); ------------------ | | 111| 806|#define FLAC__cnd_broadcast(cv) pthread_cond_broadcast(cv) ------------------ 1722| 806| FLAC__cnd_broadcast(&encoder->private_->cond_work_available); ------------------ | | 111| 806|#define FLAC__cnd_broadcast(cv) pthread_cond_broadcast(cv) ------------------ 1723| 806| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 806|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 1724| | 1725| 3.53k| for(t = 1; t < encoder->private_->num_created_threads; t++) ------------------ | Branch (1725:14): [True: 2.72k, False: 806] ------------------ 1726| 2.72k| FLAC__thrd_join(encoder->private_->thread[t], NULL); ------------------ | | 99| 2.72k|#define FLAC__thrd_join(thread, result) pthread_join(thread, result) ------------------ 1727| |#else 1728| | FLAC__ASSERT(0); 1729| |#endif 1730| 806| } 1731| | 1732| 9.37k| if(encoder->protected_->do_md5) ------------------ | Branch (1732:5): [True: 9.37k, False: 0] ------------------ 1733| 9.37k| FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context); 1734| | 1735| 9.37k| if(!encoder->private_->is_being_deleted) { ------------------ | Branch (1735:5): [True: 9.37k, False: 0] ------------------ 1736| 9.37k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK) { ------------------ | Branch (1736:6): [True: 9.30k, False: 75] ------------------ 1737| 9.30k| if(encoder->private_->seek_callback) { ------------------ | Branch (1737:7): [True: 9.30k, False: 0] ------------------ 1738| 9.30k|#if FLAC__HAS_OGG 1739| 9.30k| if(encoder->private_->is_ogg) ------------------ | Branch (1739:8): [True: 2.88k, False: 6.41k] ------------------ 1740| 2.88k| update_ogg_metadata_(encoder); 1741| 6.41k| else 1742| 6.41k|#endif 1743| 6.41k| update_metadata_(encoder); 1744| | 1745| | /* check if an error occurred while updating metadata */ 1746| 9.30k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK) ------------------ | Branch (1746:8): [True: 0, False: 9.30k] ------------------ 1747| 0| error = true; 1748| 9.30k| } 1749| 9.30k| if(encoder->private_->metadata_callback) ------------------ | Branch (1749:7): [True: 9.30k, False: 0] ------------------ 1750| 9.30k| encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data); 1751| 9.30k| } 1752| | 1753| 9.37k| if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder && !FLAC__stream_decoder_finish(encoder->private_->verify.decoder)) { ------------------ | Branch (1753:6): [True: 8.16k, False: 1.20k] | Branch (1753:37): [True: 8.16k, False: 0] | Branch (1753:79): [True: 0, False: 8.16k] ------------------ 1754| 0| if(!error) ------------------ | Branch (1754:7): [True: 0, False: 0] ------------------ 1755| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA; 1756| 0| error = true; 1757| 0| } 1758| 9.37k| } 1759| | 1760| 9.37k| if(0 != encoder->private_->file) { ------------------ | Branch (1760:5): [True: 0, False: 9.37k] ------------------ 1761| 0| if(encoder->private_->file != stdout) ------------------ | Branch (1761:6): [True: 0, False: 0] ------------------ 1762| 0| fclose(encoder->private_->file); 1763| 0| encoder->private_->file = 0; 1764| 0| } 1765| | 1766| 9.37k|#if FLAC__HAS_OGG 1767| 9.37k| if(encoder->private_->is_ogg) ------------------ | Branch (1767:5): [True: 2.89k, False: 6.48k] ------------------ 1768| 2.89k| FLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect); 1769| 9.37k|#endif 1770| | 1771| 9.37k| free_(encoder); 1772| 9.37k| set_defaults_(encoder); 1773| | 1774| 9.37k| if(!error) ------------------ | Branch (1774:5): [True: 9.37k, False: 0] ------------------ 1775| 9.37k| encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; 1776| | 1777| 9.37k| return !error; 1778| 9.37k|} FLAC__stream_encoder_set_ogg_serial_number: 1781| 20.8k|{ 1782| 20.8k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 1783| 20.8k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 1784| 20.8k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 1785| 20.8k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1785:5): [True: 9.37k, False: 11.5k] ------------------ 1786| 9.37k| return false; 1787| 11.5k|#if FLAC__HAS_OGG 1788| | /* can't check encoder->private_->is_ogg since that's not set until init time */ 1789| 11.5k| FLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value); 1790| 11.5k| return true; 1791| |#else 1792| | (void)value; 1793| | return false; 1794| |#endif 1795| 20.8k|} FLAC__stream_encoder_set_verify: 1798| 20.8k|{ 1799| 20.8k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 1800| 20.8k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 1801| 20.8k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 20.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.8k] | | ------------------ ------------------ 1802| 20.8k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1802:5): [True: 9.37k, False: 11.5k] ------------------ 1803| 9.37k| return false; 1804| 11.5k|#ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING 1805| 11.5k| encoder->protected_->verify = value; 1806| 11.5k|#endif 1807| | return true; 1808| 20.8k|} FLAC__stream_encoder_set_streamable_subset: 1811| 20.9k|{ 1812| 20.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1813| 20.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1814| 20.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1815| 20.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1815:5): [True: 9.37k, False: 11.5k] ------------------ 1816| 9.37k| return false; 1817| 11.5k| encoder->protected_->streamable_subset = value; 1818| | return true; 1819| 20.9k|} FLAC__stream_encoder_set_channels: 1841| 20.9k|{ 1842| 20.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1843| 20.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1844| 20.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1845| 20.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1845:5): [True: 9.37k, False: 11.5k] ------------------ 1846| 9.37k| return false; 1847| 11.5k| encoder->protected_->channels = value; 1848| | return true; 1849| 20.9k|} FLAC__stream_encoder_set_bits_per_sample: 1852| 20.9k|{ 1853| 20.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1854| 20.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1855| 20.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 1856| 20.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1856:5): [True: 9.37k, False: 11.5k] ------------------ 1857| 9.37k| return false; 1858| 11.5k| encoder->protected_->bits_per_sample = value; 1859| | return true; 1860| 20.9k|} FLAC__stream_encoder_set_sample_rate: 1863| 19.0k|{ 1864| 19.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 1865| 19.0k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 1866| 19.0k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 1867| 19.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1867:5): [True: 9.37k, False: 9.69k] ------------------ 1868| 9.37k| return false; 1869| 9.69k| encoder->protected_->sample_rate = value; 1870| | return true; 1871| 19.0k|} FLAC__stream_encoder_set_compression_level: 1874| 41.8k|{ 1875| 41.8k| FLAC__bool ok = true; 1876| 41.8k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 41.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 41.8k] | | ------------------ ------------------ 1877| 41.8k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 41.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 41.8k] | | ------------------ ------------------ 1878| 41.8k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 41.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 41.8k] | | ------------------ ------------------ 1879| 41.8k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1879:5): [True: 18.7k, False: 23.0k] ------------------ 1880| 18.7k| return false; 1881| 23.0k| if(value >= sizeof(compression_levels_)/sizeof(compression_levels_[0])) ------------------ | Branch (1881:5): [True: 9.40k, False: 13.6k] ------------------ 1882| 9.40k| value = sizeof(compression_levels_)/sizeof(compression_levels_[0]) - 1; 1883| 23.0k| ok &= FLAC__stream_encoder_set_do_mid_side_stereo (encoder, compression_levels_[value].do_mid_side_stereo); 1884| 23.0k| ok &= FLAC__stream_encoder_set_loose_mid_side_stereo (encoder, compression_levels_[value].loose_mid_side_stereo); 1885| 23.0k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 1886| 23.0k|#if 1 1887| 23.0k| ok &= FLAC__stream_encoder_set_apodization (encoder, compression_levels_[value].apodization); 1888| |#else 1889| | /* equivalent to -A tukey(0.5) */ 1890| | encoder->protected_->num_apodizations = 1; 1891| | encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 1892| | encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 1893| |#endif 1894| 23.0k|#endif 1895| 23.0k| ok &= FLAC__stream_encoder_set_max_lpc_order (encoder, compression_levels_[value].max_lpc_order); 1896| 23.0k| ok &= FLAC__stream_encoder_set_qlp_coeff_precision (encoder, compression_levels_[value].qlp_coeff_precision); 1897| 23.0k| ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search (encoder, compression_levels_[value].do_qlp_coeff_prec_search); 1898| 23.0k| ok &= FLAC__stream_encoder_set_do_escape_coding (encoder, compression_levels_[value].do_escape_coding); 1899| 23.0k| ok &= FLAC__stream_encoder_set_do_exhaustive_model_search (encoder, compression_levels_[value].do_exhaustive_model_search); 1900| 23.0k| ok &= FLAC__stream_encoder_set_min_residual_partition_order(encoder, compression_levels_[value].min_residual_partition_order); 1901| 23.0k| ok &= FLAC__stream_encoder_set_max_residual_partition_order(encoder, compression_levels_[value].max_residual_partition_order); 1902| 23.0k| ok &= FLAC__stream_encoder_set_rice_parameter_search_dist (encoder, compression_levels_[value].rice_parameter_search_dist); 1903| 23.0k| return ok; 1904| 41.8k|} FLAC__stream_encoder_set_blocksize: 1907| 19.0k|{ 1908| 19.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 1909| 19.0k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 1910| 19.0k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 1911| 19.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1911:5): [True: 9.37k, False: 9.70k] ------------------ 1912| 9.37k| return false; 1913| 9.70k| encoder->protected_->blocksize = value; 1914| | return true; 1915| 19.0k|} FLAC__stream_encoder_set_do_mid_side_stereo: 1918| 43.9k|{ 1919| 43.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 1920| 43.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 1921| 43.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 1922| 43.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1922:5): [True: 9.37k, False: 34.6k] ------------------ 1923| 9.37k| return false; 1924| 34.6k| encoder->protected_->do_mid_side_stereo = value; 1925| | return true; 1926| 43.9k|} FLAC__stream_encoder_set_loose_mid_side_stereo: 1929| 43.9k|{ 1930| 43.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 1931| 43.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 1932| 43.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 1933| 43.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1933:5): [True: 9.37k, False: 34.5k] ------------------ 1934| 9.37k| return false; 1935| 34.5k| encoder->protected_->loose_mid_side_stereo = value; 1936| | return true; 1937| 43.9k|} FLAC__stream_encoder_set_apodization: 1941| 45.3k|{ 1942| 45.3k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 45.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 45.3k] | | ------------------ ------------------ 1943| 45.3k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 45.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 45.3k] | | ------------------ ------------------ 1944| 45.3k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 45.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 45.3k] | | ------------------ ------------------ 1945| 45.3k| FLAC__ASSERT(0 != specification); ------------------ | | 38| 45.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 45.3k] | | ------------------ ------------------ 1946| 45.3k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1946:5): [True: 9.37k, False: 35.9k] ------------------ 1947| 9.37k| return false; 1948| |#ifdef FLAC__INTEGER_ONLY_LIBRARY 1949| | (void)specification; /* silently ignore since we haven't integerized; will always use a rectangular window */ 1950| |#else 1951| 35.9k| encoder->protected_->num_apodizations = 0; 1952| 77.0k| while(1) { ------------------ | Branch (1952:8): [True: 77.0k, Folded] ------------------ 1953| 77.0k| const char *s = strchr(specification, ';'); 1954| 77.0k| const size_t n = s? (size_t)(s - specification) : strlen(specification); ------------------ | Branch (1954:20): [True: 41.1k, False: 35.9k] ------------------ 1955| 77.0k| if (n==8 && 0 == strncmp("bartlett" , specification, n)) ------------------ | Branch (1955:11): [True: 2.44k, False: 74.6k] | Branch (1955:20): [True: 579, False: 1.86k] ------------------ 1956| 579| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT; 1957| 76.4k| else if(n==13 && 0 == strncmp("bartlett_hann", specification, n)) ------------------ | Branch (1957:11): [True: 931, False: 75.5k] | Branch (1957:20): [True: 118, False: 813] ------------------ 1958| 118| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN; 1959| 76.3k| else if(n==8 && 0 == strncmp("blackman" , specification, n)) ------------------ | Branch (1959:11): [True: 1.86k, False: 74.5k] | Branch (1959:20): [True: 131, False: 1.73k] ------------------ 1960| 131| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN; 1961| 76.2k| else if(n==26 && 0 == strncmp("blackman_harris_4term_92db", specification, n)) ------------------ | Branch (1961:11): [True: 1.25k, False: 74.9k] | Branch (1961:20): [True: 107, False: 1.14k] ------------------ 1962| 107| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE; 1963| 76.1k| else if(n==6 && 0 == strncmp("connes" , specification, n)) ------------------ | Branch (1963:11): [True: 1.50k, False: 74.6k] | Branch (1963:20): [True: 267, False: 1.24k] ------------------ 1964| 267| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES; 1965| 75.8k| else if(n==7 && 0 == strncmp("flattop" , specification, n)) ------------------ | Branch (1965:11): [True: 1.63k, False: 74.2k] | Branch (1965:20): [True: 203, False: 1.43k] ------------------ 1966| 203| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP; 1967| 75.6k| else if(n>7 && 0 == strncmp("gauss(" , specification, 6)) { ------------------ | Branch (1967:11): [True: 38.6k, False: 37.0k] | Branch (1967:20): [True: 440, False: 38.1k] ------------------ 1968| 440| FLAC__real stddev = (FLAC__real)strtod(specification+6, 0); 1969| 440| if (stddev > 0.0 && stddev <= 0.5) { ------------------ | Branch (1969:8): [True: 271, False: 169] | Branch (1969:24): [True: 178, False: 93] ------------------ 1970| 178| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev; 1971| 178| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS; 1972| 178| } 1973| 440| } 1974| 75.2k| else if(n==7 && 0 == strncmp("hamming" , specification, n)) ------------------ | Branch (1974:11): [True: 1.43k, False: 73.7k] | Branch (1974:20): [True: 246, False: 1.18k] ------------------ 1975| 246| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING; 1976| 74.9k| else if(n==4 && 0 == strncmp("hann" , specification, n)) ------------------ | Branch (1976:11): [True: 2.20k, False: 72.7k] | Branch (1976:20): [True: 476, False: 1.73k] ------------------ 1977| 476| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN; 1978| 74.5k| else if(n==13 && 0 == strncmp("kaiser_bessel", specification, n)) ------------------ | Branch (1978:11): [True: 812, False: 73.6k] | Branch (1978:20): [True: 143, False: 669] ------------------ 1979| 143| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL; 1980| 74.3k| else if(n==7 && 0 == strncmp("nuttall" , specification, n)) ------------------ | Branch (1980:11): [True: 1.18k, False: 73.1k] | Branch (1980:20): [True: 119, False: 1.07k] ------------------ 1981| 119| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL; 1982| 74.2k| else if(n==9 && 0 == strncmp("rectangle" , specification, n)) ------------------ | Branch (1982:11): [True: 1.08k, False: 73.1k] | Branch (1982:20): [True: 240, False: 842] ------------------ 1983| 240| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE; 1984| 74.0k| else if(n==8 && 0 == strncmp("triangle" , specification, n)) ------------------ | Branch (1984:11): [True: 1.65k, False: 72.3k] | Branch (1984:20): [True: 515, False: 1.13k] ------------------ 1985| 515| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE; 1986| 73.4k| else if(n>7 && 0 == strncmp("tukey(" , specification, 6)) { ------------------ | Branch (1986:11): [True: 37.2k, False: 36.2k] | Branch (1986:20): [True: 14.1k, False: 23.1k] ------------------ 1987| 14.1k| FLAC__real p = (FLAC__real)strtod(specification+6, 0); 1988| 14.1k| if (p >= 0.0 && p <= 1.0) { ------------------ | Branch (1988:8): [True: 14.0k, False: 95] | Branch (1988:20): [True: 13.9k, False: 106] ------------------ 1989| 13.9k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p; 1990| 13.9k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 1991| 13.9k| } 1992| 14.1k| } 1993| 59.3k| else if(n>15 && 0 == strncmp("partial_tukey(", specification, 14)) { ------------------ | Branch (1993:11): [True: 18.8k, False: 40.5k] | Branch (1993:21): [True: 1.35k, False: 17.4k] ------------------ 1994| 1.35k| FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+14, 0); 1995| 1.35k| const char *si_1 = strchr(specification, '/'); 1996| 1.35k| FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.1f; ------------------ | | 56| 1.35k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (1996:25): [True: 693, False: 662] | Branch (1996:30): [True: 454, False: 239] ------------------ 1997| 1.35k| FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f; 1998| 1.35k| const char *si_2 = strchr((si_1?(si_1+1):specification), '/'); ------------------ | Branch (1998:31): [True: 693, False: 662] ------------------ 1999| 1.35k| FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f; ------------------ | Branch (1999:25): [True: 578, False: 777] ------------------ 2000| | 2001| 1.35k| if (tukey_parts <= 1) { ------------------ | Branch (2001:8): [True: 169, False: 1.18k] ------------------ 2002| 169| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p; 2003| 169| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 2004| 1.18k| }else if (encoder->protected_->num_apodizations + tukey_parts < 32){ ------------------ | Branch (2004:14): [True: 629, False: 557] ------------------ 2005| 629| FLAC__int32 m; 2006| 5.55k| for(m = 0; m < tukey_parts; m++){ ------------------ | Branch (2006:16): [True: 4.92k, False: 629] ------------------ 2007| 4.92k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p; 2008| 4.92k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units); 2009| 4.92k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units); 2010| 4.92k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PARTIAL_TUKEY; 2011| 4.92k| } 2012| 629| } 2013| 1.35k| } 2014| 58.0k| else if(n>16 && 0 == strncmp("punchout_tukey(", specification, 15)) { ------------------ | Branch (2014:11): [True: 17.2k, False: 40.7k] | Branch (2014:21): [True: 1.63k, False: 15.6k] ------------------ 2015| 1.63k| FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+15, 0); 2016| 1.63k| const char *si_1 = strchr(specification, '/'); 2017| 1.63k| FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.2f; ------------------ | | 56| 1.63k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (2017:25): [True: 800, False: 831] | Branch (2017:30): [True: 437, False: 363] ------------------ 2018| 1.63k| FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f; 2019| 1.63k| const char *si_2 = strchr((si_1?(si_1+1):specification), '/'); ------------------ | Branch (2019:31): [True: 800, False: 831] ------------------ 2020| 1.63k| FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f; ------------------ | Branch (2020:25): [True: 445, False: 1.18k] ------------------ 2021| | 2022| 1.63k| if (tukey_parts <= 1) { ------------------ | Branch (2022:8): [True: 463, False: 1.16k] ------------------ 2023| 463| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p; 2024| 463| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 2025| 1.16k| }else if (encoder->protected_->num_apodizations + tukey_parts < 32){ ------------------ | Branch (2025:14): [True: 406, False: 762] ------------------ 2026| 406| FLAC__int32 m; 2027| 6.17k| for(m = 0; m < tukey_parts; m++){ ------------------ | Branch (2027:16): [True: 5.77k, False: 406] ------------------ 2028| 5.77k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p; 2029| 5.77k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units); 2030| 5.77k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units); 2031| 5.77k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PUNCHOUT_TUKEY; 2032| 5.77k| } 2033| 406| } 2034| 1.63k| } 2035| 56.3k| else if(n>17 && 0 == strncmp("subdivide_tukey(", specification, 16)){ ------------------ | Branch (2035:11): [True: 15.3k, False: 41.0k] | Branch (2035:20): [True: 11.6k, False: 3.71k] ------------------ 2036| 11.6k| FLAC__int32 parts = (FLAC__int32)strtod(specification+16, 0); 2037| 11.6k| if(parts > 1){ ------------------ | Branch (2037:7): [True: 11.4k, False: 177] ------------------ 2038| 11.4k| const char *si_1 = strchr(specification, '/'); 2039| 11.4k| FLAC__real p = si_1?(FLAC__real)strtod(si_1+1, 0):5e-1; ------------------ | Branch (2039:20): [True: 687, False: 10.7k] ------------------ 2040| 11.4k| if(p > 1) ------------------ | Branch (2040:8): [True: 72, False: 11.4k] ------------------ 2041| 72| p = 1; 2042| 11.4k| else if(p < 0) ------------------ | Branch (2042:13): [True: 105, False: 11.3k] ------------------ 2043| 105| p = 0; 2044| 11.4k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.subdivide_tukey.parts = parts; 2045| 11.4k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.subdivide_tukey.p = p/parts; 2046| 11.4k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_SUBDIVIDE_TUKEY; 2047| 11.4k| } 2048| 11.6k| } 2049| 44.7k| else if(n==5 && 0 == strncmp("welch" , specification, n)) ------------------ | Branch (2049:11): [True: 1.55k, False: 43.1k] | Branch (2049:20): [True: 265, False: 1.29k] ------------------ 2050| 265| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH; 2051| 77.0k| if (encoder->protected_->num_apodizations == 32) ------------------ | Branch (2051:7): [True: 62, False: 77.0k] ------------------ 2052| 62| break; 2053| 77.0k| if (s) ------------------ | Branch (2053:7): [True: 41.1k, False: 35.8k] ------------------ 2054| 41.1k| specification = s+1; 2055| 35.8k| else 2056| 35.8k| break; 2057| 77.0k| } 2058| 35.9k| if(encoder->protected_->num_apodizations == 0) { ------------------ | Branch (2058:5): [True: 10.6k, False: 25.3k] ------------------ 2059| 10.6k| encoder->protected_->num_apodizations = 1; 2060| 10.6k| encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 2061| 10.6k| encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 2062| 10.6k| } 2063| 35.9k|#endif 2064| | return true; 2065| 45.3k|} FLAC__stream_encoder_set_max_lpc_order: 2068| 42.4k|{ 2069| 42.4k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 42.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.4k] | | ------------------ ------------------ 2070| 42.4k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 42.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.4k] | | ------------------ ------------------ 2071| 42.4k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 42.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.4k] | | ------------------ ------------------ 2072| 42.4k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2072:5): [True: 9.37k, False: 33.0k] ------------------ 2073| 9.37k| return false; 2074| 33.0k| encoder->protected_->max_lpc_order = value; 2075| | return true; 2076| 42.4k|} FLAC__stream_encoder_set_qlp_coeff_precision: 2079| 42.3k|{ 2080| 42.3k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 42.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.3k] | | ------------------ ------------------ 2081| 42.3k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 42.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.3k] | | ------------------ ------------------ 2082| 42.3k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 42.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.3k] | | ------------------ ------------------ 2083| 42.3k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2083:5): [True: 9.37k, False: 32.9k] ------------------ 2084| 9.37k| return false; 2085| 32.9k| encoder->protected_->qlp_coeff_precision = value; 2086| | return true; 2087| 42.3k|} FLAC__stream_encoder_set_do_qlp_coeff_prec_search: 2090| 42.5k|{ 2091| 42.5k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 42.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.5k] | | ------------------ ------------------ 2092| 42.5k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 42.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.5k] | | ------------------ ------------------ 2093| 42.5k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 42.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.5k] | | ------------------ ------------------ 2094| 42.5k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2094:5): [True: 9.37k, False: 33.1k] ------------------ 2095| 9.37k| return false; 2096| 33.1k| encoder->protected_->do_qlp_coeff_prec_search = value; 2097| | return true; 2098| 42.5k|} FLAC__stream_encoder_set_do_escape_coding: 2101| 42.2k|{ 2102| 42.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2103| 42.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2104| 42.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2105| 42.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2105:5): [True: 9.37k, False: 32.9k] ------------------ 2106| 9.37k| return false; 2107| 32.9k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2108| | /* was deprecated since FLAC 1.0.4 (24-Sep-2002), but is needed for 2109| | * full spec coverage, so this should be reenabled at some point. 2110| | * For now only enable while fuzzing */ 2111| 32.9k| encoder->protected_->do_escape_coding = value; 2112| |#else 2113| | (void)value; 2114| |#endif 2115| | return true; 2116| 42.2k|} FLAC__stream_encoder_set_do_exhaustive_model_search: 2119| 44.1k|{ 2120| 44.1k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.1k] | | ------------------ ------------------ 2121| 44.1k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.1k] | | ------------------ ------------------ 2122| 44.1k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.1k] | | ------------------ ------------------ 2123| 44.1k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2123:5): [True: 9.37k, False: 34.8k] ------------------ 2124| 9.37k| return false; 2125| 34.8k| encoder->protected_->do_exhaustive_model_search = value; 2126| | return true; 2127| 44.1k|} FLAC__stream_encoder_set_min_residual_partition_order: 2130| 42.2k|{ 2131| 42.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2132| 42.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2133| 42.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2134| 42.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2134:5): [True: 9.37k, False: 32.9k] ------------------ 2135| 9.37k| return false; 2136| 32.9k| encoder->protected_->min_residual_partition_order = value; 2137| | return true; 2138| 42.2k|} FLAC__stream_encoder_set_max_residual_partition_order: 2141| 42.2k|{ 2142| 42.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2143| 42.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2144| 42.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2145| 42.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2145:5): [True: 9.37k, False: 32.8k] ------------------ 2146| 9.37k| return false; 2147| 32.8k| encoder->protected_->max_residual_partition_order = value; 2148| | return true; 2149| 42.2k|} FLAC__stream_encoder_set_num_threads: 2152| 19.0k|{ 2153| 19.0k|#ifdef FLAC__USE_THREADS 2154| 19.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 2155| 19.0k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 2156| 19.0k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 2157| | 2158| 19.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2158:5): [True: 9.37k, False: 9.68k] ------------------ 2159| 9.37k| return FLAC__STREAM_ENCODER_SET_NUM_THREADS_ALREADY_INITIALIZED; ------------------ | | 293| 9.37k|#define FLAC__STREAM_ENCODER_SET_NUM_THREADS_ALREADY_INITIALIZED 2 ------------------ 2160| 9.68k| if(value > FLAC__STREAM_ENCODER_MAX_THREADS) ------------------ | | 46| 9.68k|#define FLAC__STREAM_ENCODER_MAX_THREADS 16 ------------------ | Branch (2160:5): [True: 8.51k, False: 1.16k] ------------------ 2161| 8.51k| return FLAC__STREAM_ENCODER_SET_NUM_THREADS_TOO_MANY_THREADS; ------------------ | | 294| 8.51k|#define FLAC__STREAM_ENCODER_SET_NUM_THREADS_TOO_MANY_THREADS 3 ------------------ 2162| 1.16k| if(value == 0) ------------------ | Branch (2162:5): [True: 344, False: 825] ------------------ 2163| 344| encoder->protected_->num_threads = 1; 2164| 825| else 2165| 825| encoder->protected_->num_threads = value; 2166| 1.16k| return FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK; ------------------ | | 291| 1.16k|#define FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK 0 ------------------ 2167| |#else 2168| | (void)encoder; 2169| | (void)value; 2170| | return FLAC__STREAM_ENCODER_SET_NUM_THREADS_NOT_COMPILED_WITH_MULTITHREADING_ENABLED; 2171| |#endif 2172| 9.68k|} FLAC__stream_encoder_set_rice_parameter_search_dist: 2175| 42.2k|{ 2176| 42.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2177| 42.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2178| 42.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 42.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.2k] | | ------------------ ------------------ 2179| 42.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2179:5): [True: 9.37k, False: 32.8k] ------------------ 2180| 9.37k| return false; 2181| |#if 0 2182| | /*@@@ deprecated: */ 2183| | encoder->protected_->rice_parameter_search_dist = value; 2184| |#else 2185| 32.8k| (void)value; 2186| 32.8k|#endif 2187| | return true; 2188| 42.2k|} FLAC__stream_encoder_set_total_samples_estimate: 2191| 19.1k|{ 2192| 19.1k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 2193| 19.1k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 2194| 19.1k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.1k] | | ------------------ ------------------ 2195| 19.1k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2195:5): [True: 9.37k, False: 9.78k] ------------------ 2196| 9.37k| return false; 2197| 9.78k| value = flac_min(value, (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN) - 1); ------------------ | | 56| 9.78k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (2197:10): [True: 664, False: 9.12k] ------------------ 2198| 9.78k| encoder->protected_->total_samples_estimate = value; 2199| | return true; 2200| 19.1k|} FLAC__stream_encoder_set_limit_min_bitrate: 2235| 19.0k|{ 2236| 19.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 2237| 19.0k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 2238| 19.0k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.0k] | | ------------------ ------------------ 2239| 19.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2239:5): [True: 9.37k, False: 9.69k] ------------------ 2240| 9.37k| return false; 2241| 9.69k| encoder->protected_->limit_min_bitrate = value; 2242| | return true; 2243| 19.0k|} FLAC__stream_encoder_get_verify_decoder_state: 2308| 212k|{ 2309| 212k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 212k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 212k] | | ------------------ ------------------ 2310| 212k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 212k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 212k] | | ------------------ ------------------ 2311| 212k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 212k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 212k] | | ------------------ ------------------ 2312| 212k| if(encoder->protected_->verify) ------------------ | Branch (2312:5): [True: 212k, False: 0] ------------------ 2313| 212k| if(encoder->private_->verify.decoder == NULL) ------------------ | Branch (2313:6): [True: 0, False: 212k] ------------------ 2314| 0| return FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 2315| 212k| else 2316| 212k| return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder); 2317| 0| else 2318| 0| return FLAC__STREAM_DECODER_UNINITIALIZED; 2319| 212k|} FLAC__stream_encoder_get_verify: 2354| 9.37k|{ 2355| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2356| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2357| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2358| 9.37k| return encoder->protected_->verify; 2359| 9.37k|} FLAC__stream_encoder_get_streamable_subset: 2362| 9.37k|{ 2363| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2364| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2365| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2366| 9.37k| return encoder->protected_->streamable_subset; 2367| 9.37k|} FLAC__stream_encoder_get_channels: 2378| 9.37k|{ 2379| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2380| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2381| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2382| 9.37k| return encoder->protected_->channels; 2383| 9.37k|} FLAC__stream_encoder_get_bits_per_sample: 2386| 405k|{ 2387| 405k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 405k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 405k] | | ------------------ ------------------ 2388| 405k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 405k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 405k] | | ------------------ ------------------ 2389| 405k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 405k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 405k] | | ------------------ ------------------ 2390| 405k| return encoder->protected_->bits_per_sample; 2391| 405k|} FLAC__stream_encoder_get_sample_rate: 2394| 9.37k|{ 2395| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2396| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2397| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2398| 9.37k| return encoder->protected_->sample_rate; 2399| 9.37k|} FLAC__stream_encoder_get_blocksize: 2402| 9.37k|{ 2403| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2404| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2405| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2406| 9.37k| return encoder->protected_->blocksize; 2407| 9.37k|} FLAC__stream_encoder_get_do_mid_side_stereo: 2410| 9.37k|{ 2411| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2412| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2413| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2414| 9.37k| return encoder->protected_->do_mid_side_stereo; 2415| 9.37k|} FLAC__stream_encoder_get_loose_mid_side_stereo: 2418| 9.37k|{ 2419| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2420| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2421| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2422| 9.37k| return encoder->protected_->loose_mid_side_stereo; 2423| 9.37k|} FLAC__stream_encoder_get_max_lpc_order: 2426| 9.37k|{ 2427| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2428| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2429| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2430| 9.37k| return encoder->protected_->max_lpc_order; 2431| 9.37k|} FLAC__stream_encoder_get_qlp_coeff_precision: 2434| 9.37k|{ 2435| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2436| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2437| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2438| 9.37k| return encoder->protected_->qlp_coeff_precision; 2439| 9.37k|} FLAC__stream_encoder_get_do_qlp_coeff_prec_search: 2442| 9.37k|{ 2443| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2444| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2445| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2446| 9.37k| return encoder->protected_->do_qlp_coeff_prec_search; 2447| 9.37k|} FLAC__stream_encoder_get_do_escape_coding: 2450| 9.37k|{ 2451| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2452| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2453| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2454| 9.37k| return encoder->protected_->do_escape_coding; 2455| 9.37k|} FLAC__stream_encoder_get_do_exhaustive_model_search: 2458| 9.37k|{ 2459| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2460| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2461| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2462| 9.37k| return encoder->protected_->do_exhaustive_model_search; 2463| 9.37k|} FLAC__stream_encoder_get_min_residual_partition_order: 2466| 9.37k|{ 2467| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2468| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2469| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2470| 9.37k| return encoder->protected_->min_residual_partition_order; 2471| 9.37k|} FLAC__stream_encoder_get_num_threads: 2474| 9.37k|{ 2475| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2476| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2477| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2478| 9.37k| return encoder->protected_->num_threads; 2479| 9.37k|} FLAC__stream_encoder_get_max_residual_partition_order: 2482| 9.37k|{ 2483| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2484| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2485| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2486| 9.37k| return encoder->protected_->max_residual_partition_order; 2487| 9.37k|} FLAC__stream_encoder_get_rice_parameter_search_dist: 2490| 9.37k|{ 2491| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2492| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2493| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2494| 9.37k| return encoder->protected_->rice_parameter_search_dist; 2495| 9.37k|} FLAC__stream_encoder_get_total_samples_estimate: 2498| 9.37k|{ 2499| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2500| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2501| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2502| 9.37k| return encoder->protected_->total_samples_estimate; 2503| 9.37k|} FLAC__stream_encoder_get_limit_min_bitrate: 2506| 9.37k|{ 2507| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2508| 9.37k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2509| 9.37k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2510| 9.37k| return encoder->protected_->limit_min_bitrate; 2511| 9.37k|} FLAC__stream_encoder_process_interleaved: 2571| 178k|{ 2572| 178k| uint32_t i, j, k, channel; 2573| 178k| uint32_t channels; 2574| 178k| uint32_t blocksize; 2575| 178k| FLAC__int32 sample_max; 2576| 178k| FLAC__int32 sample_min; 2577| | 2578| 178k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 178k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 178k] | | ------------------ ------------------ 2579| 178k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 178k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 178k] | | ------------------ ------------------ 2580| 178k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 178k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 178k] | | ------------------ ------------------ 2581| | 2582| 178k| channels = encoder->protected_->channels; 2583| 178k| blocksize = encoder->protected_->blocksize; 2584| 178k| sample_max = INT32_MAX >> (32 - encoder->protected_->bits_per_sample); 2585| 178k| sample_min = INT32_MIN >> (32 - encoder->protected_->bits_per_sample); 2586| | 2587| 178k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK) ------------------ | Branch (2587:5): [True: 1.03k, False: 177k] ------------------ 2588| 1.03k| return false; 2589| | 2590| 177k| j = k = 0; 2591| 411k| do { 2592| 411k| if(encoder->protected_->verify) ------------------ | Branch (2592:6): [True: 368k, False: 43.2k] ------------------ 2593| 368k| append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j)); ------------------ | | 56| 368k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (2593:99): [True: 193k, False: 174k] ------------------ 2594| | 2595| | /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */ 2596| 23.3M| for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) { ------------------ | Branch (2596:53): [True: 23.1M, False: 236k] | Branch (2596:71): [True: 22.9M, False: 175k] ------------------ 2597| 51.8M| for(channel = 0; channel < channels; channel++){ ------------------ | Branch (2597:21): [True: 28.8M, False: 22.9M] ------------------ 2598| 28.8M| if(buffer[k] < sample_min || buffer[k] > sample_max){ ------------------ | Branch (2598:8): [True: 4, False: 28.8M] | Branch (2598:34): [True: 71, False: 28.8M] ------------------ 2599| 75| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2600| 75| return false; 2601| 75| } 2602| 28.8M| encoder->private_->threadtask[0]->integer_signal[channel][i] = buffer[k++]; 2603| 28.8M| } 2604| 22.9M| } 2605| 411k| encoder->private_->current_sample_number = i; 2606| | /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */ 2607| 411k| if(i > blocksize) { ------------------ | Branch (2607:6): [True: 236k, False: 175k] ------------------ 2608| 236k| if(!process_frame_(encoder, /*is_last_block=*/false)) ------------------ | Branch (2608:7): [True: 0, False: 236k] ------------------ 2609| 0| return false; 2610| | /* move unprocessed overread samples to beginnings of arrays */ 2611| 236k| FLAC__ASSERT(i == blocksize+OVERREAD_); ------------------ | | 38| 236k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 236k] | | ------------------ ------------------ 2612| 236k| FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */ ------------------ | | 38| 236k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 236k] | | ------------------ ------------------ 2613| 536k| for(channel = 0; channel < channels; channel++) ------------------ | Branch (2613:21): [True: 299k, False: 236k] ------------------ 2614| 299k| encoder->private_->threadtask[0]->integer_signal[channel][0] = encoder->private_->threadtask[0]->integer_signal[channel][blocksize]; 2615| 236k| encoder->private_->current_sample_number = 1; 2616| 236k| } 2617| 411k| } while(j < samples); ------------------ | Branch (2617:10): [True: 234k, False: 177k] ------------------ 2618| | 2619| 177k| return true; 2620| 177k|} process_frame_thread_: 3627| 2.72k|FLAC__thread_return_type process_frame_thread_(void * args) { 3628| 2.72k| FLAC__StreamEncoder * encoder = args; 3629| 2.72k| uint32_t channel; 3630| | 3631| 2.72k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 2.72k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3632| 2.72k| encoder->private_->num_running_threads++; 3633| 2.72k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 2.72k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3634| | 3635| 143k| while(1) { ------------------ | Branch (3635:8): [True: 143k, Folded] ------------------ 3636| 143k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 143k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3637| 143k| if(encoder->private_->finish_work_threads) { ------------------ | Branch (3637:6): [True: 75, False: 143k] ------------------ 3638| 75| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 75|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3639| 75| return FLAC__thread_default_return_value; ------------------ | | 117| 75|#define FLAC__thread_default_return_value NULL ------------------ 3640| 75| } 3641| | /* The code below pauses and restarts threads if it is noticed threads are often put too sleep 3642| | * because of a lack of work. This reduces overhead when too many threads are active. The 3643| | * overcommited indicator is increased when no tasks are available, decreased when more tasks 3644| | * are available then threads are running, and reset when a thread is woken up or put to sleep */ 3645| 143k| if(encoder->private_->num_available_threadtasks == 0) ------------------ | Branch (3645:6): [True: 32.2k, False: 111k] ------------------ 3646| 32.2k| encoder->private_->overcommitted_indicator++; 3647| 111k| else if(encoder->private_->num_available_threadtasks > encoder->private_->num_running_threads) ------------------ | Branch (3647:11): [True: 43.3k, False: 67.8k] ------------------ 3648| 43.3k| encoder->private_->overcommitted_indicator--; 3649| 143k| if(encoder->private_->overcommitted_indicator < -20) { ------------------ | Branch (3649:6): [True: 1.36k, False: 142k] ------------------ 3650| 1.36k| encoder->private_->overcommitted_indicator = 0; 3651| 1.36k| FLAC__cnd_signal(&encoder->private_->cond_wake_up_thread); ------------------ | | 112| 1.36k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3652| 1.36k| } 3653| 142k| else if(encoder->private_->overcommitted_indicator > 20 && encoder->private_->num_running_threads > 2) { ------------------ | Branch (3653:11): [True: 4.72k, False: 137k] | Branch (3653:62): [True: 783, False: 3.93k] ------------------ 3654| 783| encoder->private_->overcommitted_indicator = 0; 3655| 783| encoder->private_->num_running_threads--; 3656| 783| FLAC__cnd_wait(&encoder->private_->cond_wake_up_thread, &encoder->private_->mutex_work_queue); ------------------ | | 113| 783|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3657| 783| encoder->private_->num_running_threads++; 3658| 783| } 3659| 185k| while(encoder->private_->num_available_threadtasks == 0 && (encoder->private_->md5_active || encoder->private_->md5_fifo.tail == 0)) { ------------------ | Branch (3659:9): [True: 50.4k, False: 134k] | Branch (3659:63): [True: 17.8k, False: 32.5k] | Branch (3659:96): [True: 26.3k, False: 6.14k] ------------------ 3660| 44.2k| if(encoder->private_->finish_work_threads) { ------------------ | Branch (3660:7): [True: 2.65k, False: 41.6k] ------------------ 3661| 2.65k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 2.65k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3662| 2.65k| return FLAC__thread_default_return_value; ------------------ | | 117| 2.65k|#define FLAC__thread_default_return_value NULL ------------------ 3663| 2.65k| } 3664| 41.6k| FLAC__cnd_wait(&encoder->private_->cond_work_available, &encoder->private_->mutex_work_queue); ------------------ | | 113| 41.6k|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3665| 41.6k| } 3666| 141k| if(encoder->protected_->do_md5 && !encoder->private_->md5_active && encoder->private_->md5_fifo.tail > 0) { ------------------ | Branch (3666:6): [True: 141k, False: 18.4E] | Branch (3666:37): [True: 114k, False: 26.6k] | Branch (3666:71): [True: 47.8k, False: 66.7k] ------------------ 3667| 47.8k| uint32_t length = 0; 3668| 47.8k| encoder->private_->md5_active = true; 3669| 108k| while(encoder->private_->md5_fifo.tail > 0) { ------------------ | Branch (3669:10): [True: 60.1k, False: 47.8k] ------------------ 3670| 60.1k| length = encoder->private_->md5_fifo.tail; 3671| 60.1k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 60.1k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3672| 60.1k| if(!FLAC__MD5Accumulate(&encoder->private_->md5context, (const FLAC__int32 * const *)encoder->private_->md5_fifo.data, encoder->protected_->channels, length, (encoder->protected_->bits_per_sample+7) / 8)) { ------------------ | Branch (3672:8): [True: 0, False: 60.1k] ------------------ 3673| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3674| 0| return FLAC__thread_default_return_value; ------------------ | | 117| 0|#define FLAC__thread_default_return_value NULL ------------------ 3675| 0| } 3676| 60.1k| FLAC__mtx_lock(&encoder->private_->mutex_md5_fifo); ------------------ | | 105| 60.1k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3677| 121k| for(channel = 0; channel < encoder->protected_->channels; channel++) ------------------ | Branch (3677:22): [True: 61.8k, False: 60.1k] ------------------ 3678| 61.8k| memmove(&encoder->private_->md5_fifo.data[channel][0], &encoder->private_->md5_fifo.data[channel][length], (encoder->private_->md5_fifo.tail-length) * sizeof(encoder->private_->md5_fifo.data[0][0])); 3679| 60.1k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 60.1k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3680| 60.1k| encoder->private_->md5_fifo.tail -= length; 3681| 60.1k| FLAC__cnd_signal(&encoder->private_->cond_md5_emptied); ------------------ | | 112| 60.1k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3682| 60.1k| FLAC__mtx_unlock(&encoder->private_->mutex_md5_fifo); ------------------ | | 106| 60.1k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3683| 60.1k| } 3684| 47.8k| encoder->private_->md5_active = false; 3685| 47.8k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 47.8k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3686| 47.8k| } 3687| 93.3k| else if(encoder->private_->num_available_threadtasks > 0) { ------------------ | Branch (3687:11): [True: 93.3k, False: 18.4E] ------------------ 3688| 93.3k| FLAC__StreamEncoderThreadTask * task = NULL; 3689| 93.3k| task = encoder->private_->threadtask[encoder->private_->next_threadtask]; 3690| 93.3k| encoder->private_->num_available_threadtasks--; 3691| 93.3k| encoder->private_->next_threadtask++; 3692| 93.3k| if(encoder->private_->next_threadtask == encoder->private_->num_threadtasks) ------------------ | Branch (3692:7): [True: 9.55k, False: 83.8k] ------------------ 3693| 9.55k| encoder->private_->next_threadtask = 1; 3694| 93.3k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 93.3k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3695| 93.3k| FLAC__mtx_lock(&task->mutex_this_task); ------------------ | | 105| 93.3k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3696| 93.3k| if(!process_frame_thread_inner_(encoder, task)) ------------------ | Branch (3696:7): [True: 0, False: 93.3k] ------------------ 3697| 0| return FLAC__thread_default_return_value; ------------------ | | 117| 0|#define FLAC__thread_default_return_value NULL ------------------ 3698| 93.3k| } 3699| 18.4E| else { 3700| 18.4E| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 18.4E|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3701| 18.4E| } 3702| 140k| } 3703| 2.72k|} process_frame_thread_inner_: 3705| 105k|FLAC__bool process_frame_thread_inner_(FLAC__StreamEncoder * encoder, FLAC__StreamEncoderThreadTask * task) { 3706| 105k| FLAC__bool ok = true; 3707| 105k| FLAC__uint16 crc; 3708| | 3709| | /* 3710| | * Process the frame header and subframes into the frame bitbuffer 3711| | */ 3712| 105k| if(ok && !process_subframes_(encoder, task)) { ------------------ | Branch (3712:5): [True: 105k, False: 39] | Branch (3712:11): [True: 0, False: 105k] ------------------ 3713| | /* the above function sets the state for us in case of an error */ 3714| 0| ok = false; 3715| 0| } 3716| | 3717| | /* 3718| | * Zero-pad the frame to a byte_boundary 3719| | */ 3720| 105k| if(ok && !FLAC__bitwriter_zero_pad_to_byte_boundary(task->frame)) { ------------------ | Branch (3720:5): [True: 103k, False: 1.61k] | Branch (3720:11): [True: 0, False: 103k] ------------------ 3721| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3722| 0| ok = false; 3723| 0| } 3724| | 3725| | /* 3726| | * CRC-16 the whole thing 3727| | */ 3728| 105k| FLAC__ASSERT(!ok || FLAC__bitwriter_is_byte_aligned(task->frame)); ------------------ | | 38| 208k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 1.85k, False: 103k] | | | Branch (38:30): [True: 103k, False: 0] | | ------------------ ------------------ 3729| 105k| if( 3730| 105k| ok && ------------------ | Branch (3730:3): [True: 103k, False: 1.97k] ------------------ 3731| 103k| ( 3732| 103k| !FLAC__bitwriter_get_write_crc16(task->frame, &crc) || ------------------ | Branch (3732:4): [True: 18.4E, False: 103k] ------------------ 3733| 103k| !FLAC__bitwriter_write_raw_uint32(task->frame, crc, FLAC__FRAME_FOOTER_CRC_LEN) ------------------ | Branch (3733:4): [True: 181, False: 103k] ------------------ 3734| 103k| ) 3735| 105k| ) { 3736| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3737| 0| ok = false; 3738| 0| } 3739| 105k| task->returnvalue = ok; 3740| 105k| task->task_done = true; 3741| 105k| FLAC__cnd_signal(&task->cond_task_done); ------------------ | | 112| 105k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3742| 105k| FLAC__mtx_unlock(&task->mutex_this_task); ------------------ | | 106| 105k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3743| | return true; 3744| 105k|} stream_encoder.c:init_stream_internal_: 717| 9.64k|{ 718| 9.64k| uint32_t i, t; 719| 9.64k| FLAC__bool metadata_has_seektable, metadata_has_vorbis_comment, metadata_picture_has_type1, metadata_picture_has_type2; 720| | 721| 9.64k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.64k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.64k] | | ------------------ ------------------ 722| | 723| 9.64k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (723:5): [True: 0, False: 9.64k] ------------------ 724| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED; 725| | 726| 9.64k| if(FLAC__HAS_OGG == 0 && is_ogg) ------------------ | | 45| 9.64k|#define FLAC__HAS_OGG 1 ------------------ | Branch (726:5): [Folded, False: 9.64k] | Branch (726:27): [True: 0, False: 0] ------------------ 727| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER; 728| | 729| 9.64k| if(0 == write_callback || (seek_callback && 0 == tell_callback)) ------------------ | Branch (729:5): [True: 0, False: 9.64k] | Branch (729:29): [True: 9.64k, False: 0] | Branch (729:46): [True: 0, False: 9.64k] ------------------ 730| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS; 731| | 732| 9.64k| if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS) ------------------ | | 106| 9.63k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (732:5): [True: 3, False: 9.63k] | Branch (732:43): [True: 10, False: 9.62k] ------------------ 733| 13| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS; 734| | 735| 9.62k| if(encoder->protected_->channels != 2) { ------------------ | Branch (735:5): [True: 6.55k, False: 3.07k] ------------------ 736| 6.55k| encoder->protected_->do_mid_side_stereo = false; 737| 6.55k| encoder->protected_->loose_mid_side_stereo = false; 738| 6.55k| } 739| 3.07k| else if(!encoder->protected_->do_mid_side_stereo) ------------------ | Branch (739:10): [True: 97, False: 2.97k] ------------------ 740| 97| encoder->protected_->loose_mid_side_stereo = false; 741| | 742| 9.62k| if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__MAX_BITS_PER_SAMPLE) ------------------ | | 109| 19.2k|#define FLAC__MIN_BITS_PER_SAMPLE (4u) ------------------ if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__MAX_BITS_PER_SAMPLE) ------------------ | | 112| 9.62k|#define FLAC__MAX_BITS_PER_SAMPLE (32u) ------------------ | Branch (742:5): [True: 2, False: 9.62k] | Branch (742:73): [True: 6, False: 9.61k] ------------------ 743| 8| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE; 744| | 745| 9.61k| if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate)) ------------------ | Branch (745:5): [True: 47, False: 9.57k] ------------------ 746| 47| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE; 747| | 748| 9.57k| if(encoder->protected_->blocksize == 0) { ------------------ | Branch (748:5): [True: 703, False: 8.86k] ------------------ 749| 703| if(encoder->protected_->max_lpc_order == 0) ------------------ | Branch (749:6): [True: 125, False: 578] ------------------ 750| 125| encoder->protected_->blocksize = 1152; 751| 578| else 752| 578| encoder->protected_->blocksize = 4096; 753| 703| } 754| | 755| 9.57k| if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE) ------------------ | | 96| 19.1k|#define FLAC__MIN_BLOCK_SIZE (16u) ------------------ if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE) ------------------ | | 99| 9.56k|#define FLAC__MAX_BLOCK_SIZE (65535u) ------------------ | Branch (755:5): [True: 3, False: 9.56k] | Branch (755:62): [True: 0, False: 9.56k] ------------------ 756| 3| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE; 757| | 758| 9.56k| if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER) ------------------ | | 128| 9.56k|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (758:5): [True: 3, False: 9.56k] ------------------ 759| 3| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER; 760| | 761| 9.56k| if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order) ------------------ | Branch (761:5): [True: 1, False: 9.56k] ------------------ 762| 1| return FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER; 763| | 764| 9.56k| if(encoder->protected_->qlp_coeff_precision == 0) { ------------------ | Branch (764:5): [True: 7.09k, False: 2.47k] ------------------ 765| 7.09k| if(encoder->protected_->bits_per_sample < 16) { ------------------ | Branch (765:6): [True: 587, False: 6.50k] ------------------ 766| | /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */ 767| | /* @@@ until then we'll make a guess */ 768| 587| encoder->protected_->qlp_coeff_precision = flac_max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2); ------------------ | | 55| 587|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (768:47): [True: 177, False: 410] ------------------ 769| 587| } 770| 6.50k| else if(encoder->protected_->bits_per_sample == 16) { ------------------ | Branch (770:11): [True: 551, False: 5.95k] ------------------ 771| 551| if(encoder->protected_->blocksize <= 192) ------------------ | Branch (771:7): [True: 211, False: 340] ------------------ 772| 211| encoder->protected_->qlp_coeff_precision = 7; 773| 340| else if(encoder->protected_->blocksize <= 384) ------------------ | Branch (773:12): [True: 25, False: 315] ------------------ 774| 25| encoder->protected_->qlp_coeff_precision = 8; 775| 315| else if(encoder->protected_->blocksize <= 576) ------------------ | Branch (775:12): [True: 15, False: 300] ------------------ 776| 15| encoder->protected_->qlp_coeff_precision = 9; 777| 300| else if(encoder->protected_->blocksize <= 1152) ------------------ | Branch (777:12): [True: 30, False: 270] ------------------ 778| 30| encoder->protected_->qlp_coeff_precision = 10; 779| 270| else if(encoder->protected_->blocksize <= 2304) ------------------ | Branch (779:12): [True: 19, False: 251] ------------------ 780| 19| encoder->protected_->qlp_coeff_precision = 11; 781| 251| else if(encoder->protected_->blocksize <= 4608) ------------------ | Branch (781:12): [True: 64, False: 187] ------------------ 782| 64| encoder->protected_->qlp_coeff_precision = 12; 783| 187| else 784| 187| encoder->protected_->qlp_coeff_precision = 13; 785| 551| } 786| 5.95k| else { 787| 5.95k| if(encoder->protected_->blocksize <= 384) ------------------ | Branch (787:7): [True: 2.13k, False: 3.82k] ------------------ 788| 2.13k| encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2; ------------------ | | 142| 2.13k|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 789| 3.82k| else if(encoder->protected_->blocksize <= 1152) ------------------ | Branch (789:12): [True: 251, False: 3.57k] ------------------ 790| 251| encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1; ------------------ | | 142| 251|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 791| 3.57k| else 792| 3.57k| encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; ------------------ | | 142| 3.57k|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 793| 5.95k| } 794| 7.09k| FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION); ------------------ | | 38| 7.09k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 7.09k] | | ------------------ ------------------ 795| 7.09k| } 796| 2.47k| else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION) ------------------ | | 137| 4.94k|#define FLAC__MIN_QLP_COEFF_PRECISION (5u) ------------------ else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION) ------------------ | | 142| 2.47k|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ | Branch (796:10): [True: 2, False: 2.47k] | Branch (796:86): [True: 57, False: 2.41k] ------------------ 797| 59| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION; 798| | 799| 9.50k| if(encoder->protected_->streamable_subset) { ------------------ | Branch (799:5): [True: 668, False: 8.83k] ------------------ 800| 668| if(!FLAC__format_blocksize_is_subset(encoder->protected_->blocksize, encoder->protected_->sample_rate)) ------------------ | Branch (800:6): [True: 14, False: 654] ------------------ 801| 14| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 802| 654| if(!FLAC__format_sample_rate_is_subset(encoder->protected_->sample_rate)) ------------------ | Branch (802:6): [True: 45, False: 609] ------------------ 803| 45| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 804| 609| if( 805| 609| encoder->protected_->bits_per_sample != 8 && ------------------ | Branch (805:4): [True: 575, False: 34] ------------------ 806| 575| encoder->protected_->bits_per_sample != 12 && ------------------ | Branch (806:4): [True: 567, False: 8] ------------------ 807| 567| encoder->protected_->bits_per_sample != 16 && ------------------ | Branch (807:4): [True: 478, False: 89] ------------------ 808| 478| encoder->protected_->bits_per_sample != 20 && ------------------ | Branch (808:4): [True: 472, False: 6] ------------------ 809| 472| encoder->protected_->bits_per_sample != 24 && ------------------ | Branch (809:4): [True: 426, False: 46] ------------------ 810| 426| encoder->protected_->bits_per_sample != 32 ------------------ | Branch (810:4): [True: 14, False: 412] ------------------ 811| 609| ) 812| 14| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 813| 595| if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER) ------------------ | | 151| 595|#define FLAC__SUBSET_MAX_RICE_PARTITION_ORDER (8u) ------------------ | Branch (813:6): [True: 54, False: 541] ------------------ 814| 54| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 815| 541| if( 816| 541| encoder->protected_->sample_rate <= 48000 && ------------------ | Branch (816:4): [True: 237, False: 304] ------------------ 817| 237| ( 818| 237| encoder->protected_->blocksize > FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ || ------------------ | | 103| 474|#define FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ (4608u) ------------------ | Branch (818:5): [True: 0, False: 237] ------------------ 819| 237| encoder->protected_->max_lpc_order > FLAC__SUBSET_MAX_LPC_ORDER_48000HZ ------------------ | | 132| 237|#define FLAC__SUBSET_MAX_LPC_ORDER_48000HZ (12u) ------------------ | Branch (819:5): [True: 4, False: 233] ------------------ 820| 237| ) 821| 541| ) { 822| 4| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 823| 4| } 824| 541| } 825| | 826| 9.37k| if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) ------------------ | Branch (826:5): [True: 6.73k, False: 2.64k] ------------------ 827| 6.73k| encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1; 828| 9.37k| if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order) ------------------ | Branch (828:5): [True: 8.55k, False: 817] ------------------ 829| 8.55k| encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order; 830| | 831| 9.37k|#if FLAC__HAS_OGG 832| | /* drop any seektable for ogg */ 833| 9.37k| if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) { ------------------ | Branch (833:5): [True: 2.89k, False: 6.48k] | Branch (833:15): [True: 0, False: 2.89k] | Branch (833:53): [True: 0, False: 0] ------------------ 834| 0| uint32_t i1; 835| 0| for(i1 = 0; i1 < encoder->protected_->num_metadata_blocks; i1++) { ------------------ | Branch (835:15): [True: 0, False: 0] ------------------ 836| 0| if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_SEEKTABLE) { ------------------ | Branch (836:7): [True: 0, False: 0] | Branch (836:49): [True: 0, False: 0] ------------------ 837| 0| encoder->protected_->num_metadata_blocks--; 838| 0| for( ; i1 < encoder->protected_->num_metadata_blocks; i1++) ------------------ | Branch (838:12): [True: 0, False: 0] ------------------ 839| 0| encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1+1]; 840| 0| break; 841| 0| } 842| 0| } 843| 0| } 844| | /* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */ 845| 9.37k| if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) { ------------------ | Branch (845:5): [True: 2.89k, False: 6.48k] | Branch (845:15): [True: 0, False: 2.89k] | Branch (845:53): [True: 0, False: 0] ------------------ 846| 0| uint32_t i1; 847| 0| for(i1 = 1; i1 < encoder->protected_->num_metadata_blocks; i1++) { ------------------ | Branch (847:15): [True: 0, False: 0] ------------------ 848| 0| if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) { ------------------ | Branch (848:7): [True: 0, False: 0] | Branch (848:49): [True: 0, False: 0] ------------------ 849| 0| FLAC__StreamMetadata *vc = encoder->protected_->metadata[i1]; 850| 0| for( ; i1 > 0; i1--) ------------------ | Branch (850:12): [True: 0, False: 0] ------------------ 851| 0| encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1-1]; 852| 0| encoder->protected_->metadata[0] = vc; 853| 0| break; 854| 0| } 855| 0| } 856| 0| } 857| 9.37k|#endif 858| | /* keep track of any SEEKTABLE block */ 859| 9.37k| if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) { ------------------ | Branch (859:5): [True: 0, False: 9.37k] | Branch (859:43): [True: 0, False: 0] ------------------ 860| 0| uint32_t i2; 861| 0| for(i2 = 0; i2 < encoder->protected_->num_metadata_blocks; i2++) { ------------------ | Branch (861:15): [True: 0, False: 0] ------------------ 862| 0| if(0 != encoder->protected_->metadata[i2] && encoder->protected_->metadata[i2]->type == FLAC__METADATA_TYPE_SEEKTABLE) { ------------------ | Branch (862:7): [True: 0, False: 0] | Branch (862:49): [True: 0, False: 0] ------------------ 863| 0| encoder->private_->seek_table = &encoder->protected_->metadata[i2]->data.seek_table; 864| 0| break; /* take only the first one */ 865| 0| } 866| 0| } 867| 0| } 868| | 869| | /* validate metadata */ 870| 9.37k| if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) ------------------ | Branch (870:5): [True: 9.37k, False: 0] | Branch (870:43): [True: 0, False: 9.37k] ------------------ 871| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 872| 9.37k| metadata_has_seektable = false; 873| 9.37k| metadata_has_vorbis_comment = false; 874| 9.37k| metadata_picture_has_type1 = false; 875| 9.37k| metadata_picture_has_type2 = false; 876| 9.37k| for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { ------------------ | Branch (876:13): [True: 0, False: 9.37k] ------------------ 877| 0| const FLAC__StreamMetadata *m = encoder->protected_->metadata[i]; 878| 0| if(m->type == FLAC__METADATA_TYPE_STREAMINFO) ------------------ | Branch (878:6): [True: 0, False: 0] ------------------ 879| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 880| 0| else if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) { ------------------ | Branch (880:11): [True: 0, False: 0] ------------------ 881| 0| if(metadata_has_seektable) /* only one is allowed */ ------------------ | Branch (881:7): [True: 0, False: 0] ------------------ 882| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 883| 0| metadata_has_seektable = true; 884| 0| if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) ------------------ | Branch (884:7): [True: 0, False: 0] ------------------ 885| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 886| 0| } 887| 0| else if(m->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) { ------------------ | Branch (887:11): [True: 0, False: 0] ------------------ 888| 0| if(metadata_has_vorbis_comment) /* only one is allowed */ ------------------ | Branch (888:7): [True: 0, False: 0] ------------------ 889| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 890| 0| metadata_has_vorbis_comment = true; 891| 0| } 892| 0| else if(m->type == FLAC__METADATA_TYPE_CUESHEET) { ------------------ | Branch (892:11): [True: 0, False: 0] ------------------ 893| 0| if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) ------------------ | Branch (893:7): [True: 0, False: 0] ------------------ 894| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 895| 0| } 896| 0| else if(m->type == FLAC__METADATA_TYPE_PICTURE) { ------------------ | Branch (896:11): [True: 0, False: 0] ------------------ 897| 0| if(!FLAC__format_picture_is_legal(&m->data.picture, /*violation=*/0)) ------------------ | Branch (897:7): [True: 0, False: 0] ------------------ 898| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 899| 0| if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) { ------------------ | Branch (899:7): [True: 0, False: 0] ------------------ 900| 0| if(metadata_picture_has_type1) /* there should only be 1 per stream */ ------------------ | Branch (900:8): [True: 0, False: 0] ------------------ 901| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 902| 0| metadata_picture_has_type1 = true; 903| | /* standard icon must be 32x32 pixel PNG */ 904| 0| if( 905| 0| m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD && ------------------ | Branch (905:6): [True: 0, False: 0] ------------------ 906| 0| ( 907| 0| (strcmp(m->data.picture.mime_type, "image/png") && strcmp(m->data.picture.mime_type, "-->")) || ------------------ | Branch (907:8): [True: 0, False: 0] | Branch (907:58): [True: 0, False: 0] ------------------ 908| 0| m->data.picture.width != 32 || ------------------ | Branch (908:7): [True: 0, False: 0] ------------------ 909| 0| m->data.picture.height != 32 ------------------ | Branch (909:7): [True: 0, False: 0] ------------------ 910| 0| ) 911| 0| ) 912| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 913| 0| } 914| 0| else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) { ------------------ | Branch (914:12): [True: 0, False: 0] ------------------ 915| 0| if(metadata_picture_has_type2) /* there should only be 1 per stream */ ------------------ | Branch (915:8): [True: 0, False: 0] ------------------ 916| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 917| 0| metadata_picture_has_type2 = true; 918| 0| } 919| 0| } 920| 0| } 921| | 922| 9.37k| encoder->private_->input_capacity = 0; 923| 9.37k| encoder->private_->current_sample_number = 0; 924| 9.37k| encoder->private_->current_frame_number = 0; 925| | 926| | /* 927| | * get the CPU info and set the function pointers 928| | */ 929| 9.37k| FLAC__cpu_info(&encoder->private_->cpuinfo); 930| | /* remove cpu info as requested by 931| | * FLAC__stream_encoder_disable_instruction_set */ 932| 9.37k| if(encoder->private_->disable_mmx) ------------------ | Branch (932:5): [True: 0, False: 9.37k] ------------------ 933| 0| encoder->private_->cpuinfo.x86.mmx = false; 934| 9.37k| if(encoder->private_->disable_sse2) ------------------ | Branch (934:5): [True: 0, False: 9.37k] ------------------ 935| 0| encoder->private_->cpuinfo.x86.sse2 = false; 936| 9.37k| if(encoder->private_->disable_ssse3) ------------------ | Branch (936:5): [True: 0, False: 9.37k] ------------------ 937| 0| encoder->private_->cpuinfo.x86.ssse3 = false; 938| 9.37k| if(encoder->private_->disable_sse41) ------------------ | Branch (938:5): [True: 0, False: 9.37k] ------------------ 939| 0| encoder->private_->cpuinfo.x86.sse41 = false; 940| 9.37k| if(encoder->private_->disable_sse42) ------------------ | Branch (940:5): [True: 0, False: 9.37k] ------------------ 941| 0| encoder->private_->cpuinfo.x86.sse42 = false; 942| 9.37k| if(encoder->private_->disable_avx2) ------------------ | Branch (942:5): [True: 0, False: 9.37k] ------------------ 943| 0| encoder->private_->cpuinfo.x86.avx2 = false; 944| 9.37k| if(encoder->private_->disable_fma) ------------------ | Branch (944:5): [True: 0, False: 9.37k] ------------------ 945| 0| encoder->private_->cpuinfo.x86.fma = false; 946| | /* first default to the non-asm routines */ 947| 9.37k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 948| 9.37k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; 949| 9.37k|#endif 950| 9.37k| encoder->private_->local_precompute_partition_info_sums = precompute_partition_info_sums_; 951| 9.37k| encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor; 952| 9.37k| encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide; 953| 9.37k| encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual; 954| 9.37k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 955| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients; 956| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide; 957| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients; 958| 9.37k|#endif 959| | /* now override with asm where appropriate */ 960| 9.37k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 961| 9.37k|# ifndef FLAC__NO_ASM 962| |#if defined FLAC__CPU_ARM64 && FLAC__HAS_NEONINTRIN 963| |#if FLAC__HAS_A64NEONINTRIN 964| | if(encoder->protected_->max_lpc_order < 8) 965| | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_neon_lag_8; 966| | else if(encoder->protected_->max_lpc_order < 10) 967| | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_neon_lag_10; 968| | else if(encoder->protected_->max_lpc_order < 14) 969| | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_neon_lag_14; 970| | else 971| | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; 972| |#endif 973| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_neon; 974| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_neon; 975| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_neon; 976| |#endif /* defined FLAC__CPU_ARM64 && FLAC__HAS_NEONINTRIN */ 977| | 978| 9.37k| if(encoder->private_->cpuinfo.use_asm) { ------------------ | Branch (978:5): [True: 9.37k, False: 0] ------------------ 979| |# ifdef FLAC__CPU_IA32 980| | FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32); 981| |# if FLAC__HAS_X86INTRIN 982| |# ifdef FLAC__SSE2_SUPPORTED 983| | if (encoder->private_->cpuinfo.x86.sse2) { 984| | if(encoder->protected_->max_lpc_order < 8) 985| | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_8; 986| | else if(encoder->protected_->max_lpc_order < 10) 987| | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_10; 988| | else if(encoder->protected_->max_lpc_order < 14) 989| | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_14; 990| | 991| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse2; 992| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2; 993| | } 994| |# endif 995| |# ifdef FLAC__SSE4_1_SUPPORTED 996| | if (encoder->private_->cpuinfo.x86.sse41) { 997| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41; 998| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_sse41; 999| | } 1000| |# endif 1001| |# ifdef FLAC__AVX2_SUPPORTED 1002| | if (encoder->private_->cpuinfo.x86.avx2) { 1003| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2; 1004| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2; 1005| | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2; 1006| | } 1007| |# endif 1008| | 1009| |# ifdef FLAC__SSE2_SUPPORTED 1010| | if (encoder->private_->cpuinfo.x86.sse2) { 1011| | encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2; 1012| | } 1013| |# endif 1014| |# ifdef FLAC__SSSE3_SUPPORTED 1015| | if (encoder->private_->cpuinfo.x86.ssse3) { 1016| | encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3; 1017| | } 1018| |# endif 1019| |# ifdef FLAC__SSE4_2_SUPPORTED 1020| | if (encoder->private_->cpuinfo.x86.sse42) { 1021| | encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_sse42; 1022| | } 1023| |# endif 1024| |# ifdef FLAC__AVX2_SUPPORTED 1025| | if (encoder->private_->cpuinfo.x86.avx2) { 1026| | encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_avx2; 1027| | encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2; 1028| | } 1029| |# endif 1030| |# endif /* FLAC__HAS_X86INTRIN */ 1031| |# elif defined FLAC__CPU_X86_64 1032| 9.37k| FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_X86_64); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 1033| 9.37k|# if FLAC__HAS_X86INTRIN 1034| 9.37k|# ifdef FLAC__SSE2_SUPPORTED 1035| 9.37k| if(encoder->private_->cpuinfo.x86.sse2) { /* For fuzzing */ ------------------ | Branch (1035:6): [True: 9.37k, False: 0] ------------------ 1036| 9.37k| if(encoder->protected_->max_lpc_order < 8) ------------------ | Branch (1036:7): [True: 2.51k, False: 6.86k] ------------------ 1037| 2.51k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_8; 1038| 6.86k| else if(encoder->protected_->max_lpc_order < 10) ------------------ | Branch (1038:12): [True: 407, False: 6.45k] ------------------ 1039| 407| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_10; 1040| 6.45k| else if(encoder->protected_->max_lpc_order < 14) ------------------ | Branch (1040:12): [True: 240, False: 6.21k] ------------------ 1041| 240| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_14; 1042| | 1043| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2; 1044| 9.37k| } 1045| 9.37k|# endif 1046| 9.37k|# ifdef FLAC__SSE4_1_SUPPORTED 1047| 9.37k| if(encoder->private_->cpuinfo.x86.sse41) { ------------------ | Branch (1047:6): [True: 9.37k, False: 0] ------------------ 1048| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41; 1049| 9.37k| } 1050| 9.37k|# endif 1051| 9.37k|# ifdef FLAC__AVX2_SUPPORTED 1052| 9.37k| if(encoder->private_->cpuinfo.x86.avx2) { ------------------ | Branch (1052:6): [True: 9.37k, False: 0] ------------------ 1053| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2; 1054| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2; 1055| 9.37k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2; 1056| 9.37k| } 1057| 9.37k|# endif 1058| 9.37k|# ifdef FLAC__FMA_SUPPORTED 1059| 9.37k| if(encoder->private_->cpuinfo.x86.fma) { ------------------ | Branch (1059:6): [True: 9.37k, False: 0] ------------------ 1060| 9.37k| if(encoder->protected_->max_lpc_order < 8) ------------------ | Branch (1060:7): [True: 2.51k, False: 6.86k] ------------------ 1061| 2.51k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_8; 1062| 6.86k| else if(encoder->protected_->max_lpc_order < 12) ------------------ | Branch (1062:12): [True: 477, False: 6.38k] ------------------ 1063| 477| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_12; 1064| 6.38k| else if(encoder->protected_->max_lpc_order < 16) ------------------ | Branch (1064:12): [True: 1.94k, False: 4.43k] ------------------ 1065| 1.94k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_16; 1066| 9.37k| } 1067| 9.37k|# endif 1068| | 1069| | 1070| 9.37k|# ifdef FLAC__SSE2_SUPPORTED 1071| 9.37k| if(encoder->private_->cpuinfo.x86.sse2) { /* For fuzzing */ ------------------ | Branch (1071:6): [True: 9.37k, False: 0] ------------------ 1072| 9.37k| encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2; 1073| 9.37k| } 1074| 9.37k|# endif 1075| 9.37k|# ifdef FLAC__SSSE3_SUPPORTED 1076| 9.37k| if (encoder->private_->cpuinfo.x86.ssse3) { ------------------ | Branch (1076:7): [True: 9.37k, False: 0] ------------------ 1077| 9.37k| encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3; 1078| 9.37k| } 1079| 9.37k|# endif 1080| 9.37k|# ifdef FLAC__SSE4_2_SUPPORTED 1081| 9.37k| if (encoder->private_->cpuinfo.x86.sse42) { ------------------ | Branch (1081:7): [True: 9.37k, False: 0] ------------------ 1082| 9.37k| encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_sse42; 1083| 9.37k| } 1084| 9.37k|# endif 1085| 9.37k|# ifdef FLAC__AVX2_SUPPORTED 1086| 9.37k| if (encoder->private_->cpuinfo.x86.avx2) { ------------------ | Branch (1086:7): [True: 9.37k, False: 0] ------------------ 1087| 9.37k| encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_avx2; 1088| 9.37k| encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2; 1089| 9.37k| } 1090| 9.37k|# endif 1091| 9.37k|# endif /* FLAC__HAS_X86INTRIN */ 1092| 9.37k|# endif /* FLAC__CPU_... */ 1093| 9.37k| } 1094| 9.37k|# endif /* !FLAC__NO_ASM */ 1095| | 1096| 9.37k|#endif /* !FLAC__INTEGER_ONLY_LIBRARY */ 1097| 9.37k|#if !defined FLAC__NO_ASM && FLAC__HAS_X86INTRIN 1098| 9.37k| if(encoder->private_->cpuinfo.use_asm) { ------------------ | Branch (1098:5): [True: 9.37k, False: 0] ------------------ 1099| 9.37k|# if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) 1100| 9.37k|# ifdef FLAC__SSE2_SUPPORTED 1101| 9.37k| if (encoder->private_->cpuinfo.x86.sse2) ------------------ | Branch (1101:7): [True: 9.37k, False: 0] ------------------ 1102| 9.37k| encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2; 1103| 9.37k|# endif 1104| 9.37k|# ifdef FLAC__SSSE3_SUPPORTED 1105| 9.37k| if (encoder->private_->cpuinfo.x86.ssse3) ------------------ | Branch (1105:7): [True: 9.37k, False: 0] ------------------ 1106| 9.37k| encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3; 1107| 9.37k|# endif 1108| 9.37k|# ifdef FLAC__AVX2_SUPPORTED 1109| 9.37k| if (encoder->private_->cpuinfo.x86.avx2) ------------------ | Branch (1109:7): [True: 9.37k, False: 0] ------------------ 1110| 9.37k| encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2; 1111| 9.37k|# endif 1112| 9.37k|# endif /* FLAC__CPU_... */ 1113| 9.37k| } 1114| 9.37k|#endif /* !FLAC__NO_ASM && FLAC__HAS_X86INTRIN */ 1115| | 1116| | /* set state to OK; from here on, errors are fatal and we'll override the state then */ 1117| 9.37k| encoder->protected_->state = FLAC__STREAM_ENCODER_OK; 1118| | 1119| 9.37k|#if FLAC__HAS_OGG 1120| 9.37k| encoder->private_->is_ogg = is_ogg; 1121| 9.37k| if(is_ogg && !FLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect)) { ------------------ | Branch (1121:5): [True: 2.89k, False: 6.48k] | Branch (1121:15): [True: 0, False: 2.89k] ------------------ 1122| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 1123| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1124| 0| } 1125| 9.37k|#endif 1126| | 1127| 9.37k| encoder->private_->read_callback = read_callback; 1128| 9.37k| encoder->private_->write_callback = write_callback; 1129| 9.37k| encoder->private_->seek_callback = seek_callback; 1130| 9.37k| encoder->private_->tell_callback = tell_callback; 1131| 9.37k| encoder->private_->metadata_callback = metadata_callback; 1132| 9.37k| encoder->private_->client_data = client_data; 1133| | 1134| 9.37k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (1134:5): [True: 806, False: 8.56k] ------------------ 1135| 806|#ifdef FLAC__USE_THREADS 1136| 806| encoder->private_->num_threadtasks = encoder->protected_->num_threads * 2 + 2; /* First threadtask is reserved for main thread */ 1137| 806| if(FLAC__mtx_init(&encoder->private_->mutex_md5_fifo, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 103| 806|#define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 806|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 806|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (103:47): [True: 806, False: 0] | | ------------------ ------------------ if(FLAC__mtx_init(&encoder->private_->mutex_md5_fifo, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 93| 806|#define FLAC__thrd_success 0 ------------------ | Branch (1137:6): [True: 0, False: 806] ------------------ 1138| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1139| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1140| 0| } 1141| 806| if(FLAC__mtx_init(&encoder->private_->mutex_work_queue, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 103| 806|#define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 806|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 806|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (103:47): [True: 806, False: 0] | | ------------------ ------------------ if(FLAC__mtx_init(&encoder->private_->mutex_work_queue, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 93| 806|#define FLAC__thrd_success 0 ------------------ | Branch (1141:6): [True: 0, False: 806] ------------------ 1142| 0| FLAC__mtx_destroy(&encoder->private_->mutex_md5_fifo); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1143| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1144| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1145| 0| } 1146| 806| if(FLAC__cnd_init(&encoder->private_->cond_md5_emptied) != FLAC__thrd_success) { ------------------ | | 110| 806|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 806|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 806|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 806, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->cond_md5_emptied) != FLAC__thrd_success) { ------------------ | | 93| 806|#define FLAC__thrd_success 0 ------------------ | Branch (1146:6): [True: 0, False: 806] ------------------ 1147| 0| FLAC__mtx_destroy(&encoder->private_->mutex_md5_fifo); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1148| 0| FLAC__mtx_destroy(&encoder->private_->mutex_work_queue); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1149| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1150| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1151| 0| } 1152| 806| if(FLAC__cnd_init(&encoder->private_->cond_work_available) != FLAC__thrd_success) { ------------------ | | 110| 806|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 806|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 806|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 806, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->cond_work_available) != FLAC__thrd_success) { ------------------ | | 93| 806|#define FLAC__thrd_success 0 ------------------ | Branch (1152:6): [True: 0, False: 806] ------------------ 1153| 0| FLAC__mtx_destroy(&encoder->private_->mutex_md5_fifo); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1154| 0| FLAC__mtx_destroy(&encoder->private_->mutex_work_queue); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1155| 0| FLAC__cnd_destroy(&encoder->private_->cond_md5_emptied); ------------------ | | 114| 0|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 1156| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1157| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1158| 0| } 1159| 806| if(FLAC__cnd_init(&encoder->private_->cond_wake_up_thread) != FLAC__thrd_success) { ------------------ | | 110| 806|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 806|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 806|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 806, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->cond_wake_up_thread) != FLAC__thrd_success) { ------------------ | | 93| 806|#define FLAC__thrd_success 0 ------------------ | Branch (1159:6): [True: 0, False: 806] ------------------ 1160| 0| FLAC__mtx_destroy(&encoder->private_->mutex_md5_fifo); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1161| 0| FLAC__mtx_destroy(&encoder->private_->mutex_work_queue); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1162| 0| FLAC__cnd_destroy(&encoder->private_->cond_md5_emptied); ------------------ | | 114| 0|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 1163| 0| FLAC__cnd_destroy(&encoder->private_->cond_work_available); ------------------ | | 114| 0|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 1164| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1165| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1166| 0| } 1167| 806| if(encoder->protected_->do_md5) { ------------------ | Branch (1167:6): [True: 806, False: 0] ------------------ 1168| 806| encoder->private_->md5_fifo.size = (encoder->protected_->blocksize+OVERREAD_) * (encoder->private_->num_threadtasks + 2); 1169| 1.97k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1169:15): [True: 1.17k, False: 806] ------------------ 1170| 1.17k| if(0 == (encoder->private_->md5_fifo.data[i] = safe_malloc_mul_2op_p(sizeof(FLAC__int32), /*times*/encoder->private_->md5_fifo.size))) { ------------------ | Branch (1170:8): [True: 0, False: 1.17k] ------------------ 1171| 0| FLAC__mtx_destroy(&encoder->private_->mutex_md5_fifo); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1172| 0| FLAC__mtx_destroy(&encoder->private_->mutex_work_queue); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1173| 0| FLAC__cnd_destroy(&encoder->private_->cond_md5_emptied); ------------------ | | 114| 0|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 1174| 0| FLAC__cnd_destroy(&encoder->private_->cond_work_available); ------------------ | | 114| 0|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 1175| 0| FLAC__cnd_destroy(&encoder->private_->cond_wake_up_thread); ------------------ | | 114| 0|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 1176| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1177| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1178| 0| } 1179| 1.17k| } 1180| 806| } 1181| 806| encoder->private_->md5_fifo.tail = 0; 1182| 13.4k| for(t = 1; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (1182:14): [True: 12.6k, False: 806] ------------------ 1183| 12.6k| encoder->private_->threadtask[t] = safe_calloc_(1, sizeof(FLAC__StreamEncoderThreadTask)); 1184| 12.6k| if(encoder->private_->threadtask[t] == NULL) { ------------------ | Branch (1184:7): [True: 0, False: 12.6k] ------------------ 1185| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1186| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1187| 0| } 1188| 12.6k| encoder->private_->threadtask[t]->frame = FLAC__bitwriter_new(); 1189| 12.6k| if(encoder->private_->threadtask[t]->frame == NULL) { ------------------ | Branch (1189:7): [True: 0, False: 12.6k] ------------------ 1190| 0| free(encoder->private_->threadtask[t]); 1191| 0| encoder->private_->threadtask[t] = 0; 1192| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1193| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1194| 0| } 1195| 12.6k| if(FLAC__mtx_init(&encoder->private_->threadtask[t]->mutex_this_task, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 103| 12.6k|#define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 12.6k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 12.6k|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (103:47): [True: 12.6k, False: 0] | | ------------------ ------------------ if(FLAC__mtx_init(&encoder->private_->threadtask[t]->mutex_this_task, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 93| 12.6k|#define FLAC__thrd_success 0 ------------------ | Branch (1195:7): [True: 0, False: 12.6k] ------------------ 1196| 0| FLAC__bitwriter_delete(encoder->private_->threadtask[t]->frame); 1197| 0| free(encoder->private_->threadtask[t]); 1198| 0| encoder->private_->threadtask[t] = 0; 1199| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1200| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1201| 0| } 1202| 12.6k| if(FLAC__cnd_init(&encoder->private_->threadtask[t]->cond_task_done) != FLAC__thrd_success) { ------------------ | | 110| 12.6k|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 12.6k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 12.6k|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 12.6k, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->threadtask[t]->cond_task_done) != FLAC__thrd_success) { ------------------ | | 93| 12.6k|#define FLAC__thrd_success 0 ------------------ | Branch (1202:7): [True: 0, False: 12.6k] ------------------ 1203| 0| FLAC__mtx_destroy(&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 107| 0|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 1204| 0| FLAC__bitwriter_delete(encoder->private_->threadtask[t]->frame); 1205| 0| free(encoder->private_->threadtask[t]); 1206| 0| encoder->private_->threadtask[t] = 0; 1207| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1208| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1209| 0| } 1210| | 1211| 113k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 113k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1211:15): [True: 100k, False: 12.6k] ------------------ 1212| 100k| encoder->private_->threadtask[t]->subframe_workspace_ptr[i][0] = &encoder->private_->threadtask[t]->subframe_workspace[i][0]; 1213| 100k| encoder->private_->threadtask[t]->subframe_workspace_ptr[i][1] = &encoder->private_->threadtask[t]->subframe_workspace[i][1]; 1214| 100k| } 1215| 37.8k| for(i = 0; i < 2; i++) { ------------------ | Branch (1215:15): [True: 25.2k, False: 12.6k] ------------------ 1216| 25.2k| encoder->private_->threadtask[t]->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->threadtask[t]->subframe_workspace_mid_side[i][0]; 1217| 25.2k| encoder->private_->threadtask[t]->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->threadtask[t]->subframe_workspace_mid_side[i][1]; 1218| 25.2k| } 1219| 113k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 113k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1219:15): [True: 100k, False: 12.6k] ------------------ 1220| 100k| encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][0]; 1221| 100k| encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][1]; 1222| 100k| } 1223| 37.8k| for(i = 0; i < 2; i++) { ------------------ | Branch (1223:15): [True: 25.2k, False: 12.6k] ------------------ 1224| 25.2k| encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][0]; 1225| 25.2k| encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][1]; 1226| 25.2k| } 1227| | 1228| 113k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 113k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1228:15): [True: 100k, False: 12.6k] ------------------ 1229| 100k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][0]); 1230| 100k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][1]); 1231| 100k| } 1232| 37.8k| for(i = 0; i < 2; i++) { ------------------ | Branch (1232:15): [True: 25.2k, False: 12.6k] ------------------ 1233| 25.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][0]); 1234| 25.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][1]); 1235| 25.2k| } 1236| 37.8k| for(i = 0; i < 2; i++) ------------------ | Branch (1236:15): [True: 25.2k, False: 12.6k] ------------------ 1237| 25.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_extra[i]); 1238| 12.6k| } 1239| |#else 1240| | FLAC__ASSERT(0); 1241| |#endif 1242| 806| } 1243| | 1244| 9.37k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 1245| 30.7k| for(i = 0; i < encoder->protected_->num_apodizations; i++) ------------------ | Branch (1245:13): [True: 21.3k, False: 9.37k] ------------------ 1246| 21.3k| encoder->private_->window_unaligned[i] = encoder->private_->window[i] = 0; 1247| 9.37k|#endif 1248| 31.3k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (1248:13): [True: 21.9k, False: 9.37k] ------------------ 1249| 57.6k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1249:14): [True: 35.7k, False: 21.9k] ------------------ 1250| 35.7k| encoder->private_->threadtask[t]->integer_signal_unaligned[i] = encoder->private_->threadtask[t]->integer_signal[i] = 0; 1251| 35.7k| } 1252| 65.9k| for(i = 0; i < 2; i++) { ------------------ | Branch (1252:14): [True: 43.9k, False: 21.9k] ------------------ 1253| 43.9k| encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i] = encoder->private_->threadtask[t]->integer_signal_mid_side[i] = 0; 1254| 43.9k| } 1255| 21.9k| encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned = encoder->private_->threadtask[t]->integer_signal_33bit_side = 0; 1256| 21.9k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 1257| 21.9k| encoder->private_->threadtask[t]->windowed_signal_unaligned = encoder->private_->threadtask[t]->windowed_signal = 0; 1258| 21.9k|#endif 1259| 57.6k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1259:14): [True: 35.7k, False: 21.9k] ------------------ 1260| 35.7k| encoder->private_->threadtask[t]->residual_workspace_unaligned[i][0] = encoder->private_->threadtask[t]->residual_workspace[i][0] = 0; 1261| 35.7k| encoder->private_->threadtask[t]->residual_workspace_unaligned[i][1] = encoder->private_->threadtask[t]->residual_workspace[i][1] = 0; 1262| 35.7k| encoder->private_->threadtask[t]->best_subframe[i] = 0; 1263| 35.7k| } 1264| 65.9k| for(i = 0; i < 2; i++) { ------------------ | Branch (1264:14): [True: 43.9k, False: 21.9k] ------------------ 1265| 43.9k| encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->threadtask[t]->residual_workspace_mid_side[i][0] = 0; 1266| 43.9k| encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->threadtask[t]->residual_workspace_mid_side[i][1] = 0; 1267| 43.9k| encoder->private_->threadtask[t]->best_subframe_mid_side[i] = 0; 1268| 43.9k| } 1269| 21.9k| encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned = encoder->private_->threadtask[t]->abs_residual_partition_sums = 0; 1270| 21.9k| encoder->private_->threadtask[t]->raw_bits_per_partition_unaligned = encoder->private_->threadtask[t]->raw_bits_per_partition = 0; 1271| 21.9k| } 1272| | 1273| | 1274| 9.37k| if(!resize_buffers_(encoder, encoder->protected_->blocksize)) { ------------------ | Branch (1274:5): [True: 0, False: 9.37k] ------------------ 1275| | /* the above function sets the state for us in case of an error */ 1276| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1277| 0| } 1278| | 1279| 31.3k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (1279:13): [True: 21.9k, False: 9.37k] ------------------ 1280| 21.9k| if(!FLAC__bitwriter_init(encoder->private_->threadtask[t]->frame)) { ------------------ | Branch (1280:6): [True: 0, False: 21.9k] ------------------ 1281| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1282| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1283| 0| } 1284| 21.9k| } 1285| | 1286| | /* 1287| | * Set up the verify stuff if necessary 1288| | */ 1289| 9.37k| if(encoder->protected_->verify) { ------------------ | Branch (1289:5): [True: 8.16k, False: 1.20k] ------------------ 1290| | /* 1291| | * First, set up the fifo which will hold the 1292| | * original signal to compare against 1293| | */ 1294| 8.16k| encoder->private_->verify.input_fifo.size = (encoder->protected_->blocksize+OVERREAD_) * encoder->private_->num_threadtasks; 1295| 22.4k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1295:14): [True: 14.3k, False: 8.16k] ------------------ 1296| 14.3k| if(0 == (encoder->private_->verify.input_fifo.data[i] = safe_malloc_mul_2op_p(sizeof(FLAC__int32), /*times*/encoder->private_->verify.input_fifo.size))) { ------------------ | Branch (1296:7): [True: 0, False: 14.3k] ------------------ 1297| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1298| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1299| 0| } 1300| 14.3k| } 1301| 8.16k| encoder->private_->verify.input_fifo.tail = 0; 1302| | 1303| | /* 1304| | * Now set up a stream decoder for verification 1305| | */ 1306| 8.16k| if(0 == encoder->private_->verify.decoder) { ------------------ | Branch (1306:6): [True: 8.16k, False: 0] ------------------ 1307| 8.16k| encoder->private_->verify.decoder = FLAC__stream_decoder_new(); 1308| 8.16k| if(0 == encoder->private_->verify.decoder) { ------------------ | Branch (1308:7): [True: 0, False: 8.16k] ------------------ 1309| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; 1310| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1311| 0| } 1312| 8.16k| } 1313| | 1314| 8.16k| if(FLAC__stream_decoder_init_stream(encoder->private_->verify.decoder, verify_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, verify_write_callback_, verify_metadata_callback_, verify_error_callback_, /*client_data=*/encoder) != FLAC__STREAM_DECODER_INIT_STATUS_OK) { ------------------ | Branch (1314:6): [True: 0, False: 8.16k] ------------------ 1315| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; 1316| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1317| 0| } 1318| 8.16k| } 1319| 9.37k| encoder->private_->verify.error_stats.absolute_sample = 0; 1320| 9.37k| encoder->private_->verify.error_stats.frame_number = 0; 1321| 9.37k| encoder->private_->verify.error_stats.channel = 0; 1322| 9.37k| encoder->private_->verify.error_stats.sample = 0; 1323| 9.37k| encoder->private_->verify.error_stats.expected = 0; 1324| 9.37k| encoder->private_->verify.error_stats.got = 0; 1325| | 1326| | /* 1327| | * These must be done before we write any metadata, because that 1328| | * calls the write_callback, which uses these values. 1329| | */ 1330| 9.37k| encoder->private_->first_seekpoint_to_check = 0; 1331| 9.37k| encoder->private_->samples_written = 0; 1332| 9.37k| encoder->protected_->streaminfo_offset = 0; 1333| 9.37k| encoder->protected_->seektable_offset = 0; 1334| 9.37k| encoder->protected_->audio_offset = 0; 1335| | 1336| | /* 1337| | * write the stream header 1338| | */ 1339| 9.37k| if(encoder->protected_->verify) ------------------ | Branch (1339:5): [True: 8.16k, False: 1.20k] ------------------ 1340| 8.16k| encoder->private_->verify.state_hint = ENCODER_IN_MAGIC; 1341| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(encoder->private_->threadtask[0]->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN)) { ------------------ | Branch (1341:5): [True: 0, False: 9.37k] ------------------ 1342| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1343| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1344| 0| } 1345| 9.37k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], 0, /*is_last_block=*/false)) { ------------------ | Branch (1345:5): [True: 0, False: 9.37k] ------------------ 1346| | /* the above function sets the state for us in case of an error */ 1347| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1348| 0| } 1349| | 1350| | /* 1351| | * write the STREAMINFO metadata block 1352| | */ 1353| 9.37k| if(encoder->protected_->verify) ------------------ | Branch (1353:5): [True: 8.16k, False: 1.20k] ------------------ 1354| 8.16k| encoder->private_->verify.state_hint = ENCODER_IN_METADATA; 1355| 9.37k| encoder->private_->streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO; 1356| 9.37k| encoder->private_->streaminfo.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */ 1357| 9.37k| encoder->private_->streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; ------------------ | | 557| 9.37k|#define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u) ------------------ 1358| 9.37k| encoder->private_->streaminfo.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */ 1359| 9.37k| encoder->private_->streaminfo.data.stream_info.max_blocksize = encoder->protected_->blocksize; 1360| 9.37k| encoder->private_->streaminfo.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */ 1361| 9.37k| encoder->private_->streaminfo.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */ 1362| 9.37k| encoder->private_->streaminfo.data.stream_info.sample_rate = encoder->protected_->sample_rate; 1363| 9.37k| encoder->private_->streaminfo.data.stream_info.channels = encoder->protected_->channels; 1364| 9.37k| encoder->private_->streaminfo.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample; 1365| 9.37k| encoder->private_->streaminfo.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */ 1366| 9.37k| memset(encoder->private_->streaminfo.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */ 1367| 9.37k| if(encoder->protected_->do_md5) ------------------ | Branch (1367:5): [True: 9.37k, False: 0] ------------------ 1368| 9.37k| FLAC__MD5Init(&encoder->private_->md5context); 1369| 9.37k| if(!FLAC__add_metadata_block(&encoder->private_->streaminfo, encoder->private_->threadtask[0]->frame, true)) { ------------------ | Branch (1369:5): [True: 0, False: 9.37k] ------------------ 1370| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1371| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1372| 0| } 1373| 9.37k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], 0, /*is_last_block=*/false)) { ------------------ | Branch (1373:5): [True: 0, False: 9.37k] ------------------ 1374| | /* the above function sets the state for us in case of an error */ 1375| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1376| 0| } 1377| | 1378| | /* 1379| | * Now that the STREAMINFO block is written, we can init this to an 1380| | * absurdly-high value... 1381| | */ 1382| 9.37k| encoder->private_->streaminfo.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1; 1383| | /* ... and clear this to 0 */ 1384| 9.37k| encoder->private_->streaminfo.data.stream_info.total_samples = 0; 1385| | 1386| | /* 1387| | * Check to see if the supplied metadata contains a VORBIS_COMMENT; 1388| | * if not, we will write an empty one (FLAC__add_metadata_block() 1389| | * automatically supplies the vendor string). 1390| | * 1391| | * WATCHOUT: the Ogg FLAC mapping requires us to write this block after 1392| | * the STREAMINFO. (In the case that metadata_has_vorbis_comment is 1393| | * true it will have already insured that the metadata list is properly 1394| | * ordered.) 1395| | */ 1396| 9.37k| if(!metadata_has_vorbis_comment) { ------------------ | Branch (1396:5): [True: 9.37k, False: 0] ------------------ 1397| 9.37k| FLAC__StreamMetadata vorbis_comment; 1398| 9.37k| vorbis_comment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT; 1399| 9.37k| vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0); 1400| 9.37k| vorbis_comment.length = 4 + 4; /* MAGIC NUMBER */ 1401| 9.37k| vorbis_comment.data.vorbis_comment.vendor_string.length = 0; 1402| 9.37k| vorbis_comment.data.vorbis_comment.vendor_string.entry = 0; 1403| 9.37k| vorbis_comment.data.vorbis_comment.num_comments = 0; 1404| 9.37k| vorbis_comment.data.vorbis_comment.comments = 0; 1405| 9.37k| if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->threadtask[0]->frame, true)) { ------------------ | Branch (1405:6): [True: 0, False: 9.37k] ------------------ 1406| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1407| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1408| 0| } 1409| 9.37k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], 0, /*is_last_block=*/false)) { ------------------ | Branch (1409:6): [True: 0, False: 9.37k] ------------------ 1410| | /* the above function sets the state for us in case of an error */ 1411| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1412| 0| } 1413| 9.37k| } 1414| | 1415| | /* 1416| | * write the user's metadata blocks 1417| | */ 1418| 9.37k| for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { ------------------ | Branch (1418:13): [True: 0, False: 9.37k] ------------------ 1419| 0| encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1); 1420| 0| if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->threadtask[0]->frame, true)) { ------------------ | Branch (1420:6): [True: 0, False: 0] ------------------ 1421| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1422| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1423| 0| } 1424| 0| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], 0, /*is_last_block=*/false)) { ------------------ | Branch (1424:6): [True: 0, False: 0] ------------------ 1425| | /* the above function sets the state for us in case of an error */ 1426| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1427| 0| } 1428| 0| } 1429| | 1430| | /* now that all the metadata is written, we save the stream offset */ 1431| 9.37k| if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &encoder->protected_->audio_offset, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) { /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */ ------------------ | Branch (1431:5): [True: 9.37k, False: 0] | Branch (1431:41): [True: 0, False: 9.37k] ------------------ 1432| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 1433| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1434| 0| } 1435| | 1436| 9.37k| if(encoder->protected_->verify) ------------------ | Branch (1436:5): [True: 8.16k, False: 1.20k] ------------------ 1437| 8.16k| encoder->private_->verify.state_hint = ENCODER_IN_AUDIO; 1438| | 1439| 9.37k| return FLAC__STREAM_ENCODER_INIT_STATUS_OK; 1440| 9.37k|} stream_encoder.c:verify_read_callback_: 5156| 235k|{ 5157| 235k| FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data; 5158| 235k| const size_t encoded_bytes = encoder->private_->verify.output.bytes; 5159| 235k| (void)decoder; 5160| | 5161| 235k| if(encoder->private_->verify.needs_magic_hack) { ------------------ | Branch (5161:5): [True: 8.16k, False: 227k] ------------------ 5162| 8.16k| FLAC__ASSERT(*bytes >= FLAC__STREAM_SYNC_LENGTH); ------------------ | | 38| 8.16k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.16k] | | ------------------ ------------------ 5163| 8.16k| *bytes = FLAC__STREAM_SYNC_LENGTH; ------------------ | | 179| 8.16k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 5164| 8.16k| memcpy(buffer, FLAC__STREAM_SYNC_STRING, *bytes); 5165| 8.16k| encoder->private_->verify.needs_magic_hack = false; 5166| 8.16k| } 5167| 227k| else { 5168| 227k| if(encoded_bytes == 0) { ------------------ | Branch (5168:6): [True: 0, False: 227k] ------------------ 5169| | /* 5170| | * If we get here, a FIFO underflow has occurred, 5171| | * which means there is a bug somewhere. 5172| | */ 5173| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 5174| 0| return FLAC__STREAM_DECODER_READ_STATUS_ABORT; 5175| 0| } 5176| 227k| else if(encoded_bytes < *bytes) ------------------ | Branch (5176:11): [True: 219k, False: 7.85k] ------------------ 5177| 219k| *bytes = encoded_bytes; 5178| 227k| memcpy(buffer, encoder->private_->verify.output.data, *bytes); 5179| 227k| encoder->private_->verify.output.data += *bytes; 5180| 227k| encoder->private_->verify.output.bytes -= *bytes; 5181| 227k| } 5182| | 5183| 235k| return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; 5184| 235k|} stream_encoder.c:verify_write_callback_: 5187| 203k|{ 5188| 203k| FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data; 5189| 203k| uint32_t channel; 5190| 203k| const uint32_t channels = frame->header.channels; 5191| 203k| const uint32_t blocksize = frame->header.blocksize; 5192| 203k| const uint32_t bytes_per_block = sizeof(FLAC__int32) * blocksize; 5193| | 5194| 203k| (void)decoder; 5195| | 5196| 203k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) { ------------------ | Branch (5196:5): [True: 0, False: 203k] ------------------ 5197| | /* This is set when verify_error_callback_ was called */ 5198| 0| return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 5199| 0| } 5200| | 5201| 473k| for(channel = 0; channel < channels; channel++) { ------------------ | Branch (5201:19): [True: 270k, False: 203k] ------------------ 5202| 270k| if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) { ------------------ | Branch (5202:6): [True: 0, False: 270k] ------------------ 5203| 0| uint32_t i, sample = 0; 5204| 0| FLAC__int32 expect = 0, got = 0; 5205| | 5206| 0| for(i = 0; i < blocksize; i++) { ------------------ | Branch (5206:15): [True: 0, False: 0] ------------------ 5207| 0| if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) { ------------------ | Branch (5207:8): [True: 0, False: 0] ------------------ 5208| 0| sample = i; 5209| 0| expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i]; 5210| 0| got = (FLAC__int32)buffer[channel][i]; 5211| 0| break; 5212| 0| } 5213| 0| } 5214| 0| FLAC__ASSERT(i < blocksize); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 5215| 0| FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 5216| 0| encoder->private_->verify.error_stats.absolute_sample = frame->header.number.sample_number + sample; 5217| 0| encoder->private_->verify.error_stats.frame_number = (uint32_t)(frame->header.number.sample_number / blocksize); 5218| 0| encoder->private_->verify.error_stats.channel = channel; 5219| 0| encoder->private_->verify.error_stats.sample = sample; 5220| 0| encoder->private_->verify.error_stats.expected = expect; 5221| 0| encoder->private_->verify.error_stats.got = got; 5222| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA; 5223| 0| return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 5224| 0| } 5225| 270k| } 5226| | /* dequeue the frame from the fifo */ 5227| 203k| encoder->private_->verify.input_fifo.tail -= blocksize; 5228| 473k| for(channel = 0; channel < channels; channel++) ------------------ | Branch (5228:19): [True: 270k, False: 203k] ------------------ 5229| 270k| memmove(&encoder->private_->verify.input_fifo.data[channel][0], &encoder->private_->verify.input_fifo.data[channel][blocksize], encoder->private_->verify.input_fifo.tail * sizeof(encoder->private_->verify.input_fifo.data[0][0])); 5230| 203k| return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 5231| 203k|} stream_encoder.c:verify_metadata_callback_: 5234| 8.16k|{ 5235| 8.16k| (void)decoder, (void)metadata, (void)client_data; 5236| 8.16k|} stream_encoder.c:set_defaults_: 2629| 20.9k|{ 2630| 20.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 20.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.9k] | | ------------------ ------------------ 2631| | 2632| |#ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING 2633| | encoder->protected_->verify = true; 2634| |#else 2635| 20.9k| encoder->protected_->verify = false; 2636| 20.9k|#endif 2637| 20.9k| encoder->protected_->streamable_subset = true; 2638| 20.9k| encoder->protected_->do_md5 = true; 2639| 20.9k| encoder->protected_->do_mid_side_stereo = false; 2640| 20.9k| encoder->protected_->loose_mid_side_stereo = false; 2641| 20.9k| encoder->protected_->channels = 2; 2642| 20.9k| encoder->protected_->bits_per_sample = 16; 2643| 20.9k| encoder->protected_->sample_rate = 44100; 2644| 20.9k| encoder->protected_->blocksize = 0; 2645| 20.9k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2646| 20.9k| encoder->protected_->num_apodizations = 1; 2647| 20.9k| encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 2648| 20.9k| encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 2649| 20.9k|#endif 2650| 20.9k| encoder->protected_->max_lpc_order = 0; 2651| 20.9k| encoder->protected_->qlp_coeff_precision = 0; 2652| 20.9k| encoder->protected_->do_qlp_coeff_prec_search = false; 2653| 20.9k| encoder->protected_->do_exhaustive_model_search = false; 2654| 20.9k| encoder->protected_->do_escape_coding = false; 2655| 20.9k| encoder->protected_->min_residual_partition_order = 0; 2656| 20.9k| encoder->protected_->max_residual_partition_order = 0; 2657| 20.9k| encoder->protected_->rice_parameter_search_dist = 0; 2658| 20.9k| encoder->protected_->total_samples_estimate = 0; 2659| 20.9k| encoder->protected_->limit_min_bitrate = false; 2660| 20.9k| encoder->protected_->metadata = 0; 2661| 20.9k| encoder->protected_->num_metadata_blocks = 0; 2662| 20.9k| encoder->protected_->num_threads = 1; 2663| | 2664| 20.9k| encoder->private_->seek_table = 0; 2665| 20.9k| encoder->private_->disable_mmx = false; 2666| 20.9k| encoder->private_->disable_sse2 = false; 2667| 20.9k| encoder->private_->disable_ssse3 = false; 2668| 20.9k| encoder->private_->disable_sse41 = false; 2669| 20.9k| encoder->private_->disable_sse42 = false; 2670| 20.9k| encoder->private_->disable_avx2 = false; 2671| 20.9k| encoder->private_->disable_constant_subframes = false; 2672| 20.9k| encoder->private_->disable_fixed_subframes = false; 2673| 20.9k| encoder->private_->disable_verbatim_subframes = false; 2674| 20.9k| encoder->private_->is_ogg = false; 2675| 20.9k| encoder->private_->read_callback = 0; 2676| 20.9k| encoder->private_->write_callback = 0; 2677| 20.9k| encoder->private_->seek_callback = 0; 2678| 20.9k| encoder->private_->tell_callback = 0; 2679| 20.9k| encoder->private_->metadata_callback = 0; 2680| 20.9k| encoder->private_->progress_callback = 0; 2681| 20.9k| encoder->private_->client_data = 0; 2682| 20.9k| encoder->private_->num_threadtasks = 1; 2683| 20.9k|#ifdef FLAC__USE_THREADS 2684| 20.9k| encoder->private_->num_created_threads = 1; 2685| 20.9k| encoder->private_->next_thread = 1; 2686| 20.9k| encoder->private_->num_running_threads = 1; 2687| 20.9k| encoder->private_->num_started_threadtasks = 1; 2688| 20.9k| encoder->private_->num_available_threadtasks = 0; 2689| 20.9k| encoder->private_->overcommitted_indicator = 0; 2690| 20.9k| encoder->private_->next_threadtask = 1; 2691| 20.9k| encoder->private_->md5_active = false; 2692| 20.9k| encoder->private_->finish_work_threads = false; 2693| 20.9k|#endif 2694| | 2695| 20.9k|#if FLAC__HAS_OGG 2696| 20.9k| FLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect); 2697| 20.9k|#endif 2698| | 2699| 20.9k| FLAC__stream_encoder_set_compression_level(encoder, 5); 2700| 20.9k|} stream_encoder.c:free_: 2703| 9.37k|{ 2704| 9.37k| uint32_t i, t, channel; 2705| | 2706| 9.37k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 2707| 9.37k| if(encoder->protected_->metadata) { ------------------ | Branch (2707:5): [True: 0, False: 9.37k] ------------------ 2708| 0| free(encoder->protected_->metadata); 2709| 0| encoder->protected_->metadata = 0; 2710| 0| encoder->protected_->num_metadata_blocks = 0; 2711| 0| } 2712| 9.37k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2713| 30.7k| for(i = 0; i < encoder->protected_->num_apodizations; i++) { ------------------ | Branch (2713:13): [True: 21.3k, False: 9.37k] ------------------ 2714| 21.3k| if(0 != encoder->private_->window_unaligned[i]) { ------------------ | Branch (2714:6): [True: 19.9k, False: 1.40k] ------------------ 2715| 19.9k| free(encoder->private_->window_unaligned[i]); 2716| 19.9k| encoder->private_->window_unaligned[i] = 0; 2717| 19.9k| } 2718| 21.3k| } 2719| 9.37k|#endif 2720| 31.3k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (2720:13): [True: 21.9k, False: 9.37k] ------------------ 2721| 21.9k| if(0 == encoder->private_->threadtask[t]) ------------------ | Branch (2721:6): [True: 0, False: 21.9k] ------------------ 2722| 0| continue; 2723| 57.6k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (2723:14): [True: 35.7k, False: 21.9k] ------------------ 2724| 35.7k| if(0 != encoder->private_->threadtask[t]->integer_signal_unaligned[i]) { ------------------ | Branch (2724:7): [True: 35.7k, False: 0] ------------------ 2725| 35.7k| free(encoder->private_->threadtask[t]->integer_signal_unaligned[i]); 2726| 35.7k| encoder->private_->threadtask[t]->integer_signal_unaligned[i] = 0; 2727| 35.7k| } 2728| 35.7k| } 2729| 65.9k| for(i = 0; i < 2; i++) { ------------------ | Branch (2729:14): [True: 43.9k, False: 21.9k] ------------------ 2730| 43.9k| if(0 != encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i]) { ------------------ | Branch (2730:7): [True: 43.9k, False: 0] ------------------ 2731| 43.9k| free(encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i]); 2732| 43.9k| encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i] = 0; 2733| 43.9k| } 2734| 43.9k| } 2735| 21.9k| if(0 != encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned){ ------------------ | Branch (2735:6): [True: 21.9k, False: 0] ------------------ 2736| 21.9k| free(encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned); 2737| 21.9k| encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned = 0; 2738| 21.9k| } 2739| 21.9k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2740| 21.9k| if(0 != encoder->private_->threadtask[t]->windowed_signal_unaligned) { ------------------ | Branch (2740:6): [True: 14.5k, False: 7.40k] ------------------ 2741| 14.5k| free(encoder->private_->threadtask[t]->windowed_signal_unaligned); 2742| 14.5k| encoder->private_->threadtask[t]->windowed_signal_unaligned = 0; 2743| 14.5k| } 2744| 21.9k|#endif 2745| 57.6k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (2745:20): [True: 35.7k, False: 21.9k] ------------------ 2746| 107k| for(i = 0; i < 2; i++) { ------------------ | Branch (2746:15): [True: 71.4k, False: 35.7k] ------------------ 2747| 71.4k| if(0 != encoder->private_->threadtask[t]->residual_workspace_unaligned[channel][i]) { ------------------ | Branch (2747:8): [True: 71.4k, False: 0] ------------------ 2748| 71.4k| free(encoder->private_->threadtask[t]->residual_workspace_unaligned[channel][i]); 2749| 71.4k| encoder->private_->threadtask[t]->residual_workspace_unaligned[channel][i] = 0; 2750| 71.4k| } 2751| 71.4k| } 2752| 35.7k| } 2753| 65.9k| for(channel = 0; channel < 2; channel++) { ------------------ | Branch (2753:20): [True: 43.9k, False: 21.9k] ------------------ 2754| 131k| for(i = 0; i < 2; i++) { ------------------ | Branch (2754:15): [True: 87.9k, False: 43.9k] ------------------ 2755| 87.9k| if(0 != encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[channel][i]) { ------------------ | Branch (2755:8): [True: 87.9k, False: 0] ------------------ 2756| 87.9k| free(encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[channel][i]); 2757| 87.9k| encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[channel][i] = 0; 2758| 87.9k| } 2759| 87.9k| } 2760| 43.9k| } 2761| 21.9k| if(0 != encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned) { ------------------ | Branch (2761:6): [True: 21.9k, False: 0] ------------------ 2762| 21.9k| free(encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned); 2763| 21.9k| encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned = 0; 2764| 21.9k| } 2765| 21.9k| if(0 != encoder->private_->threadtask[t]->raw_bits_per_partition_unaligned) { ------------------ | Branch (2765:6): [True: 15.4k, False: 6.52k] ------------------ 2766| 15.4k| free(encoder->private_->threadtask[t]->raw_bits_per_partition_unaligned); 2767| 15.4k| encoder->private_->threadtask[t]->raw_bits_per_partition_unaligned = 0; 2768| 15.4k| } 2769| 197k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 197k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (2769:14): [True: 175k, False: 21.9k] ------------------ 2770| 175k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][0]); 2771| 175k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][1]); 2772| 175k| } 2773| 65.9k| for(i = 0; i < 2; i++) { ------------------ | Branch (2773:14): [True: 43.9k, False: 21.9k] ------------------ 2774| 43.9k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][0]); 2775| 43.9k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][1]); 2776| 43.9k| } 2777| 65.9k| for(i = 0; i < 2; i++) ------------------ | Branch (2777:14): [True: 43.9k, False: 21.9k] ------------------ 2778| 43.9k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_extra[i]); 2779| 21.9k| if(t > 0) { ------------------ | Branch (2779:6): [True: 12.6k, False: 9.37k] ------------------ 2780| 12.6k|#ifdef FLAC__USE_THREADS 2781| 12.6k| FLAC__bitwriter_delete(encoder->private_->threadtask[t]->frame); 2782| 12.6k| FLAC__mtx_destroy(&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 107| 12.6k|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 2783| 12.6k| FLAC__cnd_destroy(&encoder->private_->threadtask[t]->cond_task_done); ------------------ | | 114| 12.6k|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2784| 12.6k| free(encoder->private_->threadtask[t]); 2785| 12.6k| encoder->private_->threadtask[t] = 0; 2786| |#else 2787| | FLAC__ASSERT(0); 2788| |#endif 2789| 12.6k| } 2790| | 2791| 21.9k| } 2792| 9.37k|#ifdef FLAC__USE_THREADS 2793| 9.37k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (2793:5): [True: 806, False: 8.56k] ------------------ 2794| 806| FLAC__mtx_destroy(&encoder->private_->mutex_md5_fifo); ------------------ | | 107| 806|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 2795| 806| FLAC__mtx_destroy(&encoder->private_->mutex_work_queue); ------------------ | | 107| 806|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 2796| 806| FLAC__cnd_destroy(&encoder->private_->cond_md5_emptied); ------------------ | | 114| 806|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2797| 806| FLAC__cnd_destroy(&encoder->private_->cond_work_available); ------------------ | | 114| 806|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2798| 806| FLAC__cnd_destroy(&encoder->private_->cond_wake_up_thread); ------------------ | | 114| 806|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2799| 806| if(encoder->protected_->do_md5) { ------------------ | Branch (2799:6): [True: 806, False: 0] ------------------ 2800| 1.97k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (2800:15): [True: 1.17k, False: 806] ------------------ 2801| 1.17k| if(0 != encoder->private_->md5_fifo.data[i]) { ------------------ | Branch (2801:8): [True: 1.17k, False: 0] ------------------ 2802| 1.17k| free(encoder->private_->md5_fifo.data[i]); 2803| 1.17k| encoder->private_->md5_fifo.data[i] = 0; 2804| 1.17k| } 2805| 1.17k| } 2806| 806| } 2807| | 2808| 806| } 2809| 9.37k|#endif 2810| 9.37k| if(encoder->protected_->verify) { ------------------ | Branch (2810:5): [True: 8.16k, False: 1.20k] ------------------ 2811| 22.4k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (2811:14): [True: 14.3k, False: 8.16k] ------------------ 2812| 14.3k| if(0 != encoder->private_->verify.input_fifo.data[i]) { ------------------ | Branch (2812:7): [True: 14.3k, False: 0] ------------------ 2813| 14.3k| free(encoder->private_->verify.input_fifo.data[i]); 2814| 14.3k| encoder->private_->verify.input_fifo.data[i] = 0; 2815| 14.3k| } 2816| 14.3k| } 2817| 8.16k| } 2818| 9.37k|} stream_encoder.c:resize_buffers_: 2821| 17.8k|{ 2822| 17.8k| FLAC__bool ok; 2823| 17.8k| uint32_t i, t, channel; 2824| | 2825| 17.8k| FLAC__ASSERT(new_blocksize > 0); ------------------ | | 38| 17.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.8k] | | ------------------ ------------------ 2826| 17.8k| FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); ------------------ | | 38| 17.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.8k] | | ------------------ ------------------ 2827| | 2828| 17.8k| ok = true; 2829| | 2830| | /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */ 2831| 17.8k| if(new_blocksize > encoder->private_->input_capacity) { ------------------ | Branch (2831:5): [True: 9.37k, False: 8.50k] ------------------ 2832| | 2833| | /* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx() and ..._intrin_sse2() 2834| | * require that the input arrays (in our case the integer signals) 2835| | * have a buffer of up to 3 zeroes in front (at negative indices) for 2836| | * alignment purposes; we use 4 in front to keep the data well-aligned. 2837| | */ 2838| 9.37k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2839| 9.37k| if(ok && encoder->protected_->max_lpc_order > 0) { ------------------ | Branch (2839:6): [True: 9.37k, False: 0] | Branch (2839:12): [True: 8.03k, False: 1.34k] ------------------ 2840| 27.9k| for(i = 0; ok && i < encoder->protected_->num_apodizations; i++) ------------------ | Branch (2840:15): [True: 27.9k, False: 0] | Branch (2840:21): [True: 19.9k, False: 8.03k] ------------------ 2841| 19.9k| ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->window_unaligned[i], &encoder->private_->window[i]); ------------------ | Branch (2841:10): [True: 19.9k, False: 0] | Branch (2841:16): [True: 19.9k, False: 0] ------------------ 2842| 8.03k| } 2843| 9.37k|#endif 2844| 31.3k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (2844:14): [True: 21.9k, False: 9.37k] ------------------ 2845| 57.6k| for(i = 0; ok && i < encoder->protected_->channels; i++) { ------------------ | Branch (2845:15): [True: 57.6k, False: 0] | Branch (2845:21): [True: 35.7k, False: 21.9k] ------------------ 2846| 35.7k| ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->threadtask[t]->integer_signal_unaligned[i], &encoder->private_->threadtask[t]->integer_signal[i]); ------------------ | Branch (2846:10): [True: 35.7k, False: 0] | Branch (2846:16): [True: 35.7k, False: 0] ------------------ 2847| 35.7k| if(ok) { ------------------ | Branch (2847:8): [True: 35.7k, False: 0] ------------------ 2848| 35.7k| memset(encoder->private_->threadtask[t]->integer_signal[i], 0, sizeof(FLAC__int32)*4); 2849| 35.7k| encoder->private_->threadtask[t]->integer_signal[i] += 4; 2850| 35.7k| } 2851| 35.7k| } 2852| 65.9k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2852:15): [True: 65.9k, False: 0] | Branch (2852:21): [True: 43.9k, False: 21.9k] ------------------ 2853| 43.9k| ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i], &encoder->private_->threadtask[t]->integer_signal_mid_side[i]); ------------------ | Branch (2853:10): [True: 43.9k, False: 0] | Branch (2853:16): [True: 43.9k, False: 0] ------------------ 2854| 43.9k| if(ok) { ------------------ | Branch (2854:8): [True: 43.9k, False: 0] ------------------ 2855| 43.9k| memset(encoder->private_->threadtask[t]->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4); 2856| 43.9k| encoder->private_->threadtask[t]->integer_signal_mid_side[i] += 4; 2857| 43.9k| } 2858| 43.9k| } 2859| 21.9k| ok = ok && FLAC__memory_alloc_aligned_int64_array(new_blocksize+4+OVERREAD_, &encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned, &encoder->private_->threadtask[t]->integer_signal_33bit_side); ------------------ | Branch (2859:9): [True: 21.9k, False: 0] | Branch (2859:15): [True: 21.9k, False: 0] ------------------ 2860| 21.9k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2861| 21.9k| if(ok && encoder->protected_->max_lpc_order > 0) { ------------------ | Branch (2861:7): [True: 21.9k, False: 0] | Branch (2861:13): [True: 14.5k, False: 7.40k] ------------------ 2862| 14.5k| ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->threadtask[t]->windowed_signal_unaligned, &encoder->private_->threadtask[t]->windowed_signal); ------------------ | Branch (2862:10): [True: 14.5k, False: 0] | Branch (2862:16): [True: 14.5k, False: 0] ------------------ 2863| 14.5k| } 2864| 21.9k|#endif 2865| 57.6k| for(channel = 0; ok && channel < encoder->protected_->channels; channel++) { ------------------ | Branch (2865:21): [True: 57.6k, False: 0] | Branch (2865:27): [True: 35.7k, False: 21.9k] ------------------ 2866| 107k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2866:16): [True: 107k, False: 0] | Branch (2866:22): [True: 71.4k, False: 35.7k] ------------------ 2867| 71.4k| ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->threadtask[t]->residual_workspace_unaligned[channel][i], &encoder->private_->threadtask[t]->residual_workspace[channel][i]); ------------------ | Branch (2867:11): [True: 71.4k, False: 0] | Branch (2867:17): [True: 71.4k, False: 0] ------------------ 2868| 71.4k| } 2869| 35.7k| } 2870| | 2871| | 2872| 57.6k| for(channel = 0; ok && channel < encoder->protected_->channels; channel++) { ------------------ | Branch (2872:21): [True: 57.6k, False: 0] | Branch (2872:27): [True: 35.7k, False: 21.9k] ------------------ 2873| 107k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2873:16): [True: 107k, False: 0] | Branch (2873:22): [True: 71.4k, False: 35.7k] ------------------ 2874| 71.4k| ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[channel][i], encoder->protected_->max_residual_partition_order); ------------------ | Branch (2874:11): [True: 71.4k, False: 0] | Branch (2874:17): [True: 71.4k, False: 0] ------------------ 2875| 71.4k| ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[channel][i], encoder->protected_->max_residual_partition_order); ------------------ | Branch (2875:11): [True: 71.4k, False: 0] | Branch (2875:17): [True: 71.4k, False: 0] ------------------ 2876| 71.4k| } 2877| 35.7k| } 2878| | 2879| 65.9k| for(channel = 0; ok && channel < 2; channel++) { ------------------ | Branch (2879:21): [True: 65.9k, False: 0] | Branch (2879:27): [True: 43.9k, False: 21.9k] ------------------ 2880| 131k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2880:16): [True: 131k, False: 0] | Branch (2880:22): [True: 87.9k, False: 43.9k] ------------------ 2881| 87.9k| ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[channel][i], &encoder->private_->threadtask[t]->residual_workspace_mid_side[channel][i]); ------------------ | Branch (2881:11): [True: 87.9k, False: 0] | Branch (2881:17): [True: 87.9k, False: 0] ------------------ 2882| 87.9k| } 2883| 43.9k| } 2884| | 2885| 65.9k| for(channel = 0; ok && channel < 2; channel++) { ------------------ | Branch (2885:21): [True: 65.9k, False: 0] | Branch (2885:27): [True: 43.9k, False: 21.9k] ------------------ 2886| 131k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2886:16): [True: 131k, False: 0] | Branch (2886:22): [True: 87.9k, False: 43.9k] ------------------ 2887| 87.9k| ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[channel][i], encoder->protected_->max_residual_partition_order); ------------------ | Branch (2887:11): [True: 87.9k, False: 0] | Branch (2887:17): [True: 87.9k, False: 0] ------------------ 2888| 87.9k| } 2889| 43.9k| } 2890| | 2891| 65.9k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2891:15): [True: 65.9k, False: 0] | Branch (2891:21): [True: 43.9k, False: 21.9k] ------------------ 2892| 43.9k| ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->threadtask[t]->partitioned_rice_contents_extra[i], encoder->protected_->max_residual_partition_order); ------------------ | Branch (2892:10): [True: 43.9k, False: 0] | Branch (2892:16): [True: 43.9k, False: 0] ------------------ 2893| 43.9k| } 2894| | 2895| | 2896| | /* the *2 is an approximation to the series 1 + 1/2 + 1/4 + ... that sums tree occupies in a flat array */ 2897| | /*@@@ new_blocksize*2 is too pessimistic, but to fix, we need smarter logic because a smaller new_blocksize can actually increase the # of partitions; would require moving this out into a separate function, then checking its capacity against the need of the current blocksize&min/max_partition_order (and maybe predictor order) */ 2898| 21.9k| ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_blocksize * 2, &encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned, &encoder->private_->threadtask[t]->abs_residual_partition_sums); ------------------ | Branch (2898:9): [True: 21.9k, False: 0] | Branch (2898:15): [True: 21.9k, False: 0] ------------------ 2899| 21.9k| if(encoder->protected_->do_escape_coding) ------------------ | Branch (2899:7): [True: 15.4k, False: 6.52k] ------------------ 2900| 15.4k| ok = ok && FLAC__memory_alloc_aligned_uint32_array(new_blocksize * 2, &encoder->private_->threadtask[t]->raw_bits_per_partition_unaligned, &encoder->private_->threadtask[t]->raw_bits_per_partition); ------------------ | Branch (2900:10): [True: 15.4k, False: 0] | Branch (2900:16): [True: 15.4k, False: 0] ------------------ 2901| 21.9k| } 2902| 9.37k|} 2903| 17.8k| if(ok) ------------------ | Branch (2903:5): [True: 17.8k, False: 0] ------------------ 2904| 17.8k| encoder->private_->input_capacity = new_blocksize; 2905| 0| else { 2906| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 2907| 0| return ok; 2908| 0| } 2909| | 2910| | 2911| | /* now adjust the windows if the blocksize has changed */ 2912| 17.8k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2913| 17.8k| if(encoder->protected_->max_lpc_order > 0 && new_blocksize > 1) { ------------------ | Branch (2913:5): [True: 15.3k, False: 2.57k] | Branch (2913:47): [True: 14.6k, False: 697] ------------------ 2914| 51.2k| for(i = 0; i < encoder->protected_->num_apodizations; i++) { ------------------ | Branch (2914:14): [True: 36.6k, False: 14.6k] ------------------ 2915| 36.6k| switch(encoder->protected_->apodizations[i].type) { 2916| 768| case FLAC__APODIZATION_BARTLETT: ------------------ | Branch (2916:5): [True: 768, False: 35.8k] ------------------ 2917| 768| FLAC__window_bartlett(encoder->private_->window[i], new_blocksize); 2918| 768| break; 2919| 104| case FLAC__APODIZATION_BARTLETT_HANN: ------------------ | Branch (2919:5): [True: 104, False: 36.5k] ------------------ 2920| 104| FLAC__window_bartlett_hann(encoder->private_->window[i], new_blocksize); 2921| 104| break; 2922| 118| case FLAC__APODIZATION_BLACKMAN: ------------------ | Branch (2922:5): [True: 118, False: 36.5k] ------------------ 2923| 118| FLAC__window_blackman(encoder->private_->window[i], new_blocksize); 2924| 118| break; 2925| 103| case FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE: ------------------ | Branch (2925:5): [True: 103, False: 36.5k] ------------------ 2926| 103| FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_blocksize); 2927| 103| break; 2928| 233| case FLAC__APODIZATION_CONNES: ------------------ | Branch (2928:5): [True: 233, False: 36.4k] ------------------ 2929| 233| FLAC__window_connes(encoder->private_->window[i], new_blocksize); 2930| 233| break; 2931| 150| case FLAC__APODIZATION_FLATTOP: ------------------ | Branch (2931:5): [True: 150, False: 36.5k] ------------------ 2932| 150| FLAC__window_flattop(encoder->private_->window[i], new_blocksize); 2933| 150| break; 2934| 187| case FLAC__APODIZATION_GAUSS: ------------------ | Branch (2934:5): [True: 187, False: 36.4k] ------------------ 2935| 187| FLAC__window_gauss(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.gauss.stddev); 2936| 187| break; 2937| 279| case FLAC__APODIZATION_HAMMING: ------------------ | Branch (2937:5): [True: 279, False: 36.3k] ------------------ 2938| 279| FLAC__window_hamming(encoder->private_->window[i], new_blocksize); 2939| 279| break; 2940| 517| case FLAC__APODIZATION_HANN: ------------------ | Branch (2940:5): [True: 517, False: 36.1k] ------------------ 2941| 517| FLAC__window_hann(encoder->private_->window[i], new_blocksize); 2942| 517| break; 2943| 118| case FLAC__APODIZATION_KAISER_BESSEL: ------------------ | Branch (2943:5): [True: 118, False: 36.5k] ------------------ 2944| 118| FLAC__window_kaiser_bessel(encoder->private_->window[i], new_blocksize); 2945| 118| break; 2946| 85| case FLAC__APODIZATION_NUTTALL: ------------------ | Branch (2946:5): [True: 85, False: 36.5k] ------------------ 2947| 85| FLAC__window_nuttall(encoder->private_->window[i], new_blocksize); 2948| 85| break; 2949| 257| case FLAC__APODIZATION_RECTANGLE: ------------------ | Branch (2949:5): [True: 257, False: 36.3k] ------------------ 2950| 257| FLAC__window_rectangle(encoder->private_->window[i], new_blocksize); 2951| 257| break; 2952| 679| case FLAC__APODIZATION_TRIANGLE: ------------------ | Branch (2952:5): [True: 679, False: 35.9k] ------------------ 2953| 679| FLAC__window_triangle(encoder->private_->window[i], new_blocksize); 2954| 679| break; 2955| 12.2k| case FLAC__APODIZATION_TUKEY: ------------------ | Branch (2955:5): [True: 12.2k, False: 24.4k] ------------------ 2956| 12.2k| FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p); 2957| 12.2k| break; 2958| 7.08k| case FLAC__APODIZATION_PARTIAL_TUKEY: ------------------ | Branch (2958:5): [True: 7.08k, False: 29.5k] ------------------ 2959| 7.08k| FLAC__window_partial_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end); 2960| 7.08k| break; 2961| 9.99k| case FLAC__APODIZATION_PUNCHOUT_TUKEY: ------------------ | Branch (2961:5): [True: 9.99k, False: 26.6k] ------------------ 2962| 9.99k| FLAC__window_punchout_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end); 2963| 9.99k| break; 2964| 3.46k| case FLAC__APODIZATION_SUBDIVIDE_TUKEY: ------------------ | Branch (2964:5): [True: 3.46k, False: 33.1k] ------------------ 2965| 3.46k| FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p); 2966| 3.46k| break; 2967| 259| case FLAC__APODIZATION_WELCH: ------------------ | Branch (2967:5): [True: 259, False: 36.3k] ------------------ 2968| 259| FLAC__window_welch(encoder->private_->window[i], new_blocksize); 2969| 259| break; 2970| 0| default: ------------------ | Branch (2970:5): [True: 0, False: 36.6k] ------------------ 2971| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 2972| | /* double protection */ 2973| 0| FLAC__window_hann(encoder->private_->window[i], new_blocksize); 2974| 0| break; 2975| 36.6k| } 2976| 36.6k| } 2977| 14.6k| } 2978| 17.8k| if (new_blocksize <= FLAC__MAX_LPC_ORDER) { ------------------ | | 128| 17.8k|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (2978:6): [True: 8.24k, False: 9.63k] ------------------ 2979| | /* intrinsics autocorrelation routines do not all handle cases in which lag might be 2980| | * larger than data_len. Lag is one larger than the LPC order */ 2981| 8.24k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; 2982| 8.24k| } 2983| 17.8k|#endif 2984| | 2985| | return true; 2986| 17.8k|} stream_encoder.c:write_bitbuffer_: 2989| 273k|{ 2990| 273k| const FLAC__byte *buffer; 2991| 273k| size_t bytes; 2992| | 2993| 273k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(threadtask->frame)); ------------------ | | 38| 273k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 273k] | | ------------------ ------------------ 2994| | 2995| 273k| if(!FLAC__bitwriter_get_buffer(threadtask->frame, &buffer, &bytes)) { ------------------ | Branch (2995:5): [True: 0, False: 273k] ------------------ 2996| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 2997| 0| return false; 2998| 0| } 2999| | 3000| 273k| if(encoder->protected_->verify) { ------------------ | Branch (3000:5): [True: 228k, False: 45.1k] ------------------ 3001| 228k| encoder->private_->verify.output.data = buffer; 3002| 228k| encoder->private_->verify.output.bytes = bytes; 3003| 228k| if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) { ------------------ | Branch (3003:6): [True: 8.16k, False: 219k] ------------------ 3004| 8.16k| encoder->private_->verify.needs_magic_hack = true; 3005| 8.16k| } 3006| 219k| else { 3007| 219k| if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder) ------------------ | Branch (3007:7): [True: 0, False: 219k] ------------------ 3008| 219k| || (!is_last_block ------------------ | Branch (3008:12): [True: 212k, False: 7.68k] ------------------ 3009| 212k| && (FLAC__stream_encoder_get_verify_decoder_state(encoder) == FLAC__STREAM_DECODER_END_OF_STREAM)) ------------------ | Branch (3009:12): [True: 0, False: 212k] ------------------ 3010| 219k| || encoder->protected_->state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR /* Happens when error callback was used */) { ------------------ | Branch (3010:11): [True: 0, False: 219k] ------------------ 3011| 0| FLAC__bitwriter_release_buffer(threadtask->frame); 3012| 0| FLAC__bitwriter_clear(threadtask->frame); 3013| 0| if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) ------------------ | Branch (3013:8): [True: 0, False: 0] ------------------ 3014| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; 3015| 0| return false; 3016| 0| } 3017| 219k| } 3018| 228k| } 3019| | 3020| 273k| if(write_frame_(encoder, buffer, bytes, samples, is_last_block) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3020:5): [True: 0, False: 273k] ------------------ 3021| 0| FLAC__bitwriter_release_buffer(threadtask->frame); 3022| 0| FLAC__bitwriter_clear(threadtask->frame); 3023| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3024| 0| return false; 3025| 0| } 3026| | 3027| 273k| FLAC__bitwriter_release_buffer(threadtask->frame); 3028| 273k| FLAC__bitwriter_clear(threadtask->frame); 3029| | 3030| 273k| if(samples > 0) { ------------------ | Branch (3030:5): [True: 245k, False: 28.1k] ------------------ 3031| 245k| encoder->private_->streaminfo.data.stream_info.min_framesize = flac_min(bytes, encoder->private_->streaminfo.data.stream_info.min_framesize); ------------------ | | 56| 245k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (3031:66): [True: 12.2k, False: 232k] ------------------ 3032| 245k| encoder->private_->streaminfo.data.stream_info.max_framesize = flac_max(bytes, encoder->private_->streaminfo.data.stream_info.max_framesize); ------------------ | | 55| 245k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (3032:66): [True: 10.5k, False: 234k] ------------------ 3033| 245k| } 3034| | 3035| | return true; 3036| 273k|} stream_encoder.c:write_frame_: 3039| 273k|{ 3040| 273k| FLAC__StreamEncoderWriteStatus status; 3041| 273k| FLAC__uint64 output_position = 0; 3042| | 3043| |#if FLAC__HAS_OGG == 0 3044| | (void)is_last_block; 3045| |#endif 3046| | 3047| | /* 3048| | * Watch for the STREAMINFO block and first SEEKTABLE block to go by and store their offsets. 3049| | */ 3050| 273k| if(samples == 0) { ------------------ | Branch (3050:5): [True: 28.1k, False: 245k] ------------------ 3051| 28.1k| FLAC__MetadataType type = (buffer[0] & 0x7f); 3052| | 3053| | /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */ 3054| 28.1k| if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) { ------------------ | Branch (3054:6): [True: 28.1k, False: 0] | Branch (3054:42): [True: 0, False: 28.1k] ------------------ 3055| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3056| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 3057| 0| } 3058| | 3059| 28.1k| if(type == FLAC__METADATA_TYPE_STREAMINFO) ------------------ | Branch (3059:6): [True: 9.37k, False: 18.7k] ------------------ 3060| 9.37k| encoder->protected_->streaminfo_offset = output_position; 3061| 18.7k| else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0) ------------------ | Branch (3061:11): [True: 0, False: 18.7k] | Branch (3061:52): [True: 0, False: 0] ------------------ 3062| 0| encoder->protected_->seektable_offset = output_position; 3063| 28.1k| } 3064| | 3065| | /* 3066| | * Mark the current seek point if hit (if audio_offset == 0 that 3067| | * means we're still writing metadata and haven't hit the first 3068| | * frame yet) 3069| | */ 3070| 273k| if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) { ------------------ | Branch (3070:5): [True: 0, False: 273k] | Branch (3070:43): [True: 0, False: 0] | Branch (3070:84): [True: 0, False: 0] ------------------ 3071| 0| const uint32_t blocksize = FLAC__stream_encoder_get_blocksize(encoder); 3072| 0| const FLAC__uint64 frame_first_sample = encoder->private_->samples_written; 3073| 0| const FLAC__uint64 frame_last_sample = frame_first_sample + (FLAC__uint64)blocksize - 1; 3074| 0| FLAC__uint64 test_sample; 3075| 0| uint32_t i; 3076| 0| for(i = encoder->private_->first_seekpoint_to_check; i < encoder->private_->seek_table->num_points; i++) { ------------------ | Branch (3076:56): [True: 0, False: 0] ------------------ 3077| 0| test_sample = encoder->private_->seek_table->points[i].sample_number; 3078| 0| if(test_sample > frame_last_sample) { ------------------ | Branch (3078:7): [True: 0, False: 0] ------------------ 3079| 0| break; 3080| 0| } 3081| 0| else if(test_sample >= frame_first_sample) { ------------------ | Branch (3081:12): [True: 0, False: 0] ------------------ 3082| | /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */ 3083| 0| if(output_position == 0 && encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) { ------------------ | Branch (3083:8): [True: 0, False: 0] | Branch (3083:32): [True: 0, False: 0] | Branch (3083:68): [True: 0, False: 0] ------------------ 3084| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3085| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 3086| 0| } 3087| | 3088| 0| encoder->private_->seek_table->points[i].sample_number = frame_first_sample; 3089| 0| encoder->private_->seek_table->points[i].stream_offset = output_position - encoder->protected_->audio_offset; 3090| 0| encoder->private_->seek_table->points[i].frame_samples = blocksize; 3091| 0| encoder->private_->first_seekpoint_to_check++; 3092| | /* DO NOT: "break;" and here's why: 3093| | * The seektable template may contain more than one target 3094| | * sample for any given frame; we will keep looping, generating 3095| | * duplicate seekpoints for them, and we'll clean it up later, 3096| | * just before writing the seektable back to the metadata. 3097| | */ 3098| 0| } 3099| 0| else { 3100| 0| encoder->private_->first_seekpoint_to_check++; 3101| 0| } 3102| 0| } 3103| 0| } 3104| | 3105| 273k|#if FLAC__HAS_OGG 3106| 273k| if(encoder->private_->is_ogg) { ------------------ | Branch (3106:5): [True: 145k, False: 127k] ------------------ 3107| 145k| status = FLAC__ogg_encoder_aspect_write_callback_wrapper( 3108| 145k| &encoder->protected_->ogg_encoder_aspect, 3109| 145k| buffer, 3110| 145k| bytes, 3111| 145k| samples, 3112| 145k| encoder->private_->current_frame_number, 3113| 145k| is_last_block, 3114| 145k| (FLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback, 3115| 145k| encoder, 3116| 145k| encoder->private_->client_data 3117| 145k| ); 3118| 145k| } 3119| 127k| else 3120| 127k|#endif 3121| 127k| status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data); 3122| | 3123| 273k| if(status == FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3123:5): [True: 273k, False: 0] ------------------ 3124| 273k| encoder->private_->bytes_written += bytes; 3125| 273k| encoder->private_->samples_written += samples; 3126| | /* we keep a high watermark on the number of frames written because 3127| | * when the encoder goes back to write metadata, 'current_frame' 3128| | * will drop back to 0. 3129| | */ 3130| 273k| encoder->private_->frames_written = flac_max(encoder->private_->frames_written, encoder->private_->current_frame_number+1); ------------------ | | 55| 273k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (3130:39): [True: 0, False: 273k] ------------------ 3131| 273k| } 3132| 0| else 3133| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3134| | 3135| 273k| return status; 3136| 273k|} stream_encoder.c:update_metadata_: 3140| 6.41k|{ 3141| 6.41k| FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)]; 3142| 6.41k| const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo; 3143| 6.41k| FLAC__uint64 samples = metadata->data.stream_info.total_samples; 3144| 6.41k| const uint32_t min_framesize = metadata->data.stream_info.min_framesize; 3145| 6.41k| const uint32_t max_framesize = metadata->data.stream_info.max_framesize; 3146| 6.41k| const uint32_t bps = metadata->data.stream_info.bits_per_sample; 3147| 6.41k| FLAC__StreamEncoderSeekStatus seek_status; 3148| | 3149| 6.41k| FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); ------------------ | | 38| 6.41k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.41k] | | ------------------ ------------------ 3150| | 3151| | /* All this is based on intimate knowledge of the stream header 3152| | * layout, but a change to the header format that would break this 3153| | * would also break all streams encoded in the previous format. 3154| | */ 3155| | 3156| | /* 3157| | * Write MD5 signature 3158| | */ 3159| 6.41k| { 3160| 6.41k| const uint32_t md5_offset = 3161| 6.41k| FLAC__STREAM_METADATA_HEADER_LENGTH + ------------------ | | 872| 6.41k|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ 3162| 6.41k| ( 3163| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 3164| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 3165| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 3166| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 3167| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 3168| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 3169| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN + 3170| 6.41k| FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN 3171| 6.41k| ) / 8; 3172| | 3173| 6.41k| if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + md5_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) { ------------------ | Branch (3173:6): [True: 6.41k, False: 0] ------------------ 3174| 6.41k| if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) ------------------ | Branch (3174:7): [True: 0, False: 6.41k] ------------------ 3175| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3176| 6.41k| return; 3177| 6.41k| } 3178| 0| if(encoder->private_->write_callback(encoder, metadata->data.stream_info.md5sum, 16, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3178:6): [True: 0, False: 0] ------------------ 3179| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3180| 0| return; 3181| 0| } 3182| 0| } 3183| | 3184| | /* 3185| | * Write total samples 3186| | */ 3187| 0| { 3188| 0| const uint32_t total_samples_byte_offset = 3189| 0| FLAC__STREAM_METADATA_HEADER_LENGTH + ------------------ | | 872| 0|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ 3190| 0| ( 3191| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 3192| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 3193| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 3194| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 3195| 0| FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 3196| 0| FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 3197| 0| FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN 3198| 0| - 4 3199| 0| ) / 8; 3200| 0| FLAC__uint64 samples_uint36 = samples; 3201| 0| if(samples > (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) ------------------ | | 102| 0|#define FLAC__U64L(x) x##ULL ------------------ | Branch (3201:6): [True: 0, False: 0] ------------------ 3202| 0| samples_uint36 = 0; 3203| | 3204| 0| b[0] = ((FLAC__byte)(bps-1) << 4) | (FLAC__byte)((samples_uint36 >> 32) & 0x0F); 3205| 0| b[1] = (FLAC__byte)((samples_uint36 >> 24) & 0xFF); 3206| 0| b[2] = (FLAC__byte)((samples_uint36 >> 16) & 0xFF); 3207| 0| b[3] = (FLAC__byte)((samples_uint36 >> 8) & 0xFF); 3208| 0| b[4] = (FLAC__byte)(samples_uint36 & 0xFF); 3209| 0| if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + total_samples_byte_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) { ------------------ | Branch (3209:6): [True: 0, False: 0] ------------------ 3210| 0| if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) ------------------ | Branch (3210:7): [True: 0, False: 0] ------------------ 3211| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3212| 0| return; 3213| 0| } 3214| 0| if(encoder->private_->write_callback(encoder, b, 5, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3214:6): [True: 0, False: 0] ------------------ 3215| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3216| 0| return; 3217| 0| } 3218| 0| } 3219| | 3220| | /* 3221| | * Write min/max framesize 3222| | */ 3223| 0| { 3224| 0| const uint32_t min_framesize_offset = 3225| 0| FLAC__STREAM_METADATA_HEADER_LENGTH + ------------------ | | 872| 0|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ 3226| 0| ( 3227| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 3228| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN 3229| 0| ) / 8; 3230| | 3231| 0| b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF); 3232| 0| b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF); 3233| 0| b[2] = (FLAC__byte)(min_framesize & 0xFF); 3234| 0| b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF); 3235| 0| b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF); 3236| 0| b[5] = (FLAC__byte)(max_framesize & 0xFF); 3237| 0| if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + min_framesize_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) { ------------------ | Branch (3237:6): [True: 0, False: 0] ------------------ 3238| 0| if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) ------------------ | Branch (3238:7): [True: 0, False: 0] ------------------ 3239| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3240| 0| return; 3241| 0| } 3242| 0| if(encoder->private_->write_callback(encoder, b, 6, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3242:6): [True: 0, False: 0] ------------------ 3243| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3244| 0| return; 3245| 0| } 3246| 0| } 3247| | 3248| | /* 3249| | * Write seektable 3250| | */ 3251| 0| if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) { ------------------ | Branch (3251:5): [True: 0, False: 0] | Branch (3251:43): [True: 0, False: 0] | Branch (3251:92): [True: 0, False: 0] ------------------ 3252| 0| uint32_t i; 3253| | 3254| | /* Convert unused seekpoints to placeholders */ 3255| 0| for(i = 0; i < encoder->private_->seek_table->num_points; i++) ------------------ | Branch (3255:14): [True: 0, False: 0] ------------------ 3256| 0| if(encoder->private_->seek_table->points[i].sample_number > samples) ------------------ | Branch (3256:7): [True: 0, False: 0] ------------------ 3257| 0| encoder->private_->seek_table->points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 3258| | 3259| 0| FLAC__format_seektable_sort(encoder->private_->seek_table); 3260| | 3261| 0| FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table)); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 3262| | 3263| 0| if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->seektable_offset + FLAC__STREAM_METADATA_HEADER_LENGTH, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) { ------------------ | | 872| 0|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ | Branch (3263:6): [True: 0, False: 0] ------------------ 3264| 0| if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) ------------------ | Branch (3264:7): [True: 0, False: 0] ------------------ 3265| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3266| 0| return; 3267| 0| } 3268| | 3269| 0| for(i = 0; i < encoder->private_->seek_table->num_points; i++) { ------------------ | Branch (3269:14): [True: 0, False: 0] ------------------ 3270| 0| FLAC__uint64 xx; 3271| 0| uint32_t x; 3272| 0| xx = encoder->private_->seek_table->points[i].sample_number; 3273| 0| b[7] = (FLAC__byte)xx; xx >>= 8; 3274| 0| b[6] = (FLAC__byte)xx; xx >>= 8; 3275| 0| b[5] = (FLAC__byte)xx; xx >>= 8; 3276| 0| b[4] = (FLAC__byte)xx; xx >>= 8; 3277| 0| b[3] = (FLAC__byte)xx; xx >>= 8; 3278| 0| b[2] = (FLAC__byte)xx; xx >>= 8; 3279| 0| b[1] = (FLAC__byte)xx; xx >>= 8; 3280| 0| b[0] = (FLAC__byte)xx; xx >>= 8; 3281| 0| xx = encoder->private_->seek_table->points[i].stream_offset; 3282| 0| b[15] = (FLAC__byte)xx; xx >>= 8; 3283| 0| b[14] = (FLAC__byte)xx; xx >>= 8; 3284| 0| b[13] = (FLAC__byte)xx; xx >>= 8; 3285| 0| b[12] = (FLAC__byte)xx; xx >>= 8; 3286| 0| b[11] = (FLAC__byte)xx; xx >>= 8; 3287| 0| b[10] = (FLAC__byte)xx; xx >>= 8; 3288| 0| b[9] = (FLAC__byte)xx; xx >>= 8; 3289| 0| b[8] = (FLAC__byte)xx; xx >>= 8; 3290| 0| x = encoder->private_->seek_table->points[i].frame_samples; 3291| 0| b[17] = (FLAC__byte)x; x >>= 8; 3292| 0| b[16] = (FLAC__byte)x; x >>= 8; 3293| 0| if(encoder->private_->write_callback(encoder, b, 18, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3293:7): [True: 0, False: 0] ------------------ 3294| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3295| 0| return; 3296| 0| } 3297| 0| } 3298| 0| } 3299| 0|} stream_encoder.c:update_ogg_metadata_: 3304| 2.88k|{ 3305| | /* the # of bytes in the 1st packet that precede the STREAMINFO */ 3306| 2.88k| static const uint32_t FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH = 3307| 2.88k| FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH + ------------------ | | 39| 2.88k|#define FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH (1u) ------------------ 3308| 2.88k| FLAC__OGG_MAPPING_MAGIC_LENGTH + ------------------ | | 46| 2.88k|#define FLAC__OGG_MAPPING_MAGIC_LENGTH (4u) ------------------ 3309| 2.88k| FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH + ------------------ | | 54| 2.88k|#define FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH (1u) ------------------ 3310| 2.88k| FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH + ------------------ | | 57| 2.88k|#define FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH (1u) ------------------ 3311| 2.88k| FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH + ------------------ | | 62| 2.88k|#define FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH (2u) ------------------ 3312| 2.88k| FLAC__STREAM_SYNC_LENGTH ------------------ | | 179| 2.88k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 3313| 2.88k| ; 3314| 2.88k| FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)]; 3315| 2.88k| const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo; 3316| 2.88k| const FLAC__uint64 samples = metadata->data.stream_info.total_samples; 3317| 2.88k| const uint32_t min_framesize = metadata->data.stream_info.min_framesize; 3318| 2.88k| const uint32_t max_framesize = metadata->data.stream_info.max_framesize; 3319| 2.88k| ogg_page page; 3320| | 3321| 2.88k| FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); ------------------ | | 38| 2.88k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 2.88k] | | ------------------ ------------------ 3322| 2.88k| FLAC__ASSERT(0 != encoder->private_->seek_callback); ------------------ | | 38| 2.88k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 2.88k] | | ------------------ ------------------ 3323| | 3324| | /* Pre-check that client supports seeking, since we don't want the 3325| | * ogg_helper code to ever have to deal with this condition. 3326| | */ 3327| 2.88k| if(encoder->private_->seek_callback(encoder, 0, encoder->private_->client_data) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED) ------------------ | Branch (3327:5): [True: 2.88k, False: 0] ------------------ 3328| 2.88k| return; 3329| | 3330| | /* All this is based on intimate knowledge of the stream header 3331| | * layout, but a change to the header format that would break this 3332| | * would also break all streams encoded in the previous format. 3333| | */ 3334| | 3335| | /** 3336| | ** Write STREAMINFO stats 3337| | **/ 3338| 0| simple_ogg_page__init(&page); 3339| 0| if(!simple_ogg_page__get_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) { ------------------ | Branch (3339:5): [True: 0, False: 0] ------------------ 3340| 0| simple_ogg_page__clear(&page); 3341| 0| return; /* state already set */ 3342| 0| } 3343| | 3344| | /* 3345| | * Write MD5 signature 3346| | */ 3347| 0| { 3348| 0| const uint32_t md5_offset = 3349| 0| FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH + 3350| 0| FLAC__STREAM_METADATA_HEADER_LENGTH + ------------------ | | 872| 0|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ 3351| 0| ( 3352| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 3353| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 3354| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 3355| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 3356| 0| FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 3357| 0| FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 3358| 0| FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN + 3359| 0| FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN 3360| 0| ) / 8; 3361| | 3362| 0| if(md5_offset + 16 > (uint32_t)page.body_len) { ------------------ | Branch (3362:6): [True: 0, False: 0] ------------------ 3363| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 3364| 0| simple_ogg_page__clear(&page); 3365| 0| return; 3366| 0| } 3367| 0| memcpy(page.body + md5_offset, metadata->data.stream_info.md5sum, 16); 3368| 0| } 3369| | 3370| | /* 3371| | * Write total samples 3372| | */ 3373| 0| { 3374| 0| const uint32_t total_samples_byte_offset = 3375| 0| FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH + 3376| 0| FLAC__STREAM_METADATA_HEADER_LENGTH + ------------------ | | 872| 0|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ 3377| 0| ( 3378| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 3379| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 3380| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 3381| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 3382| 0| FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 3383| 0| FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 3384| 0| FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN 3385| 0| - 4 3386| 0| ) / 8; 3387| | 3388| 0| if(total_samples_byte_offset + 5 > (uint32_t)page.body_len) { ------------------ | Branch (3388:6): [True: 0, False: 0] ------------------ 3389| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 3390| 0| simple_ogg_page__clear(&page); 3391| 0| return; 3392| 0| } 3393| 0| b[0] = (FLAC__byte)page.body[total_samples_byte_offset] & 0xF0; 3394| 0| b[0] |= (FLAC__byte)((samples >> 32) & 0x0F); 3395| 0| b[1] = (FLAC__byte)((samples >> 24) & 0xFF); 3396| 0| b[2] = (FLAC__byte)((samples >> 16) & 0xFF); 3397| 0| b[3] = (FLAC__byte)((samples >> 8) & 0xFF); 3398| 0| b[4] = (FLAC__byte)(samples & 0xFF); 3399| 0| memcpy(page.body + total_samples_byte_offset, b, 5); 3400| 0| } 3401| | 3402| | /* 3403| | * Write min/max framesize 3404| | */ 3405| 0| { 3406| 0| const uint32_t min_framesize_offset = 3407| 0| FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH + 3408| 0| FLAC__STREAM_METADATA_HEADER_LENGTH + ------------------ | | 872| 0|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ 3409| 0| ( 3410| 0| FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 3411| 0| FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN 3412| 0| ) / 8; 3413| | 3414| 0| if(min_framesize_offset + 6 > (uint32_t)page.body_len) { ------------------ | Branch (3414:6): [True: 0, False: 0] ------------------ 3415| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 3416| 0| simple_ogg_page__clear(&page); 3417| 0| return; 3418| 0| } 3419| 0| b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF); 3420| 0| b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF); 3421| 0| b[2] = (FLAC__byte)(min_framesize & 0xFF); 3422| 0| b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF); 3423| 0| b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF); 3424| 0| b[5] = (FLAC__byte)(max_framesize & 0xFF); 3425| 0| memcpy(page.body + min_framesize_offset, b, 6); 3426| 0| } 3427| 0| if(!simple_ogg_page__set_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) { ------------------ | Branch (3427:5): [True: 0, False: 0] ------------------ 3428| 0| simple_ogg_page__clear(&page); 3429| 0| return; /* state already set */ 3430| 0| } 3431| 0| simple_ogg_page__clear(&page); 3432| 0|} stream_encoder.c:process_frame_: 3436| 245k|{ 3437| 245k| FLAC__uint16 crc; 3438| 245k|#ifdef FLAC__USE_THREADS 3439| 245k| uint32_t i; 3440| 245k|#endif 3441| 245k| if(encoder->protected_->num_threads < 2 || is_last_block) { ------------------ | Branch (3441:5): [True: 138k, False: 106k] | Branch (3441:45): [True: 742, False: 105k] ------------------ 3442| | 3443| 139k| FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); ------------------ | | 38| 139k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 139k] | | ------------------ ------------------ 3444| | 3445| | /* 3446| | * Accumulate raw signal to the MD5 signature 3447| | */ 3448| 139k| if(encoder->protected_->do_md5 && !FLAC__MD5Accumulate(&encoder->private_->md5context, (const FLAC__int32 * const *)encoder->private_->threadtask[0]->integer_signal, encoder->protected_->channels, encoder->protected_->blocksize, (encoder->protected_->bits_per_sample+7) / 8)) { ------------------ | Branch (3448:6): [True: 139k, False: 0] | Branch (3448:37): [True: 0, False: 139k] ------------------ 3449| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3450| 0| return false; 3451| 0| } 3452| | 3453| | /* 3454| | * Process the frame header and subframes into the frame bitbuffer 3455| | */ 3456| 139k| encoder->private_->threadtask[0]->current_frame_number = encoder->private_->current_frame_number; 3457| 139k| if(!process_subframes_(encoder, encoder->private_->threadtask[0])) { ------------------ | Branch (3457:6): [True: 0, False: 139k] ------------------ 3458| | /* the above function sets the state for us in case of an error */ 3459| 0| return false; 3460| 0| } 3461| | 3462| | /* 3463| | * Zero-pad the frame to a byte_boundary 3464| | */ 3465| 139k| if(!FLAC__bitwriter_zero_pad_to_byte_boundary(encoder->private_->threadtask[0]->frame)) { ------------------ | Branch (3465:6): [True: 0, False: 139k] ------------------ 3466| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3467| 0| return false; 3468| 0| } 3469| | 3470| | /* 3471| | * CRC-16 the whole thing 3472| | */ 3473| 139k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->threadtask[0]->frame)); ------------------ | | 38| 139k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 139k] | | ------------------ ------------------ 3474| 139k| if( 3475| 139k| !FLAC__bitwriter_get_write_crc16(encoder->private_->threadtask[0]->frame, &crc) || ------------------ | Branch (3475:4): [True: 0, False: 139k] ------------------ 3476| 139k| !FLAC__bitwriter_write_raw_uint32(encoder->private_->threadtask[0]->frame, crc, FLAC__FRAME_FOOTER_CRC_LEN) ------------------ | Branch (3476:4): [True: 0, False: 139k] ------------------ 3477| 139k| ) { 3478| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3479| 0| return false; 3480| 0| } 3481| | 3482| | /* 3483| | * Write it 3484| | */ 3485| 139k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], encoder->protected_->blocksize, is_last_block)) { ------------------ | Branch (3485:6): [True: 0, False: 139k] ------------------ 3486| | /* the above function sets the state for us in case of an error */ 3487| 0| return false; 3488| 0| } 3489| 139k| } 3490| 105k| else { 3491| 105k|#ifdef FLAC__USE_THREADS 3492| | /* This bit is quite complicated, so here are some pointers: 3493| | * 3494| | * When this bit of code is reached for the first time, new threads are spawned and 3495| | * threadtasks are populated until the total number of threads equals the requested number 3496| | * of threads. Next, threadtasks are populated until they there are no more available. 3497| | * Next, this main thread checks whether the threadtask that is due chronologically is 3498| | * done. If it is, the bitbuffer is written and the threadtask memory reused for the next 3499| | * frame. If it is not done, the main thread checks whether there is enough work left in the 3500| | * queue. If there is a lot of work left, the main thread starts on some of it too. 3501| | * If not a lot of work is left, the main thread goes to sleep until the frame due first is 3502| | * finished. 3503| | * 3504| | * - encoder->private_->next_thread is the number of the next thread to be created or, when 3505| | * the required number of threads is created, the next threadtask to be populated, 3506| | * or, when all threadtasks have been populated once, the next threadtask that needs 3507| | * to finish and thus reused. 3508| | * - encoder->private_->next_threadtask is the number of the next threadtask that a thread 3509| | * can start work on. 3510| | * 3511| | * So, in effect, next_thread is (after startup) a pointer considering the chronological 3512| | * order, so input/output isn't shuffled. next_threadtask is a pointer to the next task that 3513| | * hasn't been picked up by a thread yet. This distinction enables threads to work on frames 3514| | * in a non-chronological order 3515| | * 3516| | * encoder->protected_->num_threads is the max number of threads that can be spawned 3517| | * encoder->private_->num_created_threads is the number of threads that has been spawned 3518| | * encoder->private_->num_threadtasks keeps track of how many threadtasks are available 3519| | * encoder->private_->num_started_threadtasks keeps track of how many threadtasks have been populated 3520| | * 3521| | * NOTE: thread no. 0 and threadtask no. 0 are reserved for non-threaded operations, so next_thread 3522| | * and next_threadtask start at 1 3523| | */ 3524| 105k| if(encoder->private_->num_created_threads < encoder->protected_->num_threads) { ------------------ | Branch (3524:6): [True: 2.72k, False: 102k] ------------------ 3525| | /* Create a new thread */ 3526| 2.72k| FLAC__thrd_create(&encoder->private_->thread[encoder->private_->next_thread], ------------------ | | 98| 2.72k|#define FLAC__thrd_create(thread, func, arg) pthread_create(thread, NULL, func, arg) ------------------ 3527| 2.72k| process_frame_thread_, encoder); 3528| 2.72k| encoder->private_->num_created_threads++; 3529| 2.72k| } 3530| 102k| else if(encoder->private_->num_started_threadtasks == encoder->private_->num_threadtasks) { ------------------ | Branch (3530:11): [True: 100k, False: 2.87k] ------------------ 3531| | /* If the first task in the queue is still running, check whether there is enough work 3532| | * left in the queue. If there is, start on some 3533| | * First, check whether the mutex for the next due task is locked or free. If it is free (and thus acquired now) and 3534| | * the task is done, proceed to the next bit (writing the bitbuffer). If it is either currently locked or not yet 3535| | * processed, choose between starting on some work (if there is enough work in the queue) or waiting for the task 3536| | * to finish. Either way, release the mutex first, so it doesn't get interlocked with the work queue mutex */ 3537| 100k| int mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 104| 100k|#define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 93| 93.7k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 94| 100k|#define FLAC__thrd_busy EBUSY | | ------------------ | | | Branch (104:47): [True: 93.7k, False: 6.25k] | | ------------------ ------------------ int mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 93| 100k|#define FLAC__thrd_success 0 ------------------ | Branch (3537:23): [True: 93.7k, False: 6.25k] ------------------ 3538| 113k| while(mutex_result || !encoder->private_->threadtask[encoder->private_->next_thread]->task_done) { ------------------ | Branch (3538:10): [True: 9.12k, False: 104k] | Branch (3538:26): [True: 4.08k, False: 100k] ------------------ 3539| 13.2k| if(!mutex_result) ------------------ | Branch (3539:8): [True: 4.08k, False: 9.12k] ------------------ 3540| 4.08k| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 4.08k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3541| | 3542| 13.2k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 13.2k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3543| 13.2k| if(encoder->private_->num_available_threadtasks > (encoder->protected_->num_threads - 1)) { ------------------ | Branch (3543:8): [True: 12.2k, False: 972] ------------------ 3544| 12.2k| FLAC__StreamEncoderThreadTask * task = NULL; 3545| 12.2k| task = encoder->private_->threadtask[encoder->private_->next_threadtask]; 3546| 12.2k| encoder->private_->num_available_threadtasks--; 3547| 12.2k| encoder->private_->next_threadtask++; 3548| 12.2k| if(encoder->private_->next_threadtask == encoder->private_->num_threadtasks) ------------------ | Branch (3548:9): [True: 1.95k, False: 10.2k] ------------------ 3549| 1.95k| encoder->private_->next_threadtask = 1; 3550| 12.2k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 12.2k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3551| 12.2k| FLAC__mtx_lock(&task->mutex_this_task); ------------------ | | 105| 12.2k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3552| 12.2k| process_frame_thread_inner_(encoder, task); 3553| 12.2k| mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 104| 12.2k|#define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 93| 9.37k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 94| 12.2k|#define FLAC__thrd_busy EBUSY | | ------------------ | | | Branch (104:47): [True: 9.37k, False: 2.86k] | | ------------------ ------------------ mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 93| 12.2k|#define FLAC__thrd_success 0 ------------------ | Branch (3553:21): [True: 9.37k, False: 2.86k] ------------------ 3554| 12.2k| } 3555| 972| else { 3556| 972| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 972|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3557| 972| FLAC__mtx_lock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 105| 972|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3558| 1.01k| while(!encoder->private_->threadtask[encoder->private_->next_thread]->task_done) ------------------ | Branch (3558:12): [True: 39, False: 972] ------------------ 3559| 39| FLAC__cnd_wait(&encoder->private_->threadtask[encoder->private_->next_thread]->cond_task_done,&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 113| 39|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3560| 972| mutex_result = 0; 3561| 972| } 3562| 13.2k| } 3563| | /* Task is finished, write bitbuffer */ 3564| 100k| if(!encoder->private_->threadtask[encoder->private_->next_thread]->returnvalue) { ------------------ | Branch (3564:7): [True: 0, False: 100k] ------------------ 3565| 0| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 0|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3566| 0| return false; 3567| 0| } 3568| 100k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[encoder->private_->next_thread], encoder->protected_->blocksize, is_last_block)) { ------------------ | Branch (3568:7): [True: 0, False: 100k] ------------------ 3569| | /* the above function sets the state for us in case of an error */ 3570| 0| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 0|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3571| 0| return false; 3572| 0| } 3573| 100k| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 100k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3574| 100k| } 3575| | /* Copy input data for MD5 calculation */ 3576| 105k| if(encoder->protected_->do_md5) { ------------------ | Branch (3576:6): [True: 105k, False: 0] ------------------ 3577| 105k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 105k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3578| 106k| while(encoder->private_->md5_fifo.tail + encoder->protected_->blocksize > encoder->private_->md5_fifo.size) { ------------------ | Branch (3578:10): [True: 383, False: 105k] ------------------ 3579| 383| FLAC__cnd_wait(&encoder->private_->cond_md5_emptied,&encoder->private_->mutex_work_queue); ------------------ | | 113| 383|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3580| 383| } 3581| 105k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 105k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3582| 105k| FLAC__mtx_lock(&encoder->private_->mutex_md5_fifo); ------------------ | | 105| 105k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3583| 216k| for(i = 0; i < encoder->protected_->channels; i++) ------------------ | Branch (3583:15): [True: 110k, False: 105k] ------------------ 3584| 110k| memcpy(encoder->private_->md5_fifo.data[i]+encoder->private_->md5_fifo.tail, encoder->private_->threadtask[0]->integer_signal[i], encoder->protected_->blocksize * sizeof(encoder->private_->threadtask[0]->integer_signal[i][0])); 3585| 105k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 105k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3586| 105k| encoder->private_->md5_fifo.tail += encoder->protected_->blocksize; 3587| 105k| FLAC__cnd_signal(&encoder->private_->cond_work_available); ------------------ | | 112| 105k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3588| 105k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 105k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3589| 105k| FLAC__mtx_unlock(&encoder->private_->mutex_md5_fifo); ------------------ | | 106| 105k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3590| 105k| } 3591| | 3592| | /* Copy input data for frame creation */ 3593| 105k| FLAC__mtx_lock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 105| 105k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3594| 216k| for(i = 0; i < encoder->protected_->channels; i++) ------------------ | Branch (3594:14): [True: 110k, False: 105k] ------------------ 3595| 110k| memcpy(encoder->private_->threadtask[encoder->private_->next_thread]->integer_signal[i], encoder->private_->threadtask[0]->integer_signal[i], encoder->protected_->blocksize * sizeof(encoder->private_->threadtask[0]->integer_signal[i][0])); 3596| | 3597| 105k| encoder->private_->threadtask[encoder->private_->next_thread]->current_frame_number = encoder->private_->current_frame_number; 3598| 105k| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 105k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3599| | 3600| 105k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 105k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3601| 105k| if(encoder->private_->num_started_threadtasks < encoder->private_->num_threadtasks) ------------------ | Branch (3601:6): [True: 5.60k, False: 100k] ------------------ 3602| 5.60k| encoder->private_->num_started_threadtasks++; 3603| 105k| encoder->private_->num_available_threadtasks++; 3604| 105k| encoder->private_->threadtask[encoder->private_->next_thread]->task_done = false; 3605| 105k| FLAC__cnd_signal(&encoder->private_->cond_work_available); ------------------ | | 112| 105k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3606| 105k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 105k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3607| | 3608| 105k| encoder->private_->next_thread++; 3609| 105k| if(encoder->private_->next_thread == encoder->private_->num_threadtasks) ------------------ | Branch (3609:6): [True: 11.5k, False: 94.1k] ------------------ 3610| 11.5k| encoder->private_->next_thread = 1; 3611| |#else 3612| | FLAC__ASSERT(0); 3613| |#endif 3614| 105k| } 3615| | 3616| | /* 3617| | * Get ready for the next frame 3618| | */ 3619| 245k| encoder->private_->current_sample_number = 0; 3620| 245k| encoder->private_->current_frame_number++; 3621| 245k| encoder->private_->streaminfo.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize; 3622| | 3623| | return true; 3624| 245k|} stream_encoder.c:process_subframes_: 3748| 244k|{ 3749| 244k| FLAC__FrameHeader frame_header; 3750| 244k| uint32_t channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order; 3751| 244k| FLAC__bool do_independent, do_mid_side, all_subframes_constant = true; 3752| | 3753| 244k| threadtask->disable_constant_subframes = encoder->private_->disable_constant_subframes; 3754| | 3755| | /* 3756| | * Calculate the min,max Rice partition orders 3757| | */ 3758| | 3759| 244k| max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize); 3760| 244k| max_partition_order = flac_min(max_partition_order, encoder->protected_->max_residual_partition_order); ------------------ | | 56| 244k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (3760:24): [True: 156k, False: 88.3k] ------------------ 3761| 244k| min_partition_order = flac_min(min_partition_order, max_partition_order); ------------------ | | 56| 244k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (3761:24): [True: 36.1k, False: 208k] ------------------ 3762| | 3763| | /* 3764| | * Setup the frame 3765| | */ 3766| 244k| frame_header.blocksize = encoder->protected_->blocksize; 3767| 244k| frame_header.sample_rate = encoder->protected_->sample_rate; 3768| 244k| frame_header.channels = encoder->protected_->channels; 3769| 244k| frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */ 3770| 244k| frame_header.bits_per_sample = encoder->protected_->bits_per_sample; 3771| 244k| frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER; 3772| 244k| frame_header.number.frame_number = threadtask->current_frame_number; 3773| | 3774| | /* 3775| | * Figure out what channel assignments to try 3776| | */ 3777| 244k| if(encoder->protected_->do_mid_side_stereo) { ------------------ | Branch (3777:5): [True: 44.9k, False: 199k] ------------------ 3778| 44.9k| if(encoder->protected_->loose_mid_side_stereo) { ------------------ | Branch (3778:6): [True: 3.15k, False: 41.7k] ------------------ 3779| 3.15k| uint64_t sumAbsLR = 0, sumAbsMS = 0; 3780| 3.15k| uint32_t i; 3781| 3.15k| if(encoder->protected_->bits_per_sample < 25) { ------------------ | Branch (3781:7): [True: 1.01k, False: 2.13k] ------------------ 3782| 17.8k| for(i = 1; i < encoder->protected_->blocksize; i++) { ------------------ | Branch (3782:16): [True: 16.7k, False: 1.01k] ------------------ 3783| 16.7k| int32_t predictionLeft = threadtask->integer_signal[0][i] - threadtask->integer_signal[0][i-1]; 3784| 16.7k| int32_t predictionRight = threadtask->integer_signal[1][i] - threadtask->integer_signal[1][i-1]; 3785| 16.7k| sumAbsLR += abs(predictionLeft) + abs(predictionRight); 3786| 16.7k| sumAbsMS += abs((predictionLeft + predictionRight) >> 1) + abs(predictionLeft - predictionRight); 3787| 16.7k| } 3788| 1.01k| } 3789| 2.13k| else { /* bps 25 or higher */ 3790| 1.50M| for(i = 1; i < encoder->protected_->blocksize; i++) { ------------------ | Branch (3790:16): [True: 1.49M, False: 2.13k] ------------------ 3791| 1.49M| int64_t predictionLeft = (int64_t)threadtask->integer_signal[0][i] - (int64_t)threadtask->integer_signal[0][i-1]; 3792| 1.49M| int64_t predictionRight = (int64_t)threadtask->integer_signal[1][i] - (int64_t)threadtask->integer_signal[1][i-1]; 3793| 1.49M| sumAbsLR += local_abs64(predictionLeft) + local_abs64(predictionRight); ------------------ | | 87| 1.49M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 50.6k, False: 1.44M] | | ------------------ ------------------ sumAbsLR += local_abs64(predictionLeft) + local_abs64(predictionRight); ------------------ | | 87| 1.49M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 51.1k, False: 1.44M] | | ------------------ ------------------ 3794| 1.49M| sumAbsMS += local_abs64((predictionLeft + predictionRight) >> 1) + local_abs64(predictionLeft - predictionRight); ------------------ | | 87| 1.49M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 58.7k, False: 1.44M] | | ------------------ ------------------ sumAbsMS += local_abs64((predictionLeft + predictionRight) >> 1) + local_abs64(predictionLeft - predictionRight); ------------------ | | 87| 1.49M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 56.1k, False: 1.44M] | | ------------------ ------------------ 3795| 1.49M| } 3796| 2.13k| } 3797| 3.15k| if(sumAbsLR < sumAbsMS) { ------------------ | Branch (3797:7): [True: 948, False: 2.20k] ------------------ 3798| 948| do_independent = true; 3799| 948| do_mid_side = false; 3800| 948| frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; 3801| 948| } 3802| 2.20k| else { 3803| 2.20k| do_independent = false; 3804| 2.20k| do_mid_side = true; 3805| 2.20k| frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE; 3806| 2.20k| } 3807| 3.15k| } 3808| 41.7k| else { 3809| 41.7k| do_independent = true; 3810| 41.7k| do_mid_side = true; 3811| 41.7k| } 3812| 44.9k| } 3813| 199k| else { 3814| 199k| do_independent = true; 3815| 199k| do_mid_side = false; 3816| 199k| } 3817| | 3818| 244k| FLAC__ASSERT(do_independent || do_mid_side); ------------------ | | 38| 247k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 242k, False: 2.20k] | | | Branch (38:30): [True: 2.20k, False: 0] | | ------------------ ------------------ 3819| | 3820| | /* 3821| | * Prepare mid-side signals if applicable 3822| | */ 3823| 244k| if(do_mid_side) { ------------------ | Branch (3823:5): [True: 43.9k, False: 200k] ------------------ 3824| 43.9k| uint32_t i; 3825| 43.9k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 3826| 43.9k| if(encoder->protected_->bits_per_sample < 32) ------------------ | Branch (3826:6): [True: 13.7k, False: 30.2k] ------------------ 3827| 347k| for(i = 0; i < encoder->protected_->blocksize; i++) { ------------------ | Branch (3827:15): [True: 333k, False: 13.7k] ------------------ 3828| 333k| threadtask->integer_signal_mid_side[1][i] = threadtask->integer_signal[0][i] - threadtask->integer_signal[1][i]; 3829| 333k| threadtask->integer_signal_mid_side[0][i] = (threadtask->integer_signal[0][i] + threadtask->integer_signal[1][i]) >> 1; /* NOTE: not the same as 'mid = (signal[0][j] + signal[1][j]) / 2' ! */ 3830| 333k| } 3831| 30.2k| else 3832| 4.03M| for(i = 0; i <= encoder->protected_->blocksize; i++) { ------------------ | Branch (3832:15): [True: 4.00M, False: 30.2k] ------------------ 3833| 4.00M| threadtask->integer_signal_33bit_side[i] = (FLAC__int64)threadtask->integer_signal[0][i] - (FLAC__int64)threadtask->integer_signal[1][i]; 3834| 4.00M| threadtask->integer_signal_mid_side[0][i] = ((FLAC__int64)threadtask->integer_signal[0][i] + (FLAC__int64)threadtask->integer_signal[1][i]) >> 1; /* NOTE: not the same as 'mid = (signal[0][j] + signal[1][j]) / 2' ! */ 3835| 4.00M| } 3836| 43.9k| } 3837| | 3838| | 3839| | /* 3840| | * Check for wasted bits; set effective bps for each subframe 3841| | */ 3842| 244k| if(do_independent) { ------------------ | Branch (3842:5): [True: 242k, False: 2.44k] ------------------ 3843| 551k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (3843:20): [True: 308k, False: 242k] ------------------ 3844| 308k| uint32_t w = get_wasted_bits_(threadtask->integer_signal[channel], encoder->protected_->blocksize); 3845| 308k| if (w > encoder->protected_->bits_per_sample) { ------------------ | Branch (3845:8): [True: 0, False: 308k] ------------------ 3846| 0| w = encoder->protected_->bits_per_sample; 3847| 0| } 3848| 308k| threadtask->subframe_workspace[channel][0].wasted_bits = threadtask->subframe_workspace[channel][1].wasted_bits = w; 3849| 308k| threadtask->subframe_bps[channel] = encoder->protected_->bits_per_sample - w; 3850| 308k| } 3851| 242k| } 3852| 244k| if(do_mid_side) { ------------------ | Branch (3852:5): [True: 43.9k, False: 200k] ------------------ 3853| 43.9k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 3854| 131k| for(channel = 0; channel < 2; channel++) { ------------------ | Branch (3854:20): [True: 87.9k, False: 43.9k] ------------------ 3855| 87.9k| uint32_t w; 3856| 87.9k| if(encoder->protected_->bits_per_sample < 32 || channel == 0) ------------------ | Branch (3856:7): [True: 27.4k, False: 60.4k] | Branch (3856:52): [True: 30.2k, False: 30.2k] ------------------ 3857| 57.6k| w = get_wasted_bits_(threadtask->integer_signal_mid_side[channel], encoder->protected_->blocksize); 3858| 30.2k| else 3859| 30.2k| w = get_wasted_bits_wide_(threadtask->integer_signal_33bit_side, threadtask->integer_signal_mid_side[channel], encoder->protected_->blocksize); 3860| | 3861| 87.9k| if (w > encoder->protected_->bits_per_sample) { ------------------ | Branch (3861:8): [True: 0, False: 87.9k] ------------------ 3862| 0| w = encoder->protected_->bits_per_sample; 3863| 0| } 3864| 87.9k| threadtask->subframe_workspace_mid_side[channel][0].wasted_bits = threadtask->subframe_workspace_mid_side[channel][1].wasted_bits = w; 3865| 87.9k| threadtask->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1); ------------------ | Branch (3865:93): [True: 43.9k, False: 43.9k] ------------------ 3866| 87.9k| } 3867| 43.9k| } 3868| | 3869| | /* 3870| | * First do a normal encoding pass of each independent channel 3871| | */ 3872| 244k| if(do_independent) { ------------------ | Branch (3872:5): [True: 242k, False: 2.74k] ------------------ 3873| 550k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (3873:20): [True: 308k, False: 242k] ------------------ 3874| 308k| if(encoder->protected_->limit_min_bitrate && all_subframes_constant && (channel + 1) == encoder->protected_->channels){ ------------------ | Branch (3874:7): [True: 114k, False: 193k] | Branch (3874:49): [True: 97.3k, False: 17.4k] | Branch (3874:75): [True: 74.0k, False: 23.2k] ------------------ 3875| | /* This frame contains only constant subframes at this point. 3876| | * To prevent the frame from becoming too small, make sure 3877| | * the last subframe isn't constant */ 3878| 73.9k| threadtask->disable_constant_subframes = true; 3879| 73.9k| } 3880| 308k| if(! ------------------ | Branch (3880:7): [True: 0, False: 308k] ------------------ 3881| 308k| process_subframe_( 3882| 308k| encoder, 3883| 308k| threadtask, 3884| 308k| min_partition_order, 3885| 308k| max_partition_order, 3886| 308k| &frame_header, 3887| 308k| threadtask->subframe_bps[channel], 3888| 308k| threadtask->integer_signal[channel], 3889| 308k| threadtask->subframe_workspace_ptr[channel], 3890| 308k| threadtask->partitioned_rice_contents_workspace_ptr[channel], 3891| 308k| threadtask->residual_workspace[channel], 3892| 308k| threadtask->best_subframe+channel, 3893| 308k| threadtask->best_subframe_bits+channel 3894| 308k| ) 3895| 308k| ) 3896| 0| return false; 3897| 308k| if(threadtask->subframe_workspace[channel][threadtask->best_subframe[channel]].type != FLAC__SUBFRAME_TYPE_CONSTANT) ------------------ | Branch (3897:7): [True: 208k, False: 99.4k] ------------------ 3898| 208k| all_subframes_constant = false; 3899| 308k| } 3900| 242k| } 3901| | 3902| | /* 3903| | * Now do mid and side channels if requested 3904| | */ 3905| 244k| if(do_mid_side) { ------------------ | Branch (3905:5): [True: 43.9k, False: 200k] ------------------ 3906| 43.9k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 43.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.9k] | | ------------------ ------------------ 3907| | 3908| 131k| for(channel = 0; channel < 2; channel++) { ------------------ | Branch (3908:20): [True: 87.9k, False: 43.9k] ------------------ 3909| 87.9k| void *integer_signal_; 3910| 87.9k| if(threadtask->subframe_bps_mid_side[channel] <= 32) ------------------ | Branch (3910:7): [True: 74.7k, False: 13.1k] ------------------ 3911| 74.7k| integer_signal_ = threadtask->integer_signal_mid_side[channel]; 3912| 13.1k| else 3913| 13.1k| integer_signal_ = threadtask->integer_signal_33bit_side; 3914| 87.9k| if(! ------------------ | Branch (3914:7): [True: 0, False: 87.9k] ------------------ 3915| 87.9k| process_subframe_( 3916| 87.9k| encoder, 3917| 87.9k| threadtask, 3918| 87.9k| min_partition_order, 3919| 87.9k| max_partition_order, 3920| 87.9k| &frame_header, 3921| 87.9k| threadtask->subframe_bps_mid_side[channel], 3922| 87.9k| integer_signal_, 3923| 87.9k| threadtask->subframe_workspace_ptr_mid_side[channel], 3924| 87.9k| threadtask->partitioned_rice_contents_workspace_ptr_mid_side[channel], 3925| 87.9k| threadtask->residual_workspace_mid_side[channel], 3926| 87.9k| threadtask->best_subframe_mid_side+channel, 3927| 87.9k| threadtask->best_subframe_bits_mid_side+channel 3928| 87.9k| ) 3929| 87.9k| ) 3930| 0| return false; 3931| 87.9k| } 3932| 43.9k| } 3933| | 3934| | /* 3935| | * Compose the frame bitbuffer 3936| | */ 3937| 244k| if((do_independent && do_mid_side) || encoder->protected_->loose_mid_side_stereo) { ------------------ | Branch (3937:6): [True: 241k, False: 3.36k] | Branch (3937:24): [True: 41.7k, False: 199k] | Branch (3937:40): [True: 3.13k, False: 198k] ------------------ 3938| 44.9k| uint32_t left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */ 3939| 44.9k| FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */ 3940| 44.9k| FLAC__ChannelAssignment channel_assignment; 3941| | 3942| 44.9k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 44.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.9k] | | ------------------ ------------------ 3943| | 3944| 44.9k| if(!encoder->protected_->loose_mid_side_stereo) { ------------------ | Branch (3944:6): [True: 41.7k, False: 3.15k] ------------------ 3945| 41.7k| uint32_t bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */ 3946| 41.7k| uint32_t min_bits; 3947| 41.7k| int ca; 3948| | 3949| 41.7k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT == 0); ------------------ | | 38| 41.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.7k] | | ------------------ ------------------ 3950| 41.7k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE == 1); ------------------ | | 38| 41.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.7k] | | ------------------ ------------------ 3951| 41.7k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE == 2); ------------------ | | 38| 41.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.7k] | | ------------------ ------------------ 3952| 41.7k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_MID_SIDE == 3); ------------------ | | 38| 41.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.7k] | | ------------------ ------------------ 3953| | 3954| | /* We have to figure out which channel assignent results in the smallest frame */ 3955| 41.7k| bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = threadtask->best_subframe_bits [0] + threadtask->best_subframe_bits [1]; 3956| 41.7k| bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE ] = threadtask->best_subframe_bits [0] + threadtask->best_subframe_bits_mid_side[1]; 3957| 41.7k| bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = threadtask->best_subframe_bits [1] + threadtask->best_subframe_bits_mid_side[1]; 3958| 41.7k| bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE ] = threadtask->best_subframe_bits_mid_side[0] + threadtask->best_subframe_bits_mid_side[1]; 3959| | 3960| 41.7k| channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; 3961| 41.7k| min_bits = bits[channel_assignment]; 3962| | 3963| | /* When doing loose mid-side stereo, ignore left-side 3964| | * and right-side options */ 3965| 166k| for(ca = 1; ca <= 3; ca++) { ------------------ | Branch (3965:16): [True: 125k, False: 41.7k] ------------------ 3966| 125k| if(bits[ca] < min_bits) { ------------------ | Branch (3966:8): [True: 45.6k, False: 79.6k] ------------------ 3967| 45.6k| min_bits = bits[ca]; 3968| 45.6k| channel_assignment = (FLAC__ChannelAssignment)ca; 3969| 45.6k| } 3970| 125k| } 3971| 41.7k| frame_header.channel_assignment = channel_assignment; 3972| 41.7k| } 3973| | 3974| 44.9k| if(!FLAC__frame_add_header(&frame_header, threadtask->frame)) { ------------------ | Branch (3974:6): [True: 0, False: 44.9k] ------------------ 3975| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3976| 0| return false; 3977| 0| } 3978| | 3979| 44.9k| switch(frame_header.channel_assignment) { 3980| 8.97k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (3980:4): [True: 8.97k, False: 35.9k] ------------------ 3981| 8.97k| left_subframe = &threadtask->subframe_workspace [0][threadtask->best_subframe [0]]; 3982| 8.97k| right_subframe = &threadtask->subframe_workspace [1][threadtask->best_subframe [1]]; 3983| 8.97k| break; 3984| 17.2k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (3984:4): [True: 17.2k, False: 27.6k] ------------------ 3985| 17.2k| left_subframe = &threadtask->subframe_workspace [0][threadtask->best_subframe [0]]; 3986| 17.2k| right_subframe = &threadtask->subframe_workspace_mid_side[1][threadtask->best_subframe_mid_side[1]]; 3987| 17.2k| break; 3988| 7.66k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (3988:4): [True: 7.66k, False: 37.2k] ------------------ 3989| 7.66k| left_subframe = &threadtask->subframe_workspace_mid_side[1][threadtask->best_subframe_mid_side[1]]; 3990| 7.66k| right_subframe = &threadtask->subframe_workspace [1][threadtask->best_subframe [1]]; 3991| 7.66k| break; 3992| 11.0k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (3992:4): [True: 11.0k, False: 33.8k] ------------------ 3993| 11.0k| left_subframe = &threadtask->subframe_workspace_mid_side[0][threadtask->best_subframe_mid_side[0]]; 3994| 11.0k| right_subframe = &threadtask->subframe_workspace_mid_side[1][threadtask->best_subframe_mid_side[1]]; 3995| 11.0k| break; 3996| 0| default: ------------------ | Branch (3996:4): [True: 0, False: 44.9k] ------------------ 3997| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 3998| 44.9k| } 3999| | 4000| 44.9k| switch(frame_header.channel_assignment) { 4001| 8.97k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (4001:4): [True: 8.97k, False: 35.9k] ------------------ 4002| 8.97k| left_bps = threadtask->subframe_bps [0]; 4003| 8.97k| right_bps = threadtask->subframe_bps [1]; 4004| 8.97k| break; 4005| 17.2k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (4005:4): [True: 17.2k, False: 27.6k] ------------------ 4006| 17.2k| left_bps = threadtask->subframe_bps [0]; 4007| 17.2k| right_bps = threadtask->subframe_bps_mid_side[1]; 4008| 17.2k| break; 4009| 7.66k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (4009:4): [True: 7.66k, False: 37.2k] ------------------ 4010| 7.66k| left_bps = threadtask->subframe_bps_mid_side[1]; 4011| 7.66k| right_bps = threadtask->subframe_bps [1]; 4012| 7.66k| break; 4013| 11.0k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (4013:4): [True: 11.0k, False: 33.8k] ------------------ 4014| 11.0k| left_bps = threadtask->subframe_bps_mid_side[0]; 4015| 11.0k| right_bps = threadtask->subframe_bps_mid_side[1]; 4016| 11.0k| break; 4017| 0| default: ------------------ | Branch (4017:4): [True: 0, False: 44.9k] ------------------ 4018| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 4019| 44.9k| } 4020| | 4021| | /* note that encoder_add_subframe_ sets the state for us in case of an error */ 4022| 44.9k| if(!add_subframe_(encoder, frame_header.blocksize, left_bps , left_subframe , threadtask->frame)) ------------------ | Branch (4022:6): [True: 0, False: 44.9k] ------------------ 4023| 0| return false; 4024| 44.9k| if(!add_subframe_(encoder, frame_header.blocksize, right_bps, right_subframe, threadtask->frame)) ------------------ | Branch (4024:6): [True: 0, False: 44.9k] ------------------ 4025| 0| return false; 4026| 44.9k| } 4027| 199k| else { 4028| 199k| FLAC__ASSERT(do_independent); ------------------ | | 38| 199k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 199k] | | ------------------ ------------------ 4029| 199k| if(!FLAC__frame_add_header(&frame_header, threadtask->frame)) { ------------------ | Branch (4029:6): [True: 0, False: 199k] ------------------ 4030| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4031| 0| return false; 4032| 0| } 4033| | 4034| 421k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (4034:20): [True: 221k, False: 199k] ------------------ 4035| 221k| if(!add_subframe_(encoder, frame_header.blocksize, threadtask->subframe_bps[channel], &threadtask->subframe_workspace[channel][threadtask->best_subframe[channel]], threadtask->frame)) { ------------------ | Branch (4035:7): [True: 0, False: 221k] ------------------ 4036| | /* the above function sets the state for us in case of an error */ 4037| 0| return false; 4038| 0| } 4039| 221k| } 4040| 199k| } 4041| | 4042| 244k| return true; 4043| 244k|} stream_encoder.c:get_wasted_bits_: 5078| 366k|{ 5079| 366k| uint32_t i, shift; 5080| 366k| FLAC__int32 x = 0; 5081| | 5082| 1.15M| for(i = 0; i < samples && !(x&1); i++) ------------------ | Branch (5082:13): [True: 1.13M, False: 23.3k] | Branch (5082:28): [True: 790k, False: 342k] ------------------ 5083| 790k| x |= signal[i]; 5084| | 5085| 366k| if(x == 0) { ------------------ | Branch (5085:5): [True: 3.16k, False: 363k] ------------------ 5086| 3.16k| shift = 0; 5087| 3.16k| } 5088| 363k| else { 5089| 453k| for(shift = 0; !(x&1); shift++) ------------------ | Branch (5089:18): [True: 90.7k, False: 363k] ------------------ 5090| 90.7k| x >>= 1; 5091| 363k| } 5092| | 5093| 366k| if(shift > 0) { ------------------ | Branch (5093:5): [True: 18.4k, False: 347k] ------------------ 5094| 370k| for(i = 0; i < samples; i++) ------------------ | Branch (5094:14): [True: 351k, False: 18.4k] ------------------ 5095| 351k| signal[i] >>= shift; 5096| 18.4k| } 5097| | 5098| 366k| return shift; 5099| 366k|} stream_encoder.c:get_wasted_bits_wide_: 5102| 30.2k|{ 5103| 30.2k| uint32_t i, shift; 5104| 30.2k| FLAC__int64 x = 0; 5105| | 5106| 716k| for(i = 0; i < samples && !(x&1); i++) ------------------ | Branch (5106:13): [True: 699k, False: 17.5k] | Branch (5106:28): [True: 686k, False: 12.7k] ------------------ 5107| 686k| x |= signal_wide[i]; 5108| | 5109| 30.2k| if(x == 0) { ------------------ | Branch (5109:5): [True: 1.89k, False: 28.3k] ------------------ 5110| 1.89k| shift = 1; 5111| 1.89k| } 5112| 28.3k| else { 5113| 109k| for(shift = 0; !(x&1); shift++) ------------------ | Branch (5113:18): [True: 80.8k, False: 28.3k] ------------------ 5114| 80.8k| x >>= 1; 5115| 28.3k| } 5116| | 5117| 30.2k| if(shift > 0) { ------------------ | Branch (5117:5): [True: 17.0k, False: 13.1k] ------------------ 5118| 452k| for(i = 0; i < samples; i++) ------------------ | Branch (5118:14): [True: 435k, False: 17.0k] ------------------ 5119| 435k| signal[i] = (FLAC__int32)(signal_wide[i] >> shift); 5120| 17.0k| } 5121| | 5122| 30.2k| return shift; 5123| 30.2k|} stream_encoder.c:process_subframe_: 4059| 396k|{ 4060| 396k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4061| 396k| float fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]; 4062| |#else 4063| | FLAC__fixedpoint fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]; 4064| |#endif 4065| 396k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4066| 396k| double lpc_residual_bits_per_sample; 4067| 396k| apply_apodization_state_struct apply_apodization_state; 4068| 396k| double lpc_error[FLAC__MAX_LPC_ORDER]; 4069| 396k| uint32_t min_lpc_order, max_lpc_order, lpc_order, guess_lpc_order; 4070| 396k| uint32_t min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision; 4071| 396k|#endif 4072| 396k| uint32_t min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order; 4073| 396k| uint32_t _candidate_bits, _best_bits; 4074| 396k| uint32_t _best_subframe; 4075| | /* only use RICE2 partitions if stream bps > 16 */ 4076| 396k| const uint32_t rice_parameter_limit = FLAC__stream_encoder_get_bits_per_sample(encoder) > 16? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; ------------------ | Branch (4076:40): [True: 365k, False: 30.7k] ------------------ 4077| | 4078| 396k| FLAC__ASSERT(frame_header->blocksize > 0); ------------------ | | 38| 396k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 396k] | | ------------------ ------------------ 4079| | 4080| | /* verbatim subframe is the baseline against which we measure other compressed subframes */ 4081| 396k| _best_subframe = 0; 4082| 396k| if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) ------------------ | | 145| 0|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ | Branch (4082:5): [True: 0, False: 396k] | Branch (4082:54): [True: 0, False: 0] ------------------ 4083| 0| _best_bits = UINT32_MAX; 4084| 396k| else 4085| 396k| _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]); 4086| 396k| *best_bits = _best_bits; 4087| | 4088| 396k| if(frame_header->blocksize > FLAC__MAX_FIXED_ORDER) { ------------------ | | 145| 396k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ | Branch (4088:5): [True: 391k, False: 4.65k] ------------------ 4089| 391k| uint32_t signal_is_constant = false; 4090| | /* The next formula determines when to use a 64-bit accumulator 4091| | * for the error of a fixed predictor, and when a 32-bit one. As 4092| | * the error of a 4th order predictor for a given sample is the 4093| | * sum of 17 sample values (1+4+6+4+1) and there are blocksize - 4094| | * order error values to be summed, the maximum total error is 4095| | * maximum_sample_value * (blocksize - order) * 17. As ilog2(x) 4096| | * calculates floor(2log(x)), the result must be 31 or lower 4097| | */ 4098| 391k| if(subframe_bps < 28){ ------------------ | Branch (4098:6): [True: 86.3k, False: 305k] ------------------ 4099| 86.3k| if(subframe_bps + FLAC__bitmath_ilog2((frame_header->blocksize-FLAC__MAX_FIXED_ORDER)*17) < 32) ------------------ | | 145| 86.3k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ | Branch (4099:7): [True: 55.7k, False: 30.5k] ------------------ 4100| 55.7k| guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor(((FLAC__int32 *)integer_signal)+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 55.7k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor(((FLAC__int32 *)integer_signal)+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 55.7k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4101| 30.5k| else 4102| 30.5k| guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_wide(((FLAC__int32 *)integer_signal)+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 30.5k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_wide(((FLAC__int32 *)integer_signal)+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 30.5k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4103| 86.3k| } 4104| 305k| else 4105| 305k| if(subframe_bps <= 32) ------------------ | Branch (4105:7): [True: 292k, False: 13.0k] ------------------ 4106| 292k| guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_limit_residual(((FLAC__int32 *)integer_signal+FLAC__MAX_FIXED_ORDER),frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 292k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_limit_residual(((FLAC__int32 *)integer_signal+FLAC__MAX_FIXED_ORDER),frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 292k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4107| 13.0k| else 4108| 13.0k| guess_fixed_order = FLAC__fixed_compute_best_predictor_limit_residual_33bit(((FLAC__int64 *)integer_signal+FLAC__MAX_FIXED_ORDER),frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 13.0k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ guess_fixed_order = FLAC__fixed_compute_best_predictor_limit_residual_33bit(((FLAC__int64 *)integer_signal+FLAC__MAX_FIXED_ORDER),frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); ------------------ | | 145| 13.0k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4109| | 4110| | /* check for constant subframe */ 4111| 391k| if( 4112| 391k| !threadtask->disable_constant_subframes && ------------------ | Branch (4112:4): [True: 315k, False: 76.1k] ------------------ 4113| 315k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4114| 315k| fixed_residual_bits_per_sample[1] == 0.0 ------------------ | Branch (4114:4): [True: 109k, False: 205k] ------------------ 4115| |#else 4116| | fixed_residual_bits_per_sample[1] == FLAC__FP_ZERO 4117| |#endif 4118| 391k| ) { 4119| | /* the above means it's possible all samples are the same value; now double-check it: */ 4120| 109k| uint32_t i; 4121| 109k| signal_is_constant = true; 4122| 109k| if(subframe_bps <= 32){ ------------------ | Branch (4122:7): [True: 108k, False: 896] ------------------ 4123| 108k| const FLAC__int32 *integer_signal_ = integer_signal; 4124| 1.84M| for(i = 1; i < frame_header->blocksize; i++) { ------------------ | Branch (4124:16): [True: 1.74M, False: 105k] ------------------ 4125| 1.74M| if(integer_signal_[0] != integer_signal_[i]) { ------------------ | Branch (4125:9): [True: 3.82k, False: 1.73M] ------------------ 4126| 3.82k| signal_is_constant = false; 4127| 3.82k| break; 4128| 3.82k| } 4129| 1.74M| } 4130| 108k| } 4131| 896| else { 4132| 896| const FLAC__int64 *integer_signal_ = integer_signal; 4133| 15.2k| for(i = 1; i < frame_header->blocksize; i++) { ------------------ | Branch (4133:16): [True: 14.3k, False: 896] ------------------ 4134| 14.3k| if(integer_signal_[0] != integer_signal_[i]) { ------------------ | Branch (4134:9): [True: 0, False: 14.3k] ------------------ 4135| 0| signal_is_constant = false; 4136| 0| break; 4137| 0| } 4138| 14.3k| } 4139| 896| } 4140| 109k| } 4141| 391k| if(signal_is_constant) { ------------------ | Branch (4141:6): [True: 106k, False: 285k] ------------------ 4142| 106k| if(subframe_bps <= 32) ------------------ | Branch (4142:7): [True: 105k, False: 897] ------------------ 4143| 105k| _candidate_bits = evaluate_constant_subframe_(encoder, ((FLAC__int32 *)integer_signal)[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]); 4144| 897| else 4145| 897| _candidate_bits = evaluate_constant_subframe_(encoder, ((FLAC__int64 *)integer_signal)[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]); 4146| | 4147| 106k| if(_candidate_bits < _best_bits) { ------------------ | Branch (4147:7): [True: 105k, False: 47] ------------------ 4148| 105k| _best_subframe = !_best_subframe; 4149| 105k| _best_bits = _candidate_bits; 4150| 105k| } 4151| 106k| } 4152| 285k| else { 4153| 286k| if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) { ------------------ | Branch (4153:7): [True: 285k, False: 0] | Branch (4153:55): [True: 0, False: 0] | Branch (4153:98): [True: 0, False: 0] ------------------ 4154| | /* encode fixed */ 4155| 286k| if(encoder->protected_->do_exhaustive_model_search) { ------------------ | Branch (4155:8): [True: 197k, False: 88.9k] ------------------ 4156| 197k| min_fixed_order = 0; 4157| 197k| max_fixed_order = FLAC__MAX_FIXED_ORDER; ------------------ | | 145| 197k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4158| 197k| } 4159| 88.9k| else { 4160| 88.9k| min_fixed_order = max_fixed_order = guess_fixed_order; 4161| 88.9k| } 4162| 286k| if(max_fixed_order >= frame_header->blocksize) ------------------ | Branch (4162:8): [True: 0, False: 286k] ------------------ 4163| 0| max_fixed_order = frame_header->blocksize - 1; 4164| 1.35M| for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) { ------------------ | Branch (4164:40): [True: 1.06M, False: 286k] ------------------ 4165| 1.06M|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4166| 1.06M| if(fixed_residual_bits_per_sample[fixed_order] >= (float)subframe_bps) ------------------ | Branch (4166:9): [True: 280k, False: 788k] ------------------ 4167| 280k| continue; /* don't even try */ 4168| |#else 4169| | if(FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]) >= (int)subframe_bps) 4170| | continue; /* don't even try */ 4171| |#endif 4172| 788k| _candidate_bits = 4173| 788k| evaluate_fixed_subframe_( 4174| 788k| encoder, 4175| 788k| threadtask, 4176| 788k| integer_signal, 4177| 788k| residual[!_best_subframe], 4178| 788k| threadtask->abs_residual_partition_sums, 4179| 788k| threadtask->raw_bits_per_partition, 4180| 788k| frame_header->blocksize, 4181| 788k| subframe_bps, 4182| 788k| fixed_order, 4183| 788k| rice_parameter_limit, 4184| 788k| min_partition_order, 4185| 788k| max_partition_order, 4186| 788k| encoder->protected_->do_escape_coding, 4187| 788k| encoder->protected_->rice_parameter_search_dist, 4188| 788k| subframe[!_best_subframe], 4189| 788k| partitioned_rice_contents[!_best_subframe] 4190| 788k| ); 4191| 788k| if(_candidate_bits < _best_bits) { ------------------ | Branch (4191:9): [True: 242k, False: 545k] ------------------ 4192| 242k| _best_subframe = !_best_subframe; 4193| 242k| _best_bits = _candidate_bits; 4194| 242k| } 4195| 788k| } 4196| 286k| } 4197| | 4198| 285k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4199| | /* encode lpc */ 4200| 285k| if(encoder->protected_->max_lpc_order > 0) { ------------------ | Branch (4200:7): [True: 225k, False: 60.3k] ------------------ 4201| 225k| if(encoder->protected_->max_lpc_order >= frame_header->blocksize) ------------------ | Branch (4201:8): [True: 13.0k, False: 212k] ------------------ 4202| 13.0k| max_lpc_order = frame_header->blocksize-1; 4203| 212k| else 4204| 212k| max_lpc_order = encoder->protected_->max_lpc_order; 4205| 225k| if(max_lpc_order > 0) { ------------------ | Branch (4205:8): [True: 225k, False: 18.4E] ------------------ 4206| 225k| apply_apodization_state.a = 0; 4207| 225k| apply_apodization_state.b = 1; 4208| 225k| apply_apodization_state.c = 0; 4209| 338M| while (apply_apodization_state.a < encoder->protected_->num_apodizations) { ------------------ | Branch (4209:13): [True: 338M, False: 225k] ------------------ 4210| 338M| uint32_t max_lpc_order_this_apodization = max_lpc_order; 4211| | 4212| 338M| if(!apply_apodization_(encoder, threadtask, &apply_apodization_state, ------------------ | Branch (4212:10): [True: 337M, False: 344k] ------------------ 4213| 338M| frame_header->blocksize, lpc_error, 4214| 338M| &max_lpc_order_this_apodization, 4215| 338M| subframe_bps, integer_signal, 4216| 338M| &guess_lpc_order)) 4217| | /* If apply_apodization_ fails, try next apodization */ 4218| 337M| continue; 4219| | 4220| 344k| if(encoder->protected_->do_exhaustive_model_search) { ------------------ | Branch (4220:10): [True: 252k, False: 91.6k] ------------------ 4221| 252k| min_lpc_order = 1; 4222| 252k| } 4223| 91.6k| else { 4224| 91.6k| min_lpc_order = max_lpc_order_this_apodization = guess_lpc_order; 4225| 91.6k| } 4226| 3.62M| for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order_this_apodization; lpc_order++) { ------------------ | Branch (4226:38): [True: 3.28M, False: 344k] ------------------ 4227| 3.28M| lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order); 4228| 3.28M| if(lpc_residual_bits_per_sample >= (double)subframe_bps) ------------------ | Branch (4228:11): [True: 26.6k, False: 3.25M] ------------------ 4229| 26.6k| continue; /* don't even try */ 4230| 3.25M| if(encoder->protected_->do_qlp_coeff_prec_search) { ------------------ | Branch (4230:11): [True: 1.78M, False: 1.47M] ------------------ 4231| 1.78M| min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION; ------------------ | | 137| 1.78M|#define FLAC__MIN_QLP_COEFF_PRECISION (5u) ------------------ 4232| | /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps(+1bps for side channel) streams */ 4233| 1.78M| if(subframe_bps <= 17) { ------------------ | Branch (4233:12): [True: 182k, False: 1.59M] ------------------ 4234| 182k| max_qlp_coeff_precision = flac_min(32 - subframe_bps - FLAC__bitmath_ilog2(lpc_order), FLAC__MAX_QLP_COEFF_PRECISION); ------------------ | | 56| 182k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (4234:36): [True: 106k, False: 76.4k] ------------------ 4235| 182k| max_qlp_coeff_precision = flac_max(max_qlp_coeff_precision, min_qlp_coeff_precision); ------------------ | | 55| 182k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (4235:36): [True: 182k, False: 0] ------------------ 4236| 182k| } 4237| 1.59M| else 4238| 1.59M| max_qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; ------------------ | | 142| 1.59M|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 4239| 1.78M| } 4240| 1.47M| else { 4241| 1.47M| min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision; 4242| 1.47M| } 4243| 23.4M| for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) { ------------------ | Branch (4243:59): [True: 20.2M, False: 3.25M] ------------------ 4244| 20.2M| _candidate_bits = 4245| 20.2M| evaluate_lpc_subframe_( 4246| 20.2M| encoder, 4247| 20.2M| threadtask, 4248| 20.2M| integer_signal, 4249| 20.2M| residual[!_best_subframe], 4250| 20.2M| threadtask->abs_residual_partition_sums, 4251| 20.2M| threadtask->raw_bits_per_partition, 4252| 20.2M| threadtask->lp_coeff[lpc_order-1], 4253| 20.2M| frame_header->blocksize, 4254| 20.2M| subframe_bps, 4255| 20.2M| lpc_order, 4256| 20.2M| qlp_coeff_precision, 4257| 20.2M| rice_parameter_limit, 4258| 20.2M| min_partition_order, 4259| 20.2M| max_partition_order, 4260| 20.2M| encoder->protected_->do_escape_coding, 4261| 20.2M| encoder->protected_->rice_parameter_search_dist, 4262| 20.2M| subframe[!_best_subframe], 4263| 20.2M| partitioned_rice_contents[!_best_subframe] 4264| 20.2M| ); 4265| 20.2M| if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */ ------------------ | Branch (4265:12): [True: 17.3M, False: 2.92M] ------------------ 4266| 17.3M| if(_candidate_bits < _best_bits) { ------------------ | Branch (4266:13): [True: 38.1k, False: 17.2M] ------------------ 4267| 38.1k| _best_subframe = !_best_subframe; 4268| 38.1k| _best_bits = _candidate_bits; 4269| 38.1k| } 4270| 17.3M| } 4271| 20.2M| } 4272| 3.25M| } 4273| 344k| } 4274| 225k| } 4275| 225k| } 4276| 285k|#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */ 4277| 285k| } 4278| 391k| } 4279| | 4280| | /* under rare circumstances this can happen when all but lpc subframe types are disabled: */ 4281| 396k| if(_best_bits == UINT32_MAX) { ------------------ | Branch (4281:5): [True: 0, False: 396k] ------------------ 4282| 0| FLAC__ASSERT(_best_subframe == 0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 4283| 0| _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]); 4284| 0| } 4285| | 4286| 396k| *best_subframe = _best_subframe; 4287| 396k| *best_bits = _best_bits; 4288| | 4289| | return true; 4290| 396k|} stream_encoder.c:evaluate_verbatim_subframe_: 4676| 396k|{ 4677| 396k| uint32_t estimate; 4678| | 4679| 396k| subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM; 4680| | 4681| 396k| if(subframe_bps <= 32){ ------------------ | Branch (4681:5): [True: 382k, False: 13.1k] ------------------ 4682| 382k| subframe->data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32; 4683| 382k| subframe->data.verbatim.data.int32 = signal; 4684| 382k| } 4685| 13.1k| else { 4686| 13.1k| subframe->data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64; 4687| 13.1k| subframe->data.verbatim.data.int64 = signal; 4688| 13.1k| } 4689| | 4690| 396k| estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (blocksize * subframe_bps); 4691| | 4692| |#if SPOTCHECK_ESTIMATE 4693| | spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 4694| |#else 4695| 396k| (void)encoder; 4696| 396k|#endif 4697| | 4698| 396k| return estimate; 4699| 396k|} stream_encoder.c:evaluate_constant_subframe_: 4473| 105k|{ 4474| 105k| uint32_t estimate; 4475| 105k| subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT; 4476| 105k| subframe->data.constant.value = signal; 4477| | 4478| 105k| estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + subframe_bps; 4479| | 4480| |#if SPOTCHECK_ESTIMATE 4481| | spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 4482| |#else 4483| 105k| (void)encoder, (void)blocksize; 4484| 105k|#endif 4485| | 4486| 105k| return estimate; 4487| 105k|} stream_encoder.c:evaluate_fixed_subframe_: 4507| 788k|{ 4508| 788k| uint32_t i, residual_bits, estimate; 4509| 788k| const uint32_t residual_samples = blocksize - order; 4510| | 4511| 788k| if((subframe_bps + order) <= 32) ------------------ | Branch (4511:5): [True: 463k, False: 325k] ------------------ 4512| 463k| FLAC__fixed_compute_residual(((FLAC__int32 *)signal)+order, residual_samples, order, residual); 4513| 325k| else if(subframe_bps <= 32) ------------------ | Branch (4513:10): [True: 314k, False: 10.5k] ------------------ 4514| 314k| FLAC__fixed_compute_residual_wide(((FLAC__int32 *)signal)+order, residual_samples, order, residual); 4515| 10.5k| else 4516| 10.5k| FLAC__fixed_compute_residual_wide_33bit(((FLAC__int64 *)signal)+order, residual_samples, order, residual); 4517| | 4518| 788k| subframe->type = FLAC__SUBFRAME_TYPE_FIXED; 4519| | 4520| 788k| subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; 4521| 788k| subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; 4522| 788k| subframe->data.fixed.residual = residual; 4523| | 4524| 788k| residual_bits = 4525| 788k| find_best_partition_order_( 4526| 788k| encoder->private_, 4527| 788k| threadtask, 4528| 788k| residual, 4529| 788k| abs_residual_partition_sums, 4530| 788k| raw_bits_per_partition, 4531| 788k| residual_samples, 4532| 788k| order, 4533| 788k| rice_parameter_limit, 4534| 788k| min_partition_order, 4535| 788k| max_partition_order, 4536| 788k| subframe_bps, 4537| 788k| do_escape_coding, 4538| 788k| rice_parameter_search_dist, 4539| 788k| &subframe->data.fixed.entropy_coding_method 4540| 788k| ); 4541| | 4542| 788k| subframe->data.fixed.order = order; 4543| 788k| if(subframe_bps <= 32) ------------------ | Branch (4543:5): [True: 775k, False: 12.5k] ------------------ 4544| 2.02M| for(i = 0; i < order; i++) ------------------ | Branch (4544:14): [True: 1.25M, False: 775k] ------------------ 4545| 1.25M| subframe->data.fixed.warmup[i] = ((FLAC__int32 *)signal)[i]; 4546| 12.5k| else 4547| 24.5k| for(i = 0; i < order; i++) ------------------ | Branch (4547:14): [True: 11.9k, False: 12.5k] ------------------ 4548| 11.9k| subframe->data.fixed.warmup[i] = ((FLAC__int64 *)signal)[i]; 4549| | 4550| 788k| estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (order * subframe_bps); 4551| 788k| if(residual_bits < UINT32_MAX - estimate) // To make sure estimate doesn't overflow ------------------ | Branch (4551:5): [True: 788k, False: 18.4E] ------------------ 4552| 788k| estimate += residual_bits; 4553| 18.4E| else 4554| 18.4E| estimate = UINT32_MAX; 4555| | 4556| |#if SPOTCHECK_ESTIMATE 4557| | spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 4558| |#endif 4559| | 4560| 788k| return estimate; 4561| 788k|} stream_encoder.c:find_best_partition_order_: 4717| 17.9M|{ 4718| 17.9M| uint32_t residual_bits, best_residual_bits = 0; 4719| 17.9M| uint32_t best_parameters_index = 0; 4720| 17.9M| uint32_t best_partition_order = 0; 4721| 17.9M| const uint32_t blocksize = residual_samples + predictor_order; 4722| | 4723| 17.9M| max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order); 4724| 17.9M| min_partition_order = flac_min(min_partition_order, max_partition_order); ------------------ | | 56| 17.9M|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (4724:24): [True: 342k, False: 17.6M] ------------------ 4725| | 4726| 17.9M| private_->local_precompute_partition_info_sums(residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order, bps); 4727| | 4728| 17.9M| if(do_escape_coding) ------------------ | Branch (4728:5): [True: 13.9M, False: 3.99M] ------------------ 4729| 13.9M| precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order); 4730| | 4731| 17.9M| { 4732| 17.9M| int partition_order; 4733| 17.9M| uint32_t sum; 4734| | 4735| 36.1M| for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) { ------------------ | Branch (4735:60): [True: 18.1M, False: 17.9M] ------------------ 4736| 18.1M| FLAC__ASSERT(do_escape_coding != /* XOR */ (raw_bits_per_partition == NULL)); ------------------ | | 38| 18.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.1M] | | ------------------ ------------------ 4737| 18.1M| if(! ------------------ | Branch (4737:7): [True: 0, False: 18.1M] ------------------ 4738| 18.1M| set_partitioned_rice_( 4739| |#ifdef EXACT_RICE_BITS_CALCULATION 4740| | residual, 4741| |#endif 4742| 18.1M| abs_residual_partition_sums+sum, 4743| 18.1M| do_escape_coding ? raw_bits_per_partition+sum : NULL, ------------------ | Branch (4743:6): [True: 13.8M, False: 4.30M] ------------------ 4744| 18.1M| residual_samples, 4745| 18.1M| predictor_order, 4746| 18.1M| rice_parameter_limit, 4747| 18.1M| rice_parameter_search_dist, 4748| 18.1M| (uint32_t)partition_order, 4749| 18.1M| do_escape_coding, 4750| 18.1M| &threadtask->partitioned_rice_contents_extra[!best_parameters_index], 4751| 18.1M| &residual_bits 4752| 18.1M| ) 4753| 18.1M| ) 4754| 0| { 4755| 0| FLAC__ASSERT(best_residual_bits != 0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 4756| 0| break; 4757| 0| } 4758| 18.1M| sum += 1u << partition_order; 4759| 18.1M| if(best_residual_bits == 0 || residual_bits < best_residual_bits) { ------------------ | Branch (4759:7): [True: 17.4M, False: 704k] | Branch (4759:34): [True: 393k, False: 310k] ------------------ 4760| 17.8M| best_residual_bits = residual_bits; 4761| 17.8M| best_parameters_index = !best_parameters_index; 4762| 17.8M| best_partition_order = partition_order; 4763| 17.8M| } 4764| 18.1M| } 4765| 17.9M| } 4766| | 4767| 17.9M| best_ecm->data.partitioned_rice.order = best_partition_order; 4768| | 4769| 17.9M| { 4770| | /* 4771| | * We are allowed to de-const the pointer based on our special 4772| | * knowledge; it is const to the outside world. 4773| | */ 4774| 17.9M| FLAC__EntropyCodingMethod_PartitionedRiceContents* prc = (FLAC__EntropyCodingMethod_PartitionedRiceContents*)best_ecm->data.partitioned_rice.contents; 4775| 17.9M| uint32_t partition; 4776| | 4777| | /* save best parameters and raw_bits */ 4778| 17.9M| memcpy(prc->parameters, threadtask->partitioned_rice_contents_extra[best_parameters_index].parameters, (uint32_t)sizeof(uint32_t)*(1<<(best_partition_order))); 4779| 17.9M| if(do_escape_coding) ------------------ | Branch (4779:6): [True: 13.7M, False: 4.25M] ------------------ 4780| 13.7M| memcpy(prc->raw_bits, threadtask->partitioned_rice_contents_extra[best_parameters_index].raw_bits, (uint32_t)sizeof(uint32_t)*(1<<(best_partition_order))); 4781| | /* 4782| | * Now need to check if the type should be changed to 4783| | * FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 based on the 4784| | * size of the rice parameters. 4785| | */ 4786| 27.8M| for(partition = 0; partition < (1u<parameters[partition] >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { ------------------ | Branch (4787:7): [True: 13.3M, False: 9.92M] ------------------ 4788| 13.3M| best_ecm->type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2; 4789| 13.3M| break; 4790| 13.3M| } 4791| 23.3M| } 4792| 17.9M| } 4793| | 4794| 17.9M| return best_residual_bits; 4795| 17.9M|} stream_encoder.c:precompute_partition_info_escapes_: 4862| 13.9M|{ 4863| 13.9M| int partition_order; 4864| 13.9M| uint32_t from_partition, to_partition = 0; 4865| 13.9M| const uint32_t blocksize = residual_samples + predictor_order; 4866| | 4867| | /* first do max_partition_order */ 4868| 13.9M| for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) { ------------------ | Branch (4868:50): [True: 13.9M, False: 18.4E] ------------------ 4869| 13.9M| FLAC__int32 r; 4870| 13.9M| FLAC__uint32 rmax; 4871| 13.9M| uint32_t partition, partition_sample, partition_samples, residual_sample; 4872| 13.9M| const uint32_t partitions = 1u << partition_order; 4873| 13.9M| const uint32_t default_partition_samples = blocksize >> partition_order; 4874| | 4875| 13.9M| FLAC__ASSERT(default_partition_samples > predictor_order); ------------------ | | 38| 13.9M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 13.9M] | | ------------------ ------------------ 4876| | 4877| 46.2M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (4877:40): [True: 32.3M, False: 13.9M] ------------------ 4878| 32.3M| partition_samples = default_partition_samples; 4879| 32.3M| if(partition == 0) ------------------ | Branch (4879:7): [True: 13.9M, False: 18.3M] ------------------ 4880| 13.9M| partition_samples -= predictor_order; 4881| 32.3M| rmax = 0; 4882| 1.87G| for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) { ------------------ | Branch (4882:30): [True: 1.84G, False: 32.3M] ------------------ 4883| 1.84G| r = residual[residual_sample++]; 4884| | /* OPT: maybe faster: rmax |= r ^ (r>>31) */ 4885| 1.84G| if(r < 0) ------------------ | Branch (4885:8): [True: 445M, False: 1.39G] ------------------ 4886| 445M| rmax |= ~r; 4887| 1.39G| else 4888| 1.39G| rmax |= r; 4889| 1.84G| } 4890| | /* now we know all residual values are in the range [-rmax-1,rmax] */ 4891| 32.3M| raw_bits_per_partition[partition] = rmax? FLAC__bitmath_ilog2(rmax) + 2 : 1; ------------------ | Branch (4891:40): [True: 23.2M, False: 9.04M] ------------------ 4892| 32.3M| } 4893| 13.9M| to_partition = partitions; 4894| 13.9M| break; /*@@@ yuck, should remove the 'for' loop instead */ 4895| 13.9M| } 4896| | 4897| | /* now merge partitions for lower orders */ 4898| 14.3M| for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) { ------------------ | Branch (4898:45): [True: 464k, False: 13.9M] ------------------ 4899| 464k| uint32_t m; 4900| 464k| uint32_t i; 4901| 464k| const uint32_t partitions = 1u << partition_order; 4902| 2.02M| for(i = 0; i < partitions; i++) { ------------------ | Branch (4902:14): [True: 1.56M, False: 464k] ------------------ 4903| 1.56M| m = raw_bits_per_partition[from_partition]; 4904| 1.56M| from_partition++; 4905| | raw_bits_per_partition[to_partition] = flac_max(m, raw_bits_per_partition[from_partition]); ------------------ | | 55| 1.56M|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (4905:43): [True: 269k, False: 1.29M] ------------------ 4906| 1.56M| from_partition++; 4907| 1.56M| to_partition++; 4908| 1.56M| } 4909| 464k| } 4910| 13.9M|} stream_encoder.c:set_partitioned_rice_: 4969| 18.1M|{ 4970| 18.1M| uint32_t rice_parameter, partition_bits; 4971| 18.1M| uint32_t best_partition_bits, best_rice_parameter = 0; 4972| 18.1M| uint32_t bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; 4973| 18.1M| uint32_t *parameters, *raw_bits; 4974| 18.1M| uint32_t partition, residual_sample; 4975| 18.1M| uint32_t partition_samples, partition_samples_base; 4976| 18.1M| uint32_t partition_samples_fixed_point_divisor, partition_samples_fixed_point_divisor_base; 4977| 18.1M| const uint32_t partitions = 1u << partition_order; 4978| 18.1M| FLAC__uint64 mean; 4979| |#ifdef ENABLE_RICE_PARAMETER_SEARCH 4980| | uint32_t min_rice_parameter, max_rice_parameter; 4981| |#else 4982| 18.1M| (void)rice_parameter_search_dist; 4983| 18.1M|#endif 4984| | 4985| 18.1M| FLAC__ASSERT(rice_parameter_limit <= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER); ------------------ | | 38| 18.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.1M] | | ------------------ ------------------ 4986| | 4987| 18.1M| parameters = partitioned_rice_contents->parameters; 4988| 18.1M| raw_bits = partitioned_rice_contents->raw_bits; 4989| | 4990| 18.1M| partition_samples_base = (residual_samples+predictor_order) >> partition_order; 4991| | 4992| | /* Integer division is slow. To speed up things, precalculate a fixed point 4993| | * divisor, as all partitions except the first are the same size. 18 bits 4994| | * are taken because maximum block size is 65535, max partition size for 4995| | * partitions other than 0 is 32767 (15 bit), max abs residual is 2^31, 4996| | * which leaves 18 bit */ 4997| 18.1M| partition_samples_fixed_point_divisor_base = 0x40000 / partition_samples_base; 4998| | 4999| 60.9M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (4999:39): [True: 42.7M, False: 18.1M] ------------------ 5000| 42.7M| partition_samples = partition_samples_base; 5001| 42.7M| if(partition > 0) { ------------------ | Branch (5001:6): [True: 24.8M, False: 17.9M] ------------------ 5002| 24.8M| partition_samples_fixed_point_divisor = partition_samples_fixed_point_divisor_base; 5003| 24.8M| } 5004| 17.9M| else { 5005| 17.9M| if(partition_samples <= predictor_order) ------------------ | Branch (5005:7): [True: 0, False: 17.9M] ------------------ 5006| 0| return false; 5007| 17.9M| else 5008| 17.9M| partition_samples -= predictor_order; 5009| 17.9M| partition_samples_fixed_point_divisor = 0x40000 / partition_samples; 5010| 17.9M| } 5011| 42.7M| mean = abs_residual_partition_sums[partition]; 5012| | /* 'mean' is not a good name for the variable, it is 5013| | * actually the sum of magnitudes of all residual values 5014| | * in the partition, so the actual mean is 5015| | * mean/partition_samples 5016| | */ 5017| 42.7M| if(mean < 2 || (((mean - 1)*partition_samples_fixed_point_divisor)>>18) == 0) ------------------ | Branch (5017:6): [True: 9.27M, False: 33.4M] | Branch (5017:18): [True: 3.66M, False: 29.8M] ------------------ 5018| 13.0M| rice_parameter = 0; 5019| 29.7M| else 5020| 29.7M| rice_parameter = FLAC__bitmath_ilog2_wide(((mean - 1)*partition_samples_fixed_point_divisor)>>18) + 1; 5021| | 5022| 42.7M| if(rice_parameter >= rice_parameter_limit) { ------------------ | Branch (5022:6): [True: 1.77M, False: 40.9M] ------------------ 5023| 1.77M| rice_parameter = rice_parameter_limit - 1; 5024| 1.77M| } 5025| | 5026| 42.7M| best_partition_bits = UINT32_MAX; 5027| |#ifdef ENABLE_RICE_PARAMETER_SEARCH 5028| | if(rice_parameter_search_dist) { 5029| | if(rice_parameter < rice_parameter_search_dist) 5030| | min_rice_parameter = 0; 5031| | else 5032| | min_rice_parameter = rice_parameter - rice_parameter_search_dist; 5033| | max_rice_parameter = rice_parameter + rice_parameter_search_dist; 5034| | if(max_rice_parameter >= rice_parameter_limit) { 5035| | max_rice_parameter = rice_parameter_limit - 1; 5036| | } 5037| | } 5038| | else 5039| | min_rice_parameter = max_rice_parameter = rice_parameter; 5040| | 5041| | for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) { 5042| |#endif 5043| |#ifdef EXACT_RICE_BITS_CALCULATION 5044| | partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, residual+residual_sample); 5045| |#else 5046| 42.7M| partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, abs_residual_partition_sums[partition]); 5047| 42.7M|#endif 5048| 42.7M| if(partition_bits < best_partition_bits) { ------------------ | Branch (5048:7): [True: 42.7M, False: 14.6k] ------------------ 5049| 42.7M| best_rice_parameter = rice_parameter; 5050| 42.7M| best_partition_bits = partition_bits; 5051| 42.7M| } 5052| |#ifdef ENABLE_RICE_PARAMETER_SEARCH 5053| | } 5054| |#endif 5055| 42.7M| if(search_for_escapes) { ------------------ | Branch (5055:6): [True: 33.2M, False: 9.50M] ------------------ 5056| 33.2M| partition_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN + raw_bits_per_partition[partition] * partition_samples; 5057| 33.2M| if(partition_bits <= best_partition_bits && raw_bits_per_partition[partition] < 32) { ------------------ | Branch (5057:7): [True: 3.89M, False: 29.3M] | Branch (5057:48): [True: 3.75M, False: 147k] ------------------ 5058| 3.75M| raw_bits[partition] = raw_bits_per_partition[partition]; 5059| 3.75M| best_rice_parameter = 0; /* will be converted to appropriate escape parameter later */ 5060| 3.75M| best_partition_bits = partition_bits; 5061| 3.75M| } 5062| 29.5M| else 5063| 29.5M| raw_bits[partition] = 0; 5064| 33.2M| } 5065| 42.7M| parameters[partition] = best_rice_parameter; 5066| 42.7M| if(best_partition_bits < UINT32_MAX - bits_) // To make sure _bits doesn't overflow ------------------ | Branch (5066:6): [True: 42.7M, False: 14.9k] ------------------ 5067| 42.7M| bits_ += best_partition_bits; 5068| 14.9k| else 5069| 14.9k| bits_ = UINT32_MAX; 5070| 42.7M| residual_sample += partition_samples; 5071| 42.7M| } 5072| | 5073| 18.1M| *bits = bits_; 5074| | return true; 5075| 18.1M|} stream_encoder.c:count_rice_bits_in_partition_: 4934| 42.7M|{ 4935| 42.7M| return (uint32_t)(flac_min( // To make sure the return value doesn't overflow ------------------ | | 56| 42.7M|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (4935:20): [True: 29.8M, False: 12.9M] | Branch (4935:20): [True: 29.8M, False: 12.9M] | Branch (4935:20): [True: 42.7M, False: 6.66k] ------------------ 4936| 42.7M| FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + /* actually could end up being FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN but err on side of 16bps */ 4937| 42.7M| (1+rice_parameter) * partition_samples + /* 1 for unary stop bit + rice_parameter for the binary portion */ 4938| 42.7M| ( 4939| 42.7M| rice_parameter? 4940| 42.7M| (abs_residual_partition_sum >> (rice_parameter-1)) /* rice_parameter-1 because the real coder sign-folds instead of using a sign bit */ 4941| 42.7M| : (abs_residual_partition_sum << 1) /* can't shift by negative number, so reverse */ 4942| 42.7M| ) 4943| 42.7M| - (partition_samples >> 1),UINT32_MAX)); 4944| | /* -(partition_samples>>1) to subtract out extra contributions to the abs_residual_partition_sum. 4945| | * The actual number of bits used is closer to the sum(for all i in the partition) of abs(residual[i])>>(rice_parameter-1) 4946| | * By using the abs_residual_partition sum, we also add in bits in the LSBs that would normally be shifted out. 4947| | * So the subtraction term tries to guess how many extra bits were contributed. 4948| | * If the LSBs are randomly distributed, this should average to 0.5 extra bits per sample. 4949| | */ 4950| 0| ; 4951| 0|} stream_encoder.c:apply_apodization_: 4327| 338M|{ 4328| 338M| apply_apodization_state->current_apodization = &encoder->protected_->apodizations[apply_apodization_state->a]; 4329| | 4330| 338M| if(apply_apodization_state->b == 1) { ------------------ | Branch (4330:5): [True: 251k, False: 338M] ------------------ 4331| | /* window full subblock */ 4332| 251k| if(subframe_bps <= 32) ------------------ | Branch (4332:6): [True: 237k, False: 14.4k] ------------------ 4333| 237k| FLAC__lpc_window_data(integer_signal, encoder->private_->window[apply_apodization_state->a], threadtask->windowed_signal, blocksize); 4334| 14.4k| else 4335| 14.4k| FLAC__lpc_window_data_wide(integer_signal, encoder->private_->window[apply_apodization_state->a], threadtask->windowed_signal, blocksize); 4336| 251k| encoder->private_->local_lpc_compute_autocorrelation(threadtask->windowed_signal, blocksize, (*max_lpc_order_this_apodization)+1, apply_apodization_state->autoc); 4337| 251k| if(apply_apodization_state->current_apodization->type == FLAC__APODIZATION_SUBDIVIDE_TUKEY){ ------------------ | Branch (4337:6): [True: 3.42k, False: 248k] ------------------ 4338| 3.42k| uint32_t i; 4339| 34.0k| for(i = 0; i < *max_lpc_order_this_apodization; i++) ------------------ | Branch (4339:15): [True: 30.5k, False: 3.42k] ------------------ 4340| 30.5k| memcpy(apply_apodization_state->autoc_root, apply_apodization_state->autoc, *max_lpc_order_this_apodization*sizeof(apply_apodization_state->autoc[0])); 4341| | 4342| 3.42k| (apply_apodization_state->b)++; 4343| 248k| }else{ 4344| 248k| (apply_apodization_state->a)++; 4345| 248k| } 4346| 251k| } 4347| 338M| else { 4348| | /* window part of subblock */ 4349| 338M| if(blocksize/apply_apodization_state->b <= FLAC__MAX_LPC_ORDER) { ------------------ | | 128| 338M|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (4349:6): [True: 337M, False: 95.6k] ------------------ 4350| | /* intrinsics autocorrelation routines do not all handle cases in which lag might be 4351| | * larger than data_len, and some routines round lag up to the nearest multiple of 4 4352| | * As little gain is expected from using LPC on part of a signal as small as 32 samples 4353| | * and to enable widening this rounding up to larger values in the future, windowing 4354| | * parts smaller than or equal to FLAC__MAX_LPC_ORDER (which is 32) samples is not supported */ 4355| 337M| set_next_subdivide_tukey(apply_apodization_state->current_apodization->parameters.subdivide_tukey.parts, &apply_apodization_state->a, &apply_apodization_state->b, &apply_apodization_state->c); 4356| 337M| return false; 4357| 337M| } 4358| 95.6k| if(!(apply_apodization_state->c % 2)) { ------------------ | Branch (4358:6): [True: 50.5k, False: 45.0k] ------------------ 4359| | /* on even c, evaluate the (c/2)th partial window of size blocksize/b */ 4360| 50.5k| if(subframe_bps <= 32) ------------------ | Branch (4360:7): [True: 47.3k, False: 3.20k] ------------------ 4361| 47.3k| FLAC__lpc_window_data_partial(integer_signal, encoder->private_->window[apply_apodization_state->a], threadtask->windowed_signal, blocksize, blocksize/apply_apodization_state->b/2, (apply_apodization_state->c/2*blocksize)/apply_apodization_state->b); 4362| 3.20k| else 4363| 3.20k| FLAC__lpc_window_data_partial_wide(integer_signal, encoder->private_->window[apply_apodization_state->a], threadtask->windowed_signal, blocksize, blocksize/apply_apodization_state->b/2, (apply_apodization_state->c/2*blocksize)/apply_apodization_state->b); 4364| 50.5k| encoder->private_->local_lpc_compute_autocorrelation(threadtask->windowed_signal, blocksize/apply_apodization_state->b, (*max_lpc_order_this_apodization)+1, apply_apodization_state->autoc); 4365| 50.5k| } 4366| 45.0k| else { 4367| | /* on uneven c, evaluate the root window (over the whole block) minus the previous partial window 4368| | * similar to tukey_punchout apodization but more efficient */ 4369| 45.0k| uint32_t i; 4370| 583k| for(i = 0; i < *max_lpc_order_this_apodization; i++) ------------------ | Branch (4370:15): [True: 538k, False: 45.0k] ------------------ 4371| 538k| apply_apodization_state->autoc[i] = apply_apodization_state->autoc_root[i] - apply_apodization_state->autoc[i]; 4372| 45.0k| } 4373| | /* Next function sets a, b and c appropriate for next iteration */ 4374| 95.6k| set_next_subdivide_tukey(apply_apodization_state->current_apodization->parameters.subdivide_tukey.parts, &apply_apodization_state->a, &apply_apodization_state->b, &apply_apodization_state->c); 4375| 95.6k| } 4376| | 4377| 347k| if(apply_apodization_state->autoc[0] == 0.0) /* Signal seems to be constant, so we can't do lp. Constant detection is probably disabled */ ------------------ | Branch (4377:5): [True: 3.23k, False: 344k] ------------------ 4378| 3.23k| return false; 4379| 344k| FLAC__lpc_compute_lp_coefficients(apply_apodization_state->autoc, max_lpc_order_this_apodization, threadtask->lp_coeff, lpc_error); 4380| 344k| *guess_lpc_order = 4381| 344k| FLAC__lpc_compute_best_order( 4382| 344k| lpc_error, 4383| 344k| *max_lpc_order_this_apodization, 4384| 344k| blocksize, 4385| 344k| subframe_bps + ( 4386| 344k| encoder->protected_->do_qlp_coeff_prec_search? ------------------ | Branch (4386:4): [True: 157k, False: 186k] ------------------ 4387| 157k| FLAC__MIN_QLP_COEFF_PRECISION : /* have to guess; use the min possible size to avoid accidentally favoring lower orders */ ------------------ | | 137| 157k|#define FLAC__MIN_QLP_COEFF_PRECISION (5u) ------------------ 4388| 344k| encoder->protected_->qlp_coeff_precision 4389| 344k| ) 4390| 344k| ); 4391| | return true; 4392| 347k|} stream_encoder.c:set_next_subdivide_tukey: 4293| 338M|static inline void set_next_subdivide_tukey(FLAC__int32 parts, uint32_t * apodizations, uint32_t * current_depth, uint32_t * current_part){ 4294| | // current_part is interleaved: even are partial, odd are punchout 4295| 338M| if(*current_depth == 2){ ------------------ | Branch (4295:5): [True: 6.84k, False: 337M] ------------------ 4296| | // For depth 2, we only do partial, no punchout as that is almost redundant 4297| 6.84k| if(*current_part == 0){ ------------------ | Branch (4297:6): [True: 3.42k, False: 3.42k] ------------------ 4298| 3.42k| *current_part = 2; 4299| 3.42k| }else{ /* *current_path == 2 */ 4300| 3.42k| *current_part = 0; 4301| 3.42k| (*current_depth)++; 4302| 3.42k| } 4303| 337M| }else if((*current_part) < (2*(*current_depth)-1)){ ------------------ | Branch (4303:11): [True: 337M, False: 70.0k] ------------------ 4304| 337M| (*current_part)++; 4305| 337M| }else{ /* (*current_part) >= (2*(*current_depth)-1) */ 4306| 70.0k| *current_part = 0; 4307| 70.0k| (*current_depth)++; 4308| 70.0k| } 4309| | 4310| | /* Now check if we are done with this SUBDIVIDE_TUKEY apodization */ 4311| 338M| if(*current_depth > (uint32_t) parts){ ------------------ | Branch (4311:5): [True: 3.42k, False: 338M] ------------------ 4312| 3.42k| (*apodizations)++; 4313| 3.42k| *current_depth = 1; 4314| 3.42k| *current_part = 0; 4315| 3.42k| } 4316| 338M|} stream_encoder.c:evaluate_lpc_subframe_: 4584| 20.2M|{ 4585| 20.2M| FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; /* WATCHOUT: the size is important; some x86 intrinsic routines need more than lpc order elements */ 4586| 20.2M| uint32_t i, residual_bits, estimate; 4587| 20.2M| int quantization, ret; 4588| 20.2M| const uint32_t residual_samples = blocksize - order; 4589| | 4590| | /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps(+1bps for side channel) streams */ 4591| 20.2M| if(subframe_bps <= 17) { ------------------ | Branch (4591:5): [True: 1.88M, False: 18.3M] ------------------ 4592| 1.88M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.88M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.88M] | | ------------------ ------------------ 4593| 1.88M| FLAC__ASSERT(order <= FLAC__MAX_LPC_ORDER); ------------------ | | 38| 1.88M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.88M] | | ------------------ ------------------ 4594| 1.88M| qlp_coeff_precision = flac_min(qlp_coeff_precision, 32 - subframe_bps - FLAC__bitmath_ilog2(order)); ------------------ | | 56| 1.88M|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (4594:25): [True: 1.75M, False: 128k] ------------------ 4595| 1.88M| } 4596| | 4597| 20.2M| ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, qlp_coeff, &quantization); 4598| 20.2M| if(ret != 0) ------------------ | Branch (4598:5): [True: 801k, False: 19.4M] ------------------ 4599| 801k| return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */ 4600| | 4601| 19.4M| if(FLAC__lpc_max_residual_bps(subframe_bps, qlp_coeff, order, quantization) > 32) { ------------------ | Branch (4601:5): [True: 12.9M, False: 6.47M] ------------------ 4602| 12.9M| if(subframe_bps <= 32){ ------------------ | Branch (4602:6): [True: 11.8M, False: 1.13M] ------------------ 4603| 11.8M| if(!FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual)) ------------------ | Branch (4603:7): [True: 1.83M, False: 10.0M] ------------------ 4604| 1.83M| return 0; 4605| 11.8M| } 4606| 1.13M| else 4607| 1.13M| if(!FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual_33bit(((FLAC__int64 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual)) ------------------ | Branch (4607:7): [True: 364k, False: 767k] ------------------ 4608| 364k| return 0; 4609| 12.9M| } 4610| 6.47M| else 4611| 6.47M| if(FLAC__lpc_max_prediction_before_shift_bps(subframe_bps, qlp_coeff, order) <= 32) ------------------ | Branch (4611:6): [True: 3.48M, False: 2.99M] ------------------ 4612| 3.48M| if(subframe_bps <= 16 && qlp_coeff_precision <= 16) ------------------ | Branch (4612:7): [True: 1.58M, False: 1.89M] | Branch (4612:29): [True: 1.58M, False: 0] ------------------ 4613| 1.58M| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual); 4614| 1.89M| else 4615| 1.89M| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual); 4616| 2.99M| else 4617| 2.99M| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual); 4618| | 4619| 17.2M| subframe->type = FLAC__SUBFRAME_TYPE_LPC; 4620| | 4621| 17.2M| subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; 4622| 17.2M| subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; 4623| 17.2M| subframe->data.lpc.residual = residual; 4624| | 4625| 17.2M| residual_bits = 4626| 17.2M| find_best_partition_order_( 4627| 17.2M| encoder->private_, 4628| 17.2M| threadtask, 4629| 17.2M| residual, 4630| 17.2M| abs_residual_partition_sums, 4631| 17.2M| raw_bits_per_partition, 4632| 17.2M| residual_samples, 4633| 17.2M| order, 4634| 17.2M| rice_parameter_limit, 4635| 17.2M| min_partition_order, 4636| 17.2M| max_partition_order, 4637| 17.2M| subframe_bps, 4638| 17.2M| do_escape_coding, 4639| 17.2M| rice_parameter_search_dist, 4640| 17.2M| &subframe->data.lpc.entropy_coding_method 4641| 17.2M| ); 4642| | 4643| 17.2M| subframe->data.lpc.order = order; 4644| 17.2M| subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision; 4645| 17.2M| subframe->data.lpc.quantization_level = quantization; 4646| 17.2M| memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER); ------------------ | | 128| 17.2M|#define FLAC__MAX_LPC_ORDER (32u) ------------------ 4647| 17.2M| if(subframe_bps <= 32) ------------------ | Branch (4647:5): [True: 16.3M, False: 882k] ------------------ 4648| 151M| for(i = 0; i < order; i++) ------------------ | Branch (4648:14): [True: 134M, False: 16.3M] ------------------ 4649| 134M| subframe->data.lpc.warmup[i] = ((FLAC__int32 *)signal)[i]; 4650| 882k| else 4651| 8.30M| for(i = 0; i < order; i++) ------------------ | Branch (4651:14): [True: 7.41M, False: 882k] ------------------ 4652| 7.41M| subframe->data.lpc.warmup[i] = ((FLAC__int64 *)signal)[i]; 4653| | 4654| | 4655| 17.2M| estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + subframe_bps)); 4656| 17.2M| if(residual_bits < UINT32_MAX - estimate) // To make sure estimate doesn't overflow ------------------ | Branch (4656:5): [True: 17.3M, False: 18.4E] ------------------ 4657| 17.3M| estimate += residual_bits; 4658| 18.4E| else 4659| 18.4E| estimate = UINT32_MAX; 4660| | 4661| |#if SPOTCHECK_ESTIMATE 4662| | spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 4663| |#endif 4664| | 4665| 17.2M| return estimate; 4666| 19.4M|} stream_encoder.c:add_subframe_: 4402| 310k|{ 4403| 310k| switch(subframe->type) { 4404| 101k| case FLAC__SUBFRAME_TYPE_CONSTANT: ------------------ | Branch (4404:3): [True: 101k, False: 209k] ------------------ 4405| 101k| if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) { ------------------ | Branch (4405:7): [True: 0, False: 101k] ------------------ 4406| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4407| 0| return false; 4408| 0| } 4409| 101k| break; 4410| 151k| case FLAC__SUBFRAME_TYPE_FIXED: ------------------ | Branch (4410:3): [True: 151k, False: 159k] ------------------ 4411| 151k| if(!FLAC__subframe_add_fixed(&(subframe->data.fixed), blocksize - subframe->data.fixed.order, subframe_bps, subframe->wasted_bits, frame)) { ------------------ | Branch (4411:7): [True: 0, False: 151k] ------------------ 4412| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4413| 0| return false; 4414| 0| } 4415| 151k| break; 4416| 151k| case FLAC__SUBFRAME_TYPE_LPC: ------------------ | Branch (4416:3): [True: 19.0k, False: 291k] ------------------ 4417| 19.0k| if(!FLAC__subframe_add_lpc(&(subframe->data.lpc), blocksize - subframe->data.lpc.order, subframe_bps, subframe->wasted_bits, frame)) { ------------------ | Branch (4417:7): [True: 0, False: 19.0k] ------------------ 4418| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4419| 0| return false; 4420| 0| } 4421| 19.0k| break; 4422| 38.5k| case FLAC__SUBFRAME_TYPE_VERBATIM: ------------------ | Branch (4422:3): [True: 38.5k, False: 272k] ------------------ 4423| 38.5k| if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), blocksize, subframe_bps, subframe->wasted_bits, frame)) { ------------------ | Branch (4423:7): [True: 0, False: 38.5k] ------------------ 4424| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4425| 0| return false; 4426| 0| } 4427| 38.5k| break; 4428| 38.5k| default: ------------------ | Branch (4428:3): [True: 0, False: 310k] ------------------ 4429| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 4430| 310k| } 4431| | 4432| 311k| return true; 4433| 310k|} stream_encoder.c:append_to_verify_fifo_interleaved_: 5139| 368k|{ 5140| 368k| uint32_t channel; 5141| 368k| uint32_t sample, wide_sample; 5142| 368k| uint32_t tail = fifo->tail; 5143| | 5144| 368k| sample = input_offset * channels; 5145| 22.4M| for(wide_sample = 0; wide_sample < wide_samples; wide_sample++) { ------------------ | Branch (5145:23): [True: 22.0M, False: 368k] ------------------ 5146| 50.0M| for(channel = 0; channel < channels; channel++) ------------------ | Branch (5146:20): [True: 27.9M, False: 22.0M] ------------------ 5147| 27.9M| fifo->data[channel][tail] = input[sample++]; 5148| 22.0M| tail++; 5149| 22.0M| } 5150| 368k| fifo->tail = tail; 5151| | 5152| 368k| FLAC__ASSERT(fifo->tail <= fifo->size); ------------------ | | 38| 368k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 368k] | | ------------------ ------------------ 5153| 368k|} FLAC__add_metadata_block: 48| 18.7k|{ 49| 18.7k| uint32_t i, j, metadata_length; 50| 18.7k| const uint32_t vendor_string_length = (uint32_t)strlen(FLAC__VENDOR_STRING); 51| 18.7k| const uint32_t start_bits = FLAC__bitwriter_get_input_bits_unconsumed(bw); 52| | 53| 18.7k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw)); ------------------ | | 38| 18.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.7k] | | ------------------ ------------------ 54| | 55| 18.7k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN)) ------------------ | Branch (55:5): [True: 0, False: 18.7k] ------------------ 56| 0| return false; 57| | 58| 18.7k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN)) ------------------ | Branch (58:5): [True: 0, False: 18.7k] ------------------ 59| 0| return false; 60| | 61| | /* 62| | * First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string 63| | */ 64| 18.7k| metadata_length = metadata->length; 65| 18.7k| if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && update_vendor_string) { ------------------ | Branch (65:5): [True: 9.37k, False: 9.37k] | Branch (65:61): [True: 9.37k, False: 0] ------------------ 66| 9.37k| FLAC__ASSERT(metadata->data.vorbis_comment.vendor_string.length == 0 || 0 != metadata->data.vorbis_comment.vendor_string.entry); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 9.37k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 67| 9.37k| metadata_length -= metadata->data.vorbis_comment.vendor_string.length; 68| 9.37k| metadata_length += vendor_string_length; 69| 9.37k| } 70| 18.7k| FLAC__ASSERT(metadata_length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN)); ------------------ | | 38| 18.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.7k] | | ------------------ ------------------ 71| | /* double protection */ 72| 18.7k| if(metadata_length >= (1u << FLAC__STREAM_METADATA_LENGTH_LEN)) ------------------ | Branch (72:5): [True: 0, False: 18.7k] ------------------ 73| 0| return false; 74| 18.7k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata_length, FLAC__STREAM_METADATA_LENGTH_LEN)) ------------------ | Branch (74:5): [True: 0, False: 18.7k] ------------------ 75| 0| return false; 76| | 77| 18.7k| switch(metadata->type) { 78| 9.37k| case FLAC__METADATA_TYPE_STREAMINFO: ------------------ | Branch (78:3): [True: 9.37k, False: 9.37k] ------------------ 79| 9.37k| FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 80| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.min_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)) ------------------ | Branch (80:7): [True: 0, False: 9.37k] ------------------ 81| 0| return false; 82| 9.37k| FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 83| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.max_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)) ------------------ | Branch (83:7): [True: 0, False: 9.37k] ------------------ 84| 0| return false; 85| 9.37k| FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 86| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.min_framesize, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) ------------------ | Branch (86:7): [True: 0, False: 9.37k] ------------------ 87| 0| return false; 88| 9.37k| FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 89| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) ------------------ | Branch (89:7): [True: 0, False: 9.37k] ------------------ 90| 0| return false; 91| 9.37k| FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate)); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 92| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)) ------------------ | Branch (92:7): [True: 0, False: 9.37k] ------------------ 93| 0| return false; 94| 9.37k| FLAC__ASSERT(metadata->data.stream_info.channels > 0); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 95| 9.37k| FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 96| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.channels-1, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)) ------------------ | Branch (96:7): [True: 0, False: 9.37k] ------------------ 97| 0| return false; 98| 9.37k| FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 99| 9.37k| FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); ------------------ | | 38| 9.37k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.37k] | | ------------------ ------------------ 100| 9.37k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.bits_per_sample-1, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)) ------------------ | Branch (100:7): [True: 0, False: 9.37k] ------------------ 101| 0| return false; 102| 9.37k| if(metadata->data.stream_info.total_samples >= (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)){ ------------------ | | 102| 9.37k|#define FLAC__U64L(x) x##ULL ------------------ | Branch (102:7): [True: 0, False: 9.37k] ------------------ 103| 0| if(!FLAC__bitwriter_write_raw_uint64(bw, 0, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) ------------------ | Branch (103:8): [True: 0, False: 0] ------------------ 104| 0| return false; 105| 9.37k| }else{ 106| 9.37k| if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) ------------------ | Branch (106:8): [True: 0, False: 9.37k] ------------------ 107| 0| return false; 108| 9.37k| } 109| 9.37k| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.stream_info.md5sum, 16)) ------------------ | Branch (109:7): [True: 0, False: 9.37k] ------------------ 110| 0| return false; 111| 9.37k| break; 112| 9.37k| case FLAC__METADATA_TYPE_PADDING: ------------------ | Branch (112:3): [True: 0, False: 18.7k] ------------------ 113| 0| if(!FLAC__bitwriter_write_zeroes(bw, metadata->length * 8)) ------------------ | Branch (113:7): [True: 0, False: 0] ------------------ 114| 0| return false; 115| 0| break; 116| 0| case FLAC__METADATA_TYPE_APPLICATION: ------------------ | Branch (116:3): [True: 0, False: 18.7k] ------------------ 117| 0| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)) ------------------ | Branch (117:7): [True: 0, False: 0] ------------------ 118| 0| return false; 119| 0| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.application.data, metadata->length - (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8))) ------------------ | Branch (119:7): [True: 0, False: 0] ------------------ 120| 0| return false; 121| 0| break; 122| 0| case FLAC__METADATA_TYPE_SEEKTABLE: ------------------ | Branch (122:3): [True: 0, False: 18.7k] ------------------ 123| 0| for(i = 0; i < metadata->data.seek_table.num_points; i++) { ------------------ | Branch (123:15): [True: 0, False: 0] ------------------ 124| 0| if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.seek_table.points[i].sample_number, FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN)) ------------------ | Branch (124:8): [True: 0, False: 0] ------------------ 125| 0| return false; 126| 0| if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.seek_table.points[i].stream_offset, FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN)) ------------------ | Branch (126:8): [True: 0, False: 0] ------------------ 127| 0| return false; 128| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.seek_table.points[i].frame_samples, FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN)) ------------------ | Branch (128:8): [True: 0, False: 0] ------------------ 129| 0| return false; 130| 0| } 131| 0| break; 132| 9.37k| case FLAC__METADATA_TYPE_VORBIS_COMMENT: ------------------ | Branch (132:3): [True: 9.37k, False: 9.37k] ------------------ 133| 9.37k| if(update_vendor_string) { ------------------ | Branch (133:7): [True: 9.37k, False: 0] ------------------ 134| 9.37k| if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, vendor_string_length)) ------------------ | Branch (134:8): [True: 0, False: 9.37k] ------------------ 135| 0| return false; 136| 9.37k| if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length)) ------------------ | Branch (136:8): [True: 0, False: 9.37k] ------------------ 137| 0| return false; 138| 9.37k| } 139| 0| else { 140| 0| if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.vendor_string.length)) ------------------ | Branch (140:8): [True: 0, False: 0] ------------------ 141| 0| return false; 142| 0| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.vorbis_comment.vendor_string.entry, metadata->data.vorbis_comment.vendor_string.length)) ------------------ | Branch (142:8): [True: 0, False: 0] ------------------ 143| 0| return false; 144| 0| } 145| 9.37k| if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.num_comments)) ------------------ | Branch (145:7): [True: 0, False: 9.37k] ------------------ 146| 0| return false; 147| 9.37k| for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) { ------------------ | Branch (147:15): [True: 0, False: 9.37k] ------------------ 148| 0| if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.comments[i].length)) ------------------ | Branch (148:8): [True: 0, False: 0] ------------------ 149| 0| return false; 150| 0| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length)) ------------------ | Branch (150:8): [True: 0, False: 0] ------------------ 151| 0| return false; 152| 0| } 153| 9.37k| break; 154| 9.37k| case FLAC__METADATA_TYPE_CUESHEET: ------------------ | Branch (154:3): [True: 0, False: 18.7k] ------------------ 155| 0| FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 156| 0| if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)metadata->data.cue_sheet.media_catalog_number, FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN/8)) ------------------ | Branch (156:7): [True: 0, False: 0] ------------------ 157| 0| return false; 158| 0| if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.cue_sheet.lead_in, FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN)) ------------------ | Branch (158:7): [True: 0, False: 0] ------------------ 159| 0| return false; 160| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.cue_sheet.is_cd? 1 : 0, FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN)) ------------------ | Branch (160:7): [True: 0, False: 0] | Branch (160:45): [True: 0, False: 0] ------------------ 161| 0| return false; 162| 0| if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN)) ------------------ | Branch (162:7): [True: 0, False: 0] ------------------ 163| 0| return false; 164| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.cue_sheet.num_tracks, FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN)) ------------------ | Branch (164:7): [True: 0, False: 0] ------------------ 165| 0| return false; 166| 0| for(i = 0; i < metadata->data.cue_sheet.num_tracks; i++) { ------------------ | Branch (166:15): [True: 0, False: 0] ------------------ 167| 0| const FLAC__StreamMetadata_CueSheet_Track *track = metadata->data.cue_sheet.tracks + i; 168| | 169| 0| if(!FLAC__bitwriter_write_raw_uint64(bw, track->offset, FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN)) ------------------ | Branch (169:8): [True: 0, False: 0] ------------------ 170| 0| return false; 171| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, track->number, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN)) ------------------ | Branch (171:8): [True: 0, False: 0] ------------------ 172| 0| return false; 173| 0| FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 0] | | ------------------ ------------------ 174| 0| if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)track->isrc, FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN/8)) ------------------ | Branch (174:8): [True: 0, False: 0] ------------------ 175| 0| return false; 176| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, track->type, FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN)) ------------------ | Branch (176:8): [True: 0, False: 0] ------------------ 177| 0| return false; 178| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, track->pre_emphasis, FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN)) ------------------ | Branch (178:8): [True: 0, False: 0] ------------------ 179| 0| return false; 180| 0| if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN)) ------------------ | Branch (180:8): [True: 0, False: 0] ------------------ 181| 0| return false; 182| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, track->num_indices, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN)) ------------------ | Branch (182:8): [True: 0, False: 0] ------------------ 183| 0| return false; 184| 0| for(j = 0; j < track->num_indices; j++) { ------------------ | Branch (184:16): [True: 0, False: 0] ------------------ 185| 0| const FLAC__StreamMetadata_CueSheet_Index *indx = track->indices + j; 186| | 187| 0| if(!FLAC__bitwriter_write_raw_uint64(bw, indx->offset, FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN)) ------------------ | Branch (187:9): [True: 0, False: 0] ------------------ 188| 0| return false; 189| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, indx->number, FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN)) ------------------ | Branch (189:9): [True: 0, False: 0] ------------------ 190| 0| return false; 191| 0| if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN)) ------------------ | Branch (191:9): [True: 0, False: 0] ------------------ 192| 0| return false; 193| 0| } 194| 0| } 195| 0| break; 196| 0| case FLAC__METADATA_TYPE_PICTURE: ------------------ | Branch (196:3): [True: 0, False: 18.7k] ------------------ 197| 0| { 198| 0| size_t len; 199| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.type, FLAC__STREAM_METADATA_PICTURE_TYPE_LEN)) ------------------ | Branch (199:8): [True: 0, False: 0] ------------------ 200| 0| return false; 201| 0| len = strlen(metadata->data.picture.mime_type); 202| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, len, FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN)) ------------------ | Branch (202:8): [True: 0, False: 0] ------------------ 203| 0| return false; 204| 0| if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)metadata->data.picture.mime_type, len)) ------------------ | Branch (204:8): [True: 0, False: 0] ------------------ 205| 0| return false; 206| 0| len = strlen((const char *)metadata->data.picture.description); 207| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, len, FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN)) ------------------ | Branch (207:8): [True: 0, False: 0] ------------------ 208| 0| return false; 209| 0| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.picture.description, len)) ------------------ | Branch (209:8): [True: 0, False: 0] ------------------ 210| 0| return false; 211| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.width, FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN)) ------------------ | Branch (211:8): [True: 0, False: 0] ------------------ 212| 0| return false; 213| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.height, FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN)) ------------------ | Branch (213:8): [True: 0, False: 0] ------------------ 214| 0| return false; 215| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.depth, FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN)) ------------------ | Branch (215:8): [True: 0, False: 0] ------------------ 216| 0| return false; 217| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.colors, FLAC__STREAM_METADATA_PICTURE_COLORS_LEN)) ------------------ | Branch (217:8): [True: 0, False: 0] ------------------ 218| 0| return false; 219| 0| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.data_length, FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN)) ------------------ | Branch (219:8): [True: 0, False: 0] ------------------ 220| 0| return false; 221| 0| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.picture.data, metadata->data.picture.data_length)) ------------------ | Branch (221:8): [True: 0, False: 0] ------------------ 222| 0| return false; 223| 0| } 224| 0| break; 225| 0| default: ------------------ | Branch (225:3): [True: 0, False: 18.7k] ------------------ 226| 0| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.unknown.data, metadata->length)) ------------------ | Branch (226:7): [True: 0, False: 0] ------------------ 227| 0| return false; 228| 0| break; 229| 18.7k| } 230| | 231| | /* Now check whether metadata block length was correct */ 232| 18.7k| { 233| 18.7k| uint32_t length_in_bits = FLAC__bitwriter_get_input_bits_unconsumed(bw); 234| 18.7k| if(length_in_bits < start_bits) ------------------ | Branch (234:6): [True: 0, False: 18.7k] ------------------ 235| 0| return false; 236| 18.7k| length_in_bits -= start_bits; 237| 18.7k| if(length_in_bits % 8 != 0 || length_in_bits != (metadata_length*8+32)) ------------------ | Branch (237:6): [True: 0, False: 18.7k] | Branch (237:33): [True: 0, False: 18.7k] ------------------ 238| 0| return false; 239| 18.7k| } 240| | 241| 18.7k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw)); ------------------ | | 38| 18.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.7k] | | ------------------ ------------------ 242| | return true; 243| 18.7k|} FLAC__frame_add_header: 246| 243k|{ 247| 243k| uint32_t u, blocksize_hint, sample_rate_hint; 248| 243k| FLAC__byte crc; 249| | 250| 243k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw)); ------------------ | | 38| 243k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 243k] | | ------------------ ------------------ 251| | 252| 243k| if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN)) ------------------ | Branch (252:5): [True: 0, False: 243k] ------------------ 253| 0| return false; 254| | 255| 243k| if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_RESERVED_LEN)) ------------------ | Branch (255:5): [True: 0, False: 243k] ------------------ 256| 0| return false; 257| | 258| 243k| if(!FLAC__bitwriter_write_raw_uint32(bw, (header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER)? 0 : 1, FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN)) ------------------ | Branch (258:5): [True: 0, False: 243k] | Branch (258:43): [True: 242k, False: 1.00k] ------------------ 259| 0| return false; 260| | 261| 243k| FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE); ------------------ | | 38| 485k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 242k, False: 1.48k] | | | Branch (38:30): [True: 242k, False: 18.4E] | | ------------------ ------------------ 262| | /* when this assertion holds true, any legal blocksize can be expressed in the frame header */ 263| 243k| FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535u); ------------------ | | 38| 243k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 243k] | | ------------------ ------------------ 264| 243k| blocksize_hint = 0; 265| 243k| switch(header->blocksize) { 266| 196| case 192: u = 1; break; ------------------ | Branch (266:3): [True: 196, False: 243k] ------------------ 267| 201| case 576: u = 2; break; ------------------ | Branch (267:3): [True: 201, False: 243k] ------------------ 268| 121| case 1152: u = 3; break; ------------------ | Branch (268:3): [True: 121, False: 243k] ------------------ 269| 68| case 2304: u = 4; break; ------------------ | Branch (269:3): [True: 68, False: 243k] ------------------ 270| 49| case 4608: u = 5; break; ------------------ | Branch (270:3): [True: 49, False: 243k] ------------------ 271| 286| case 256: u = 8; break; ------------------ | Branch (271:3): [True: 286, False: 243k] ------------------ 272| 242| case 512: u = 9; break; ------------------ | Branch (272:3): [True: 242, False: 243k] ------------------ 273| 149| case 1024: u = 10; break; ------------------ | Branch (273:3): [True: 149, False: 243k] ------------------ 274| 84| case 2048: u = 11; break; ------------------ | Branch (274:3): [True: 84, False: 243k] ------------------ 275| 171| case 4096: u = 12; break; ------------------ | Branch (275:3): [True: 171, False: 243k] ------------------ 276| 26| case 8192: u = 13; break; ------------------ | Branch (276:3): [True: 26, False: 243k] ------------------ 277| 32| case 16384: u = 14; break; ------------------ | Branch (277:3): [True: 32, False: 243k] ------------------ 278| 21| case 32768: u = 15; break; ------------------ | Branch (278:3): [True: 21, False: 243k] ------------------ 279| 240k| default: ------------------ | Branch (279:3): [True: 240k, False: 3.13k] ------------------ 280| 240k| if(header->blocksize <= 0x100) ------------------ | Branch (280:7): [True: 238k, False: 1.86k] ------------------ 281| 238k| blocksize_hint = u = 6; 282| 1.86k| else 283| 1.86k| blocksize_hint = u = 7; 284| 240k| break; 285| 243k| } 286| 242k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN)) ------------------ | Branch (286:5): [True: 0, False: 242k] ------------------ 287| 0| return false; 288| | 289| 242k| FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate)); ------------------ | | 38| 242k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 242k] | | ------------------ ------------------ 290| 242k| sample_rate_hint = 0; 291| 242k| switch(header->sample_rate) { 292| 413| case 88200: u = 1; break; ------------------ | Branch (292:3): [True: 413, False: 241k] ------------------ 293| 637| case 176400: u = 2; break; ------------------ | Branch (293:3): [True: 637, False: 241k] ------------------ 294| 1.39k| case 192000: u = 3; break; ------------------ | Branch (294:3): [True: 1.39k, False: 240k] ------------------ 295| 1.39k| case 8000: u = 4; break; ------------------ | Branch (295:3): [True: 1.39k, False: 240k] ------------------ 296| 88| case 16000: u = 5; break; ------------------ | Branch (296:3): [True: 88, False: 242k] ------------------ 297| 1.05k| case 22050: u = 6; break; ------------------ | Branch (297:3): [True: 1.05k, False: 241k] ------------------ 298| 342| case 24000: u = 7; break; ------------------ | Branch (298:3): [True: 342, False: 241k] ------------------ 299| 2.91k| case 32000: u = 8; break; ------------------ | Branch (299:3): [True: 2.91k, False: 239k] ------------------ 300| 40.4k| case 44100: u = 9; break; ------------------ | Branch (300:3): [True: 40.4k, False: 201k] ------------------ 301| 422| case 48000: u = 10; break; ------------------ | Branch (301:3): [True: 422, False: 241k] ------------------ 302| 5.67k| case 96000: u = 11; break; ------------------ | Branch (302:3): [True: 5.67k, False: 236k] ------------------ 303| 187k| default: ------------------ | Branch (303:3): [True: 187k, False: 54.9k] ------------------ 304| 187k| if(header->sample_rate <= 255000 && header->sample_rate % 1000 == 0) ------------------ | Branch (304:7): [True: 176k, False: 10.5k] | Branch (304:40): [True: 34.4k, False: 142k] ------------------ 305| 34.4k| sample_rate_hint = u = 12; 306| 152k| else if(header->sample_rate <= 655350 && header->sample_rate % 10 == 0) ------------------ | Branch (306:12): [True: 148k, False: 3.90k] | Branch (306:45): [True: 46.8k, False: 101k] ------------------ 307| 46.8k| sample_rate_hint = u = 14; 308| 105k| else if(header->sample_rate <= 0xffff) ------------------ | Branch (308:12): [True: 84.4k, False: 21.4k] ------------------ 309| 84.4k| sample_rate_hint = u = 13; 310| 21.4k| else 311| 21.4k| u = 0; 312| 187k| break; 313| 242k| } 314| 242k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN)) ------------------ | Branch (314:5): [True: 0, False: 242k] ------------------ 315| 0| return false; 316| | 317| 242k| FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS); ------------------ | | 38| 968k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 242k, False: 63] | | | Branch (38:30): [True: 242k, False: 18.4E] | | | Branch (38:30): [True: 242k, False: 18.4E] | | ------------------ ------------------ 318| 242k| switch(header->channel_assignment) { 319| 206k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (319:3): [True: 206k, False: 35.9k] ------------------ 320| 206k| u = header->channels - 1; 321| 206k| break; 322| 17.2k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (322:3): [True: 17.2k, False: 224k] ------------------ 323| 17.2k| FLAC__ASSERT(header->channels == 2); ------------------ | | 38| 17.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.2k] | | ------------------ ------------------ 324| 17.2k| u = 8; 325| 17.2k| break; 326| 7.66k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (326:3): [True: 7.66k, False: 234k] ------------------ 327| 7.66k| FLAC__ASSERT(header->channels == 2); ------------------ | | 38| 7.66k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 7.66k] | | ------------------ ------------------ 328| 7.66k| u = 9; 329| 7.66k| break; 330| 11.0k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (330:3): [True: 11.0k, False: 231k] ------------------ 331| 11.0k| FLAC__ASSERT(header->channels == 2); ------------------ | | 38| 11.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.0k] | | ------------------ ------------------ 332| 11.0k| u = 10; 333| 11.0k| break; 334| 0| default: ------------------ | Branch (334:3): [True: 0, False: 242k] ------------------ 335| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 336| 242k| } 337| 242k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN)) ------------------ | Branch (337:5): [True: 0, False: 242k] ------------------ 338| 0| return false; 339| | 340| 242k| FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); ------------------ | | 38| 484k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 242k, False: 18.4E] | | | Branch (38:30): [True: 242k, False: 18.4E] | | ------------------ ------------------ 341| 242k| switch(header->bits_per_sample) { 342| 3.08k| case 8 : u = 1; break; ------------------ | Branch (342:3): [True: 3.08k, False: 239k] ------------------ 343| 249| case 12: u = 2; break; ------------------ | Branch (343:3): [True: 249, False: 241k] ------------------ 344| 5.94k| case 16: u = 4; break; ------------------ | Branch (344:3): [True: 5.94k, False: 236k] ------------------ 345| 410| case 20: u = 5; break; ------------------ | Branch (345:3): [True: 410, False: 241k] ------------------ 346| 11.0k| case 24: u = 6; break; ------------------ | Branch (346:3): [True: 11.0k, False: 231k] ------------------ 347| 217k| case 32: u = 7; break; ------------------ | Branch (347:3): [True: 217k, False: 25.1k] ------------------ 348| 4.55k| default: u = 0; break; ------------------ | Branch (348:3): [True: 4.55k, False: 237k] ------------------ 349| 242k| } 350| 242k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN)) ------------------ | Branch (350:5): [True: 0, False: 242k] ------------------ 351| 0| return false; 352| | 353| 242k| if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_ZERO_PAD_LEN)) ------------------ | Branch (353:5): [True: 0, False: 242k] ------------------ 354| 0| return false; 355| | 356| 242k| if(header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) { ------------------ | Branch (356:5): [True: 242k, False: 119] ------------------ 357| 242k| if(!FLAC__bitwriter_write_utf8_uint32(bw, header->number.frame_number)) ------------------ | Branch (357:6): [True: 0, False: 242k] ------------------ 358| 0| return false; 359| 242k| } 360| 119| else { 361| 119| if(!FLAC__bitwriter_write_utf8_uint64(bw, header->number.sample_number)) ------------------ | Branch (361:6): [True: 0, False: 119] ------------------ 362| 0| return false; 363| 119| } 364| | 365| 242k| if(blocksize_hint) ------------------ | Branch (365:5): [True: 240k, False: 1.63k] ------------------ 366| 240k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->blocksize-1, (blocksize_hint==6)? 8:16)) ------------------ | Branch (366:6): [True: 0, False: 240k] | Branch (366:65): [True: 238k, False: 1.88k] ------------------ 367| 0| return false; 368| | 369| 242k| switch(sample_rate_hint) { ------------------ | Branch (369:9): [True: 165k, False: 76.3k] ------------------ 370| 34.6k| case 12: ------------------ | Branch (370:3): [True: 34.6k, False: 207k] ------------------ 371| 34.6k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 1000, 8)) ------------------ | Branch (371:7): [True: 0, False: 34.6k] ------------------ 372| 0| return false; 373| 34.6k| break; 374| 84.4k| case 13: ------------------ | Branch (374:3): [True: 84.4k, False: 157k] ------------------ 375| 84.4k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate, 16)) ------------------ | Branch (375:7): [True: 0, False: 84.4k] ------------------ 376| 0| return false; 377| 84.4k| break; 378| 84.4k| case 14: ------------------ | Branch (378:3): [True: 46.8k, False: 195k] ------------------ 379| 46.8k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 10, 16)) ------------------ | Branch (379:7): [True: 0, False: 46.8k] ------------------ 380| 0| return false; 381| 46.8k| break; 382| 242k| } 383| | 384| | /* write the CRC */ 385| 242k| if(!FLAC__bitwriter_get_write_crc8(bw, &crc)) ------------------ | Branch (385:5): [True: 0, False: 242k] ------------------ 386| 0| return false; 387| 242k| if(!FLAC__bitwriter_write_raw_uint32(bw, crc, FLAC__FRAME_HEADER_CRC_LEN)) ------------------ | Branch (387:5): [True: 0, False: 242k] ------------------ 388| 0| return false; 389| | 390| 242k| return true; 391| 242k|} FLAC__subframe_add_constant: 394| 101k|{ 395| 101k| FLAC__bool ok; 396| | 397| 101k| ok = 398| 101k| FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN) && ------------------ | Branch (398:3): [True: 101k, False: 35] | Branch (398:90): [True: 1.26k, False: 100k] ------------------ 399| 101k| (wasted_bits? FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1) : true) && ------------------ | Branch (399:3): [True: 101k, False: 18.4E] | Branch (399:4): [True: 1.26k, False: 100k] ------------------ 400| 101k| FLAC__bitwriter_write_raw_int64(bw, subframe->value, subframe_bps) ------------------ | Branch (400:3): [True: 101k, False: 66] ------------------ 401| 101k| ; 402| | 403| 101k| return ok; 404| 101k|} FLAC__subframe_add_fixed: 407| 151k|{ 408| 151k| uint32_t i; 409| | 410| 151k| if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK | (subframe->order<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN)) ------------------ | Branch (410:5): [True: 0, False: 151k] | Branch (410:113): [True: 23.2k, False: 128k] ------------------ 411| 0| return false; 412| 151k| if(wasted_bits) ------------------ | Branch (412:5): [True: 23.2k, False: 128k] ------------------ 413| 23.2k| if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1)) ------------------ | Branch (413:6): [True: 0, False: 23.2k] ------------------ 414| 0| return false; 415| | 416| 263k| for(i = 0; i < subframe->order; i++) ------------------ | Branch (416:13): [True: 111k, False: 151k] ------------------ 417| 111k| if(!FLAC__bitwriter_write_raw_int64(bw, subframe->warmup[i], subframe_bps)) ------------------ | Branch (417:6): [True: 0, False: 111k] ------------------ 418| 0| return false; 419| | 420| 151k| if(!add_entropy_coding_method_(bw, &subframe->entropy_coding_method)) ------------------ | Branch (420:5): [True: 0, False: 151k] ------------------ 421| 0| return false; 422| 151k| switch(subframe->entropy_coding_method.type) { 423| 70.6k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (423:3): [True: 70.6k, False: 81.1k] ------------------ 424| 151k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (424:3): [True: 80.8k, False: 70.9k] ------------------ 425| 151k| if(!add_residual_partitioned_rice_( ------------------ | Branch (425:7): [True: 0, False: 151k] ------------------ 426| 151k| bw, 427| 151k| subframe->residual, 428| 151k| residual_samples, 429| 151k| subframe->order, 430| 151k| subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, 431| 151k| subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, 432| 151k| subframe->entropy_coding_method.data.partitioned_rice.order, 433| 151k| /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 434| 151k| )) 435| 0| return false; 436| 151k| break; 437| 151k| default: ------------------ | Branch (437:3): [True: 0, False: 151k] ------------------ 438| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 439| 151k| } 440| | 441| 152k| return true; 442| 151k|} FLAC__subframe_add_lpc: 445| 19.0k|{ 446| 19.0k| uint32_t i; 447| | 448| 19.0k| if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK | ((subframe->order-1)<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN)) ------------------ | Branch (448:5): [True: 0, False: 19.0k] | Branch (448:115): [True: 5.43k, False: 13.6k] ------------------ 449| 0| return false; 450| 19.0k| if(wasted_bits) ------------------ | Branch (450:5): [True: 5.43k, False: 13.6k] ------------------ 451| 5.43k| if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1)) ------------------ | Branch (451:6): [True: 0, False: 5.43k] ------------------ 452| 0| return false; 453| | 454| 124k| for(i = 0; i < subframe->order; i++) ------------------ | Branch (454:13): [True: 105k, False: 19.0k] ------------------ 455| 105k| if(!FLAC__bitwriter_write_raw_int64(bw, subframe->warmup[i], subframe_bps)) ------------------ | Branch (455:6): [True: 0, False: 105k] ------------------ 456| 0| return false; 457| | 458| 19.0k| if(!FLAC__bitwriter_write_raw_uint32(bw, subframe->qlp_coeff_precision-1, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN)) ------------------ | Branch (458:5): [True: 0, False: 19.0k] ------------------ 459| 0| return false; 460| 19.0k| if(!FLAC__bitwriter_write_raw_int32(bw, subframe->quantization_level, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN)) ------------------ | Branch (460:5): [True: 0, False: 19.0k] ------------------ 461| 0| return false; 462| 124k| for(i = 0; i < subframe->order; i++) ------------------ | Branch (462:13): [True: 105k, False: 19.0k] ------------------ 463| 105k| if(!FLAC__bitwriter_write_raw_int32(bw, subframe->qlp_coeff[i], subframe->qlp_coeff_precision)) ------------------ | Branch (463:6): [True: 0, False: 105k] ------------------ 464| 0| return false; 465| | 466| 19.0k| if(!add_entropy_coding_method_(bw, &subframe->entropy_coding_method)) ------------------ | Branch (466:5): [True: 0, False: 19.0k] ------------------ 467| 0| return false; 468| 19.0k| switch(subframe->entropy_coding_method.type) { 469| 13.2k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (469:3): [True: 13.2k, False: 5.84k] ------------------ 470| 19.0k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (470:3): [True: 5.84k, False: 13.2k] ------------------ 471| 19.0k| if(!add_residual_partitioned_rice_( ------------------ | Branch (471:7): [True: 0, False: 19.0k] ------------------ 472| 19.0k| bw, 473| 19.0k| subframe->residual, 474| 19.0k| residual_samples, 475| 19.0k| subframe->order, 476| 19.0k| subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, 477| 19.0k| subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, 478| 19.0k| subframe->entropy_coding_method.data.partitioned_rice.order, 479| 19.0k| /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 480| 19.0k| )) 481| 0| return false; 482| 19.0k| break; 483| 19.0k| default: ------------------ | Branch (483:3): [True: 0, False: 19.0k] ------------------ 484| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 485| 19.0k| } 486| | 487| 19.0k| return true; 488| 19.0k|} FLAC__subframe_add_verbatim: 491| 38.5k|{ 492| 38.5k| uint32_t i; 493| | 494| 38.5k| if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN)) ------------------ | Branch (494:5): [True: 0, False: 38.5k] | Branch (494:93): [True: 1.94k, False: 36.6k] ------------------ 495| 0| return false; 496| 38.5k| if(wasted_bits) ------------------ | Branch (496:5): [True: 1.94k, False: 36.6k] ------------------ 497| 1.94k| if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1)) ------------------ | Branch (497:6): [True: 0, False: 1.94k] ------------------ 498| 0| return false; 499| | 500| 38.5k| if(subframe->data_type == FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32) { ------------------ | Branch (500:5): [True: 37.7k, False: 749] ------------------ 501| 37.7k| const FLAC__int32 *signal = subframe->data.int32; 502| | 503| 37.7k| FLAC__ASSERT(subframe_bps < 33); ------------------ | | 38| 37.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 37.7k] | | ------------------ ------------------ 504| | 505| 2.73M| for(i = 0; i < samples; i++) ------------------ | Branch (505:14): [True: 2.69M, False: 37.7k] ------------------ 506| 2.69M| if(!FLAC__bitwriter_write_raw_int32(bw, signal[i], subframe_bps)) ------------------ | Branch (506:7): [True: 0, False: 2.69M] ------------------ 507| 0| return false; 508| 37.7k| } 509| 749| else { 510| 749| const FLAC__int64 *signal = subframe->data.int64; 511| | 512| 749| FLAC__ASSERT(subframe_bps == 33); ------------------ | | 38| 749|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 749] | | ------------------ ------------------ 513| | 514| 1.62M| for(i = 0; i < samples; i++) ------------------ | Branch (514:14): [True: 1.62M, False: 749] ------------------ 515| 1.62M| if(!FLAC__bitwriter_write_raw_int64(bw, (FLAC__int64)signal[i], subframe_bps)) ------------------ | Branch (515:7): [True: 0, False: 1.62M] ------------------ 516| 0| return false; 517| 749| } 518| | 519| 38.5k| return true; 520| 38.5k|} stream_encoder_framing.c:add_entropy_coding_method_: 523| 170k|{ 524| 170k| if(!FLAC__bitwriter_write_raw_uint32(bw, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN)) ------------------ | Branch (524:5): [True: 0, False: 170k] ------------------ 525| 0| return false; 526| 170k| switch(method->type) { 527| 83.8k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (527:3): [True: 83.8k, False: 86.6k] ------------------ 528| 170k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (528:3): [True: 86.6k, False: 83.8k] ------------------ 529| 170k| if(!FLAC__bitwriter_write_raw_uint32(bw, method->data.partitioned_rice.order, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) ------------------ | Branch (529:7): [True: 0, False: 170k] ------------------ 530| 0| return false; 531| 170k| break; 532| 170k| default: ------------------ | Branch (532:3): [True: 0, False: 170k] ------------------ 533| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 534| 170k| } 535| 170k| return true; 536| 170k|} stream_encoder_framing.c:add_residual_partitioned_rice_: 539| 170k|{ 540| 170k| const uint32_t plen = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; ------------------ | Branch (540:24): [True: 86.6k, False: 83.9k] ------------------ 541| 170k| const uint32_t pesc = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; ------------------ | Branch (541:24): [True: 86.6k, False: 83.8k] ------------------ 542| | 543| 170k| if(partition_order == 0) { ------------------ | Branch (543:5): [True: 110k, False: 59.5k] ------------------ 544| 110k| uint32_t i; 545| | 546| 110k| if(raw_bits[0] == 0) { ------------------ | Branch (546:6): [True: 102k, False: 8.99k] ------------------ 547| 102k| if(!FLAC__bitwriter_write_raw_uint32(bw, rice_parameters[0], plen)) ------------------ | Branch (547:7): [True: 0, False: 102k] ------------------ 548| 0| return false; 549| 102k| if(!FLAC__bitwriter_write_rice_signed_block(bw, residual, residual_samples, rice_parameters[0])) ------------------ | Branch (549:7): [True: 0, False: 102k] ------------------ 550| 0| return false; 551| 102k| } 552| 8.99k| else { 553| 8.99k| FLAC__ASSERT(rice_parameters[0] == 0); ------------------ | | 38| 8.99k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.99k] | | ------------------ ------------------ 554| 8.99k| if(!FLAC__bitwriter_write_raw_uint32(bw, pesc, plen)) ------------------ | Branch (554:7): [True: 0, False: 8.99k] ------------------ 555| 0| return false; 556| 8.99k| if(!FLAC__bitwriter_write_raw_uint32(bw, raw_bits[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN)) ------------------ | Branch (556:7): [True: 0, False: 8.99k] ------------------ 557| 0| return false; 558| 166k| for(i = 0; i < residual_samples; i++) { ------------------ | Branch (558:15): [True: 157k, False: 8.99k] ------------------ 559| 157k| if(!FLAC__bitwriter_write_raw_int32(bw, residual[i], raw_bits[0])) ------------------ | Branch (559:8): [True: 0, False: 157k] ------------------ 560| 0| return false; 561| 157k| } 562| 8.99k| } 563| 110k| return true; 564| 110k| } 565| 59.5k| else { 566| 59.5k| uint32_t i, j, k = 0, k_last = 0; 567| 59.5k| uint32_t partition_samples; 568| 59.5k| const uint32_t default_partition_samples = (residual_samples+predictor_order) >> partition_order; 569| 1.40M| for(i = 0; i < (1u<> max_partition_order; 54| 18.0M| uint32_t partitions = 1u << max_partition_order; 55| | 56| 18.0M| FLAC__ASSERT(default_partition_samples > predictor_order); ------------------ | | 38| 18.0M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.0M] | | ------------------ ------------------ 57| | 58| | /* first do max_partition_order */ 59| 18.0M| { 60| 18.0M| const uint32_t threshold = 32 - FLAC__bitmath_ilog2(default_partition_samples); 61| 18.0M| uint32_t partition, residual_sample, end = (uint32_t)(-(int32_t)predictor_order); 62| | 63| 18.0M| if(bps + FLAC__MAX_EXTRA_RESIDUAL_BPS < threshold) { ------------------ | | 44| 18.0M|#define FLAC__MAX_EXTRA_RESIDUAL_BPS 4 ------------------ | Branch (63:6): [True: 2.60M, False: 15.4M] ------------------ 64| 10.9M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (64:41): [True: 8.30M, False: 2.60M] ------------------ 65| 8.30M| __m256i sum256 = _mm256_setzero_si256(); 66| 8.30M| __m128i sum128; 67| 8.30M| end += default_partition_samples; 68| | 69| 61.5M| for( ; (int)residual_sample < (int)end-7; residual_sample+=8) { ------------------ | Branch (69:12): [True: 53.2M, False: 8.30M] ------------------ 70| 53.2M| __m256i res256 = _mm256_abs_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(residual+residual_sample))); 71| 53.2M| sum256 = _mm256_add_epi32(sum256, res256); 72| 53.2M| } 73| | 74| 8.30M| sum128 = _mm_add_epi32(_mm256_extracti128_si256(sum256, 1), _mm256_castsi256_si128(sum256)); 75| | 76| 11.3M| for( ; (int)residual_sample < (int)end-3; residual_sample+=4) { ------------------ | Branch (76:12): [True: 3.05M, False: 8.30M] ------------------ 77| 3.05M| __m128i res128 = _mm_abs_epi32(_mm_loadu_si128((const __m128i*)(const void*)(residual+residual_sample))); 78| 3.05M| sum128 = _mm_add_epi32(sum128, res128); 79| 3.05M| } 80| | 81| 17.5M| for( ; residual_sample < end; residual_sample++) { ------------------ | Branch (81:12): [True: 9.22M, False: 8.30M] ------------------ 82| 9.22M| __m128i res128 = _mm_abs_epi32(_mm_cvtsi32_si128(residual[residual_sample])); 83| 9.22M| sum128 = _mm_add_epi32(sum128, res128); 84| 9.22M| } 85| | 86| 8.30M| sum128 = _mm_add_epi32(sum128, _mm_shuffle_epi32(sum128, _MM_SHUFFLE(1,0,3,2))); 87| 8.30M| sum128 = _mm_add_epi32(sum128, _mm_shufflelo_epi16(sum128, _MM_SHUFFLE(1,0,3,2))); 88| 8.30M| abs_residual_partition_sums[partition] = (FLAC__uint32)_mm_cvtsi128_si32(sum128); 89| |/* workaround for MSVC bugs (at least versions 2015 and 2017 are affected) */ 90| |#if (defined _MSC_VER) && (defined FLAC__CPU_X86_64) 91| | abs_residual_partition_sums[partition] &= 0xFFFFFFFF; /**/ 92| |#endif 93| 8.30M| } 94| 2.60M| } 95| 15.4M| else { /* have to pessimistically use 64 bits for accumulator */ 96| 49.0M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (96:41): [True: 33.6M, False: 15.4M] ------------------ 97| 33.6M| __m256i sum256 = _mm256_setzero_si256(); 98| 33.6M| __m128i sum128; 99| 33.6M| end += default_partition_samples; 100| | 101| 483M| for( ; (int)residual_sample < (int)end-3; residual_sample+=4) { ------------------ | Branch (101:12): [True: 449M, False: 33.6M] ------------------ 102| 449M| __m128i res128 = _mm_abs_epi32(_mm_loadu_si128((const __m128i*)(const void*)(residual+residual_sample))); 103| 449M| __m256i res256 = _mm256_cvtepu32_epi64(res128); 104| 449M| sum256 = _mm256_add_epi64(sum256, res256); 105| 449M| } 106| | 107| 33.6M| sum128 = _mm_add_epi64(_mm256_extracti128_si256(sum256, 1), _mm256_castsi256_si128(sum256)); 108| | 109| 46.9M| for( ; (int)residual_sample < (int)end-1; residual_sample+=2) { ------------------ | Branch (109:12): [True: 13.2M, False: 33.6M] ------------------ 110| 13.2M| __m128i res128 = _mm_abs_epi32(_mm_loadl_epi64((const __m128i*)(const void*)(residual+residual_sample))); 111| 13.2M| res128 = _mm_cvtepu32_epi64(res128); 112| 13.2M| sum128 = _mm_add_epi64(sum128, res128); 113| 13.2M| } 114| | 115| 47.7M| for( ; residual_sample < end; residual_sample++) { ------------------ | Branch (115:12): [True: 14.0M, False: 33.6M] ------------------ 116| 14.0M| __m128i res128 = _mm_abs_epi32(_mm_cvtsi32_si128(residual[residual_sample])); 117| 14.0M| sum128 = _mm_add_epi64(sum128, res128); 118| 14.0M| } 119| | 120| 33.6M| sum128 = _mm_add_epi64(sum128, _mm_srli_si128(sum128, 8)); 121| 33.6M| _mm_storel_epi64((__m128i*)(void*)(abs_residual_partition_sums+partition), sum128); 122| 33.6M| } 123| 15.4M| } 124| 18.0M| } 125| | 126| | /* now merge partitions for lower orders */ 127| 18.0M| { 128| 18.0M| uint32_t from_partition = 0, to_partition = partitions; 129| 18.0M| int partition_order; 130| 18.7M| for(partition_order = (int)max_partition_order - 1; partition_order >= (int)min_partition_order; partition_order--) { ------------------ | Branch (130:55): [True: 706k, False: 18.0M] ------------------ 131| 706k| uint32_t i; 132| 706k| partitions >>= 1; 133| 3.07M| for(i = 0; i < partitions; i++) { ------------------ | Branch (133:15): [True: 2.37M, False: 706k] ------------------ 134| 2.37M| abs_residual_partition_sums[to_partition++] = 135| 2.37M| abs_residual_partition_sums[from_partition ] + 136| 2.37M| abs_residual_partition_sums[from_partition+1]; 137| 2.37M| from_partition += 2; 138| 2.37M| } 139| 706k| } 140| 18.0M| } 141| 18.0M| _mm256_zeroupper(); 142| 18.0M|} FLAC__window_bartlett: 51| 768|{ 52| 768| const FLAC__int32 N = L - 1; 53| 768| FLAC__int32 n; 54| | 55| 768| if (L & 1) { ------------------ | Branch (55:6): [True: 359, False: 409] ------------------ 56| 1.99M| for (n = 0; n <= N/2; n++) ------------------ | Branch (56:15): [True: 1.99M, False: 359] ------------------ 57| 1.99M| window[n] = 2.0f * n / (float)N; 58| 1.99M| for (; n <= N; n++) ------------------ | Branch (58:10): [True: 1.99M, False: 359] ------------------ 59| 1.99M| window[n] = 2.0f - 2.0f * n / (float)N; 60| 359| } 61| 409| else { 62| 2.78M| for (n = 0; n <= L/2-1; n++) ------------------ | Branch (62:15): [True: 2.78M, False: 409] ------------------ 63| 2.78M| window[n] = 2.0f * n / (float)N; 64| 2.78M| for (; n <= N; n++) ------------------ | Branch (64:10): [True: 2.78M, False: 409] ------------------ 65| 2.78M| window[n] = 2.0f - 2.0f * n / (float)N; 66| 409| } 67| 768|} FLAC__window_bartlett_hann: 70| 104|{ 71| 104| const FLAC__int32 N = L - 1; 72| 104| FLAC__int32 n; 73| | 74| 733k| for (n = 0; n < L; n++) ------------------ | Branch (74:14): [True: 733k, False: 104] ------------------ 75| 733k| window[n] = (FLAC__real)(0.62f - 0.48f * fabsf((float)n/(float)N-0.5f) - 0.38f * cosf(2.0f * M_PI * ((float)n/(float)N))); 76| 104|} FLAC__window_blackman: 79| 118|{ 80| 118| const FLAC__int32 N = L - 1; 81| 118| FLAC__int32 n; 82| | 83| 1.12M| for (n = 0; n < L; n++) ------------------ | Branch (83:14): [True: 1.12M, False: 118] ------------------ 84| 1.12M| window[n] = (FLAC__real)(0.42f - 0.5f * cosf(2.0f * M_PI * n / N) + 0.08f * cosf(4.0f * M_PI * n / N)); 85| 118|} FLAC__window_blackman_harris_4term_92db_sidelobe: 89| 103|{ 90| 103| const FLAC__int32 N = L - 1; 91| 103| FLAC__int32 n; 92| | 93| 1.00M| for (n = 0; n <= N; n++) ------------------ | Branch (93:14): [True: 1.00M, False: 103] ------------------ 94| 1.00M| window[n] = (FLAC__real)(0.35875f - 0.48829f * cosf(2.0f * M_PI * n / N) + 0.14128f * cosf(4.0f * M_PI * n / N) - 0.01168f * cosf(6.0f * M_PI * n / N)); 95| 103|} FLAC__window_connes: 98| 233|{ 99| 233| const FLAC__int32 N = L - 1; 100| 233| const double N2 = (double)N / 2.; 101| 233| FLAC__int32 n; 102| | 103| 4.46M| for (n = 0; n <= N; n++) { ------------------ | Branch (103:14): [True: 4.46M, False: 233] ------------------ 104| 4.46M| double k = ((double)n - N2) / N2; 105| 4.46M| k = 1.0f - k * k; 106| 4.46M| window[n] = (FLAC__real)(k * k); 107| 4.46M| } 108| 233|} FLAC__window_flattop: 111| 150|{ 112| 150| const FLAC__int32 N = L - 1; 113| 150| FLAC__int32 n; 114| | 115| 2.10M| for (n = 0; n < L; n++) ------------------ | Branch (115:14): [True: 2.10M, False: 150] ------------------ 116| 2.10M| window[n] = (FLAC__real)(0.21557895f - 0.41663158f * cosf(2.0f * M_PI * n / N) + 0.277263158f * cosf(4.0f * M_PI * n / N) - 0.083578947f * cosf(6.0f * M_PI * n / N) + 0.006947368f * cosf(8.0f * M_PI * n / N)); 117| 150|} FLAC__window_gauss: 120| 187|{ 121| 187| const FLAC__int32 N = L - 1; 122| 187| const double N2 = (double)N / 2.; 123| 187| FLAC__int32 n; 124| | 125| 187| if(!(stddev > 0.0f && stddev <= 0.5f)) ------------------ | Branch (125:7): [True: 187, False: 0] | Branch (125:24): [True: 187, False: 0] ------------------ 126| | /* stddev is not between 0 and 0.5, might be NaN. 127| | * Default to 0.5 */ 128| 0| FLAC__window_gauss(window, L, 0.25f); 129| 187| else { 130| 2.05M| for (n = 0; n <= N; n++) { ------------------ | Branch (130:15): [True: 2.05M, False: 187] ------------------ 131| 2.05M| const double k = ((double)n - N2) / (stddev * N2); 132| 2.05M| window[n] = (FLAC__real)exp(-0.5f * k * k); 133| 2.05M| } 134| 187| } 135| 187|} FLAC__window_hamming: 138| 279|{ 139| 279| const FLAC__int32 N = L - 1; 140| 279| FLAC__int32 n; 141| | 142| 2.62M| for (n = 0; n < L; n++) ------------------ | Branch (142:14): [True: 2.62M, False: 279] ------------------ 143| 2.62M| window[n] = (FLAC__real)(0.54f - 0.46f * cosf(2.0f * M_PI * n / N)); 144| 279|} FLAC__window_hann: 147| 698|{ 148| 698| const FLAC__int32 N = L - 1; 149| 698| FLAC__int32 n; 150| | 151| 13.4M| for (n = 0; n < L; n++) ------------------ | Branch (151:14): [True: 13.4M, False: 698] ------------------ 152| 13.4M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(2.0f * M_PI * n / N)); 153| 698|} FLAC__window_kaiser_bessel: 156| 118|{ 157| 118| const FLAC__int32 N = L - 1; 158| 118| FLAC__int32 n; 159| | 160| 2.37M| for (n = 0; n < L; n++) ------------------ | Branch (160:14): [True: 2.37M, False: 118] ------------------ 161| 2.37M| window[n] = (FLAC__real)(0.402f - 0.498f * cosf(2.0f * M_PI * n / N) + 0.098f * cosf(4.0f * M_PI * n / N) - 0.001f * cosf(6.0f * M_PI * n / N)); 162| 118|} FLAC__window_nuttall: 165| 85|{ 166| 85| const FLAC__int32 N = L - 1; 167| 85| FLAC__int32 n; 168| | 169| 1.22M| for (n = 0; n < L; n++) ------------------ | Branch (169:14): [True: 1.22M, False: 85] ------------------ 170| 1.22M| window[n] = (FLAC__real)(0.3635819f - 0.4891775f*cosf(2.0f*M_PI*n/N) + 0.1365995f*cosf(4.0f*M_PI*n/N) - 0.0106411f*cosf(6.0f*M_PI*n/N)); 171| 85|} FLAC__window_rectangle: 174| 15.7k|{ 175| 15.7k| FLAC__int32 n; 176| | 177| 213M| for (n = 0; n < L; n++) ------------------ | Branch (177:14): [True: 213M, False: 15.7k] ------------------ 178| 213M| window[n] = 1.0f; 179| 15.7k|} FLAC__window_triangle: 182| 679|{ 183| 679| FLAC__int32 n; 184| | 185| 679| if (L & 1) { ------------------ | Branch (185:6): [True: 346, False: 333] ------------------ 186| 2.11M| for (n = 1; n <= (L+1)/2; n++) ------------------ | Branch (186:15): [True: 2.11M, False: 346] ------------------ 187| 2.11M| window[n-1] = 2.0f * n / ((float)L + 1.0f); 188| 2.11M| for (; n <= L; n++) ------------------ | Branch (188:10): [True: 2.11M, False: 346] ------------------ 189| 2.11M| window[n-1] = (float)(2 * (L - n + 1)) / ((float)L + 1.0f); 190| 346| } 191| 333| else { 192| 1.88M| for (n = 1; n <= L/2; n++) ------------------ | Branch (192:15): [True: 1.88M, False: 333] ------------------ 193| 1.88M| window[n-1] = 2.0f * n / ((float)L + 1.0f); 194| 1.88M| for (; n <= L; n++) ------------------ | Branch (194:10): [True: 1.88M, False: 333] ------------------ 195| 1.88M| window[n-1] = (float)(2 * (L - n + 1)) / ((float)L + 1.0f); 196| 333| } 197| 679|} FLAC__window_tukey: 200| 16.0k|{ 201| 16.0k| if (p <= 0.0) ------------------ | Branch (201:6): [True: 897, False: 15.1k] ------------------ 202| 897| FLAC__window_rectangle(window, L); 203| 15.1k| else if (p >= 1.0) ------------------ | Branch (203:11): [True: 181, False: 14.9k] ------------------ 204| 181| FLAC__window_hann(window, L); 205| 14.9k| else if (!(p > 0.0f && p < 1.0f)) ------------------ | Branch (205:13): [True: 14.6k, False: 348] | Branch (205:25): [True: 14.6k, False: 0] ------------------ 206| | /* p is not between 0 and 1, probably NaN. 207| | * Default to 0.5 */ 208| 348| FLAC__window_tukey(window, L, 0.5f); 209| 14.6k| else { 210| 14.6k| const FLAC__int32 Np = (FLAC__int32)(p / 2.0f * L) - 1; 211| 14.6k| FLAC__int32 n; 212| | /* start with rectangle... */ 213| 14.6k| FLAC__window_rectangle(window, L); 214| | /* ...replace ends with hann */ 215| 14.6k| if (Np > 0) { ------------------ | Branch (215:7): [True: 12.4k, False: 2.16k] ------------------ 216| 46.4M| for (n = 0; n <= Np; n++) { ------------------ | Branch (216:16): [True: 46.4M, False: 12.4k] ------------------ 217| 46.4M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * n / Np)); 218| | window[L-Np-1+n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * (n+Np) / Np)); 219| 46.4M| } 220| 12.4k| } 221| 14.6k| } 222| 16.0k|} FLAC__window_partial_tukey: 225| 9.42k|{ 226| 9.42k| const FLAC__int32 start_n = (FLAC__int32)(start * L); 227| 9.42k| const FLAC__int32 end_n = (FLAC__int32)(end * L); 228| 9.42k| const FLAC__int32 N = end_n - start_n; 229| 9.42k| FLAC__int32 Np, n, i; 230| | 231| 9.42k| if (p <= 0.0f) ------------------ | Branch (231:6): [True: 1.25k, False: 8.17k] ------------------ 232| 1.25k| FLAC__window_partial_tukey(window, L, 0.05f, start, end); 233| 8.17k| else if (p >= 1.0f) ------------------ | Branch (233:11): [True: 651, False: 7.52k] ------------------ 234| 651| FLAC__window_partial_tukey(window, L, 0.95f, start, end); 235| 7.52k| else if (!(p > 0.0f && p < 1.0f)) ------------------ | Branch (235:13): [True: 7.08k, False: 440] | Branch (235:25): [True: 7.08k, False: 0] ------------------ 236| | /* p is not between 0 and 1, probably NaN. 237| | * Default to 0.5 */ 238| 440| FLAC__window_partial_tukey(window, L, 0.5f, start, end); 239| 7.08k| else { 240| | 241| 7.08k| Np = (FLAC__int32)(p / 2.0f * N); 242| | 243| 31.3M| for (n = 0; n < start_n && n < L; n++) ------------------ | Branch (243:15): [True: 31.3M, False: 7.08k] | Branch (243:30): [True: 31.3M, False: 0] ------------------ 244| 31.3M| window[n] = 0.0f; 245| 1.83M| for (i = 1; n < (start_n+Np) && n < L; n++, i++) ------------------ | Branch (245:15): [True: 1.83M, False: 7.08k] | Branch (245:35): [True: 1.83M, False: 0] ------------------ 246| 1.83M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np)); 247| 10.8M| for (; n < (end_n-Np) && n < L; n++) ------------------ | Branch (247:10): [True: 10.8M, False: 7.08k] | Branch (247:28): [True: 10.8M, False: 0] ------------------ 248| 10.8M| window[n] = 1.0f; 249| 1.83M| for (i = Np; n < end_n && n < L; n++, i--) ------------------ | Branch (249:16): [True: 1.83M, False: 7.08k] | Branch (249:29): [True: 1.83M, False: 0] ------------------ 250| 1.83M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np)); 251| 31.3M| for (; n < L; n++) ------------------ | Branch (251:10): [True: 31.3M, False: 7.08k] ------------------ 252| 31.3M| window[n] = 0.0f; 253| 7.08k| } 254| 9.42k|} FLAC__window_punchout_tukey: 257| 10.4k|{ 258| 10.4k| const FLAC__int32 start_n = (FLAC__int32)(start * L); 259| 10.4k| const FLAC__int32 end_n = (FLAC__int32)(end * L); 260| 10.4k| FLAC__int32 Ns, Ne, n, i; 261| | 262| 10.4k| if (p <= 0.0f) ------------------ | Branch (262:6): [True: 229, False: 10.2k] ------------------ 263| 229| FLAC__window_punchout_tukey(window, L, 0.05f, start, end); 264| 10.2k| else if (p >= 1.0f) ------------------ | Branch (264:11): [True: 136, False: 10.0k] ------------------ 265| 136| FLAC__window_punchout_tukey(window, L, 0.95f, start, end); 266| 10.0k| else if (!(p > 0.0f && p < 1.0f)) ------------------ | Branch (266:13): [True: 9.99k, False: 71] | Branch (266:25): [True: 9.99k, False: 0] ------------------ 267| | /* p is not between 0 and 1, probably NaN. 268| | * Default to 0.5 */ 269| 71| FLAC__window_punchout_tukey(window, L, 0.5f, start, end); 270| 9.99k| else { 271| | 272| 9.99k| Ns = (FLAC__int32)(p / 2.0f * start_n); 273| 9.99k| Ne = (FLAC__int32)(p / 2.0f * (L - end_n)); 274| | 275| 8.62M| for (n = 0, i = 1; n < Ns && n < L; n++, i++) ------------------ | Branch (275:22): [True: 8.61M, False: 9.99k] | Branch (275:32): [True: 8.61M, False: 0] ------------------ 276| 8.61M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns)); 277| 65.5M| for (; n < start_n-Ns && n < L; n++) ------------------ | Branch (277:10): [True: 65.5M, False: 9.99k] | Branch (277:28): [True: 65.5M, False: 0] ------------------ 278| 65.5M| window[n] = 1.0f; 279| 8.62M| for (i = Ns; n < start_n && n < L; n++, i--) ------------------ | Branch (279:16): [True: 8.61M, False: 9.99k] | Branch (279:31): [True: 8.61M, False: 0] ------------------ 280| 8.61M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns)); 281| 13.0M| for (; n < end_n && n < L; n++) ------------------ | Branch (281:10): [True: 12.9M, False: 9.99k] | Branch (281:23): [True: 12.9M, False: 0] ------------------ 282| 12.9M| window[n] = 0.0f; 283| 8.62M| for (i = 1; n < end_n+Ne && n < L; n++, i++) ------------------ | Branch (283:15): [True: 8.61M, False: 9.99k] | Branch (283:31): [True: 8.61M, False: 0] ------------------ 284| 8.61M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne)); 285| 65.5M| for (; n < L - (Ne) && n < L; n++) ------------------ | Branch (285:10): [True: 65.5M, False: 9.99k] | Branch (285:26): [True: 65.5M, False: 0] ------------------ 286| 65.5M| window[n] = 1.0f; 287| 8.62M| for (i = Ne; n < L; n++, i--) ------------------ | Branch (287:16): [True: 8.61M, False: 9.99k] ------------------ 288| 8.61M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne)); 289| 9.99k| } 290| 10.4k|} FLAC__window_welch: 293| 259|{ 294| 259| const FLAC__int32 N = L - 1; 295| 259| const double N2 = (double)N / 2.; 296| 259| FLAC__int32 n; 297| | 298| 3.35M| for (n = 0; n <= N; n++) { ------------------ | Branch (298:14): [True: 3.35M, False: 259] ------------------ 299| 3.35M| const double k = ((double)n - N2) / N2; 300| 3.35M| window[n] = (FLAC__real)(1.0f - k * k); 301| 3.35M| } 302| 259|} ogg_page_granulepos: 49| 10.1k|ogg_int64_t ogg_page_granulepos(const ogg_page *og){ 50| 10.1k| unsigned char *page=og->header; 51| 10.1k| ogg_uint64_t granulepos=page[13]&(0xff); 52| 10.1k| granulepos= (granulepos<<8)|(page[12]&0xff); 53| 10.1k| granulepos= (granulepos<<8)|(page[11]&0xff); 54| 10.1k| granulepos= (granulepos<<8)|(page[10]&0xff); 55| 10.1k| granulepos= (granulepos<<8)|(page[9]&0xff); 56| 10.1k| granulepos= (granulepos<<8)|(page[8]&0xff); 57| 10.1k| granulepos= (granulepos<<8)|(page[7]&0xff); 58| 10.1k| granulepos= (granulepos<<8)|(page[6]&0xff); 59| 10.1k| return((ogg_int64_t)granulepos); 60| 10.1k|} ogg_stream_init: 133| 2.89k|int ogg_stream_init(ogg_stream_state *os,int serialno){ 134| 2.89k| if(os){ ------------------ | Branch (134:6): [True: 2.89k, False: 0] ------------------ 135| 2.89k| memset(os,0,sizeof(*os)); 136| 2.89k| os->body_storage=16*1024; 137| 2.89k| os->lacing_storage=1024; 138| | 139| 2.89k| os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data)); ------------------ | | 21| 2.89k|#define _ogg_malloc malloc ------------------ 140| 2.89k| os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals)); ------------------ | | 21| 2.89k|#define _ogg_malloc malloc ------------------ 141| 2.89k| os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals)); ------------------ | | 21| 2.89k|#define _ogg_malloc malloc ------------------ 142| | 143| 2.89k| if(!os->body_data || !os->lacing_vals || !os->granule_vals){ ------------------ | Branch (143:8): [True: 0, False: 2.89k] | Branch (143:26): [True: 0, False: 2.89k] | Branch (143:46): [True: 0, False: 2.89k] ------------------ 144| 0| ogg_stream_clear(os); 145| 0| return -1; 146| 0| } 147| | 148| 2.89k| os->serialno=serialno; 149| | 150| 2.89k| return(0); 151| 2.89k| } 152| 0| return(-1); 153| 2.89k|} ogg_stream_check: 156| 437k|int ogg_stream_check(ogg_stream_state *os){ 157| 437k| if(!os || !os->body_data) return -1; ------------------ | Branch (157:6): [True: 0, False: 437k] | Branch (157:13): [True: 0, False: 437k] ------------------ 158| 437k| return 0; 159| 437k|} ogg_stream_clear: 162| 2.89k|int ogg_stream_clear(ogg_stream_state *os){ 163| 2.89k| if(os){ ------------------ | Branch (163:6): [True: 2.89k, False: 0] ------------------ 164| 2.89k| if(os->body_data)_ogg_free(os->body_data); ------------------ | | 24| 2.89k|#define _ogg_free free ------------------ | Branch (164:8): [True: 2.89k, False: 0] ------------------ 165| 2.89k| if(os->lacing_vals)_ogg_free(os->lacing_vals); ------------------ | | 24| 2.89k|#define _ogg_free free ------------------ | Branch (165:8): [True: 2.89k, False: 0] ------------------ 166| 2.89k| if(os->granule_vals)_ogg_free(os->granule_vals); ------------------ | | 24| 2.89k|#define _ogg_free free ------------------ | Branch (166:8): [True: 2.89k, False: 0] ------------------ 167| | 168| 2.89k| memset(os,0,sizeof(*os)); 169| 2.89k| } 170| 2.89k| return(0); 171| 2.89k|} ogg_page_checksum_set: 255| 10.1k|void ogg_page_checksum_set(ogg_page *og){ 256| 10.1k| if(og){ ------------------ | Branch (256:6): [True: 10.1k, False: 0] ------------------ 257| 10.1k| ogg_uint32_t crc_reg=0; 258| | 259| | /* safety; needed for API behavior, but not framing code */ 260| 10.1k| og->header[22]=0; 261| 10.1k| og->header[23]=0; 262| 10.1k| og->header[24]=0; 263| 10.1k| og->header[25]=0; 264| | 265| 10.1k| crc_reg=_os_update_crc(crc_reg,og->header,og->header_len); 266| 10.1k| crc_reg=_os_update_crc(crc_reg,og->body,og->body_len); 267| | 268| 10.1k| og->header[22]=(unsigned char)(crc_reg&0xff); 269| 10.1k| og->header[23]=(unsigned char)((crc_reg>>8)&0xff); 270| 10.1k| og->header[24]=(unsigned char)((crc_reg>>16)&0xff); 271| 10.1k| og->header[25]=(unsigned char)((crc_reg>>24)&0xff); 272| 10.1k| } 273| 10.1k|} ogg_stream_iovecin: 277| 142k| long e_o_s, ogg_int64_t granulepos){ 278| | 279| 142k| long bytes = 0, lacing_vals; 280| 142k| int i; 281| | 282| 142k| if(ogg_stream_check(os)) return -1; ------------------ | Branch (282:6): [True: 0, False: 142k] ------------------ 283| 142k| if(!iov) return 0; ------------------ | Branch (283:6): [True: 0, False: 142k] ------------------ 284| | 285| 285k| for (i = 0; i < count; ++i){ ------------------ | Branch (285:15): [True: 142k, False: 142k] ------------------ 286| 142k| if(iov[i].iov_len>LONG_MAX) return -1; ------------------ | Branch (286:8): [True: 0, False: 142k] ------------------ 287| 142k| if(bytes>LONG_MAX-(long)iov[i].iov_len) return -1; ------------------ | Branch (287:8): [True: 0, False: 142k] ------------------ 288| 142k| bytes += (long)iov[i].iov_len; 289| 142k| } 290| 142k| lacing_vals=bytes/255+1; 291| | 292| 142k| if(os->body_returned){ ------------------ | Branch (292:6): [True: 6.87k, False: 136k] ------------------ 293| | /* advance packet data according to the body_returned pointer. We 294| | had to keep it around to return a pointer into the buffer last 295| | call */ 296| | 297| 6.87k| os->body_fill-=os->body_returned; 298| 6.87k| if(os->body_fill) ------------------ | Branch (298:8): [True: 1.29k, False: 5.58k] ------------------ 299| 1.29k| memmove(os->body_data,os->body_data+os->body_returned, 300| 1.29k| os->body_fill); 301| 6.87k| os->body_returned=0; 302| 6.87k| } 303| | 304| | /* make sure we have the buffer storage */ 305| 142k| if(_os_body_expand(os,bytes) || _os_lacing_expand(os,lacing_vals)) ------------------ | Branch (305:6): [True: 0, False: 142k] | Branch (305:35): [True: 0, False: 142k] ------------------ 306| 0| return -1; 307| | 308| | /* Copy in the submitted packet. Yes, the copy is a waste; this is 309| | the liability of overly clean abstraction for the time being. It 310| | will actually be fairly easy to eliminate the extra copy in the 311| | future */ 312| | 313| 285k| for (i = 0; i < count; ++i) { ------------------ | Branch (313:15): [True: 142k, False: 142k] ------------------ 314| 142k| memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len); 315| 142k| os->body_fill += (long)iov[i].iov_len; 316| 142k| } 317| | 318| | /* Store lacing vals for this packet */ 319| 273k| for(i=0;ilacing_vals[os->lacing_fill+i]=255; 321| 130k| os->granule_vals[os->lacing_fill+i]=os->granulepos; 322| 130k| } 323| 142k| os->lacing_vals[os->lacing_fill+i]=bytes%255; 324| 142k| os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos; 325| | 326| | /* flag the first segment as the beginning of the packet */ 327| 142k| os->lacing_vals[os->lacing_fill]|= 0x100; 328| | 329| 142k| os->lacing_fill+=lacing_vals; 330| | 331| | /* for the sake of completeness */ 332| 142k| os->packetno++; 333| | 334| 142k| if(e_o_s)os->e_o_s=1; ------------------ | Branch (334:6): [True: 2.52k, False: 140k] ------------------ 335| | 336| 142k| return(0); 337| 142k|} ogg_stream_packetin: 339| 142k|int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){ 340| 142k| ogg_iovec_t iov; 341| 142k| iov.iov_base = op->packet; 342| 142k| iov.iov_len = op->bytes; 343| 142k| return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos); 344| 142k|} ogg_stream_flush: 495| 11.5k|int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){ 496| 11.5k| return ogg_stream_flush_i(os,og,1,4096); 497| 11.5k|} ogg_stream_pageout: 511| 141k|int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){ 512| 141k| int force=0; 513| 141k| if(ogg_stream_check(os)) return 0; ------------------ | Branch (513:6): [True: 0, False: 141k] ------------------ 514| | 515| 141k| if((os->e_o_s&&os->lacing_fill) || /* 'were done, now flush' case */ ------------------ | Branch (515:7): [True: 5.38k, False: 136k] | Branch (515:18): [True: 2.85k, False: 2.52k] ------------------ 516| 138k| (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */ ------------------ | Branch (516:7): [True: 135k, False: 2.68k] | Branch (516:24): [True: 0, False: 135k] ------------------ 517| 2.85k| force=1; 518| | 519| 141k| return(ogg_stream_flush_i(os,og,force,4096)); 520| 141k|} framing.c:_os_update_crc: 237| 20.2k|static ogg_uint32_t _os_update_crc(ogg_uint32_t crc, unsigned char *buffer, int size){ 238| 5.06M| while (size>=8){ ------------------ | Branch (238:10): [True: 5.04M, False: 20.2k] ------------------ 239| 5.04M| crc^=((ogg_uint32_t)buffer[0]<<24)|((ogg_uint32_t)buffer[1]<<16)|((ogg_uint32_t)buffer[2]<<8)|((ogg_uint32_t)buffer[3]); 240| | 241| 5.04M| crc=crc_lookup[7][ crc>>24 ]^crc_lookup[6][(crc>>16)&0xFF]^ 242| 5.04M| crc_lookup[5][(crc>> 8)&0xFF]^crc_lookup[4][ crc &0xFF]^ 243| 5.04M| crc_lookup[3][buffer[4] ]^crc_lookup[2][buffer[5] ]^ 244| 5.04M| crc_lookup[1][buffer[6] ]^crc_lookup[0][buffer[7] ]; 245| | 246| 5.04M| buffer+=8; 247| 5.04M| size-=8; 248| 5.04M| } 249| | 250| 89.4k| while (size--) ------------------ | Branch (250:10): [True: 69.2k, False: 20.2k] ------------------ 251| 69.2k| crc=(crc<<8)^crc_lookup[0][((crc >> 24)&0xff)^*buffer++]; 252| 20.2k| return crc; 253| 20.2k|} framing.c:_os_body_expand: 184| 142k|static int _os_body_expand(ogg_stream_state *os,long needed){ 185| 142k| if(os->body_storage-needed<=os->body_fill){ ------------------ | Branch (185:6): [True: 380, False: 142k] ------------------ 186| 380| long body_storage; 187| 380| void *ret; 188| 380| if(os->body_storage>LONG_MAX-needed){ ------------------ | Branch (188:8): [True: 0, False: 380] ------------------ 189| 0| ogg_stream_clear(os); 190| 0| return -1; 191| 0| } 192| 380| body_storage=os->body_storage+needed; 193| 380| if(body_storagebody_data,body_storage*sizeof(*os->body_data)); ------------------ | | 23| 380|#define _ogg_realloc realloc ------------------ 195| 380| if(!ret){ ------------------ | Branch (195:8): [True: 0, False: 380] ------------------ 196| 0| ogg_stream_clear(os); 197| 0| return -1; 198| 0| } 199| 380| os->body_storage=body_storage; 200| 380| os->body_data=ret; 201| 380| } 202| 142k| return 0; 203| 142k|} framing.c:_os_lacing_expand: 205| 142k|static int _os_lacing_expand(ogg_stream_state *os,long needed){ 206| 142k| if(os->lacing_storage-needed<=os->lacing_fill){ ------------------ | Branch (206:6): [True: 26, False: 142k] ------------------ 207| 26| long lacing_storage; 208| 26| void *ret; 209| 26| if(os->lacing_storage>LONG_MAX-needed){ ------------------ | Branch (209:8): [True: 0, False: 26] ------------------ 210| 0| ogg_stream_clear(os); 211| 0| return -1; 212| 0| } 213| 26| lacing_storage=os->lacing_storage+needed; 214| 26| if(lacing_storagelacing_vals,lacing_storage*sizeof(*os->lacing_vals)); ------------------ | | 23| 26|#define _ogg_realloc realloc ------------------ 216| 26| if(!ret){ ------------------ | Branch (216:8): [True: 0, False: 26] ------------------ 217| 0| ogg_stream_clear(os); 218| 0| return -1; 219| 0| } 220| 26| os->lacing_vals=ret; 221| 26| ret=_ogg_realloc(os->granule_vals,lacing_storage* ------------------ | | 23| 26|#define _ogg_realloc realloc ------------------ 222| 26| sizeof(*os->granule_vals)); 223| 26| if(!ret){ ------------------ | Branch (223:8): [True: 0, False: 26] ------------------ 224| 0| ogg_stream_clear(os); 225| 0| return -1; 226| 0| } 227| 26| os->granule_vals=ret; 228| 26| os->lacing_storage=lacing_storage; 229| 26| } 230| 142k| return 0; 231| 142k|} framing.c:ogg_stream_flush_i: 349| 153k|static int ogg_stream_flush_i(ogg_stream_state *os,ogg_page *og, int force, int nfill){ 350| 153k| int i; 351| 153k| int vals=0; 352| 153k| int maxvals; 353| 153k| int bytes=0; 354| 153k| long acc=0; 355| 153k| ogg_int64_t granule_pos=-1; 356| | 357| 153k| if(ogg_stream_check(os)) return(0); ------------------ | Branch (357:6): [True: 0, False: 153k] ------------------ 358| 153k| maxvals=(os->lacing_fill>255?255:os->lacing_fill); ------------------ | Branch (358:12): [True: 345, False: 152k] ------------------ 359| 153k| if(maxvals==0) return(0); ------------------ | Branch (359:6): [True: 8.47k, False: 144k] ------------------ 360| | 361| | /* construct a page */ 362| | /* decide how many segments to include */ 363| | 364| | /* If this is the initial header case, the first page must only include 365| | the initial header packet */ 366| 144k| if(os->b_o_s==0){ /* 'initial header page' case */ ------------------ | Branch (366:6): [True: 2.89k, False: 141k] ------------------ 367| 2.89k| granule_pos=0; 368| 2.89k| for(vals=0;valslacing_vals[vals]&0x0ff)<255){ ------------------ | Branch (369:10): [True: 2.89k, False: 0] ------------------ 370| 2.89k| vals++; 371| 2.89k| break; 372| 2.89k| } 373| 2.89k| } 374| 141k| }else{ 375| | 376| | /* The extra packets_done, packet_just_done logic here attempts to do two things: 377| | 1) Don't unnecessarily span pages. 378| | 2) Unless necessary, don't flush pages if there are less than four packets on 379| | them; this expands page size to reduce unnecessary overhead if incoming packets 380| | are large. 381| | These are not necessary behaviors, just 'always better than naive flushing' 382| | without requiring an application to explicitly request a specific optimized 383| | behavior. We'll want an explicit behavior setup pathway eventually as well. */ 384| | 385| 141k| int packets_done=0; 386| 141k| int packet_just_done=0; 387| 10.4M| for(vals=0;valsnfill && packet_just_done>=4){ ------------------ | Branch (388:10): [True: 141k, False: 10.1M] | Branch (388:23): [True: 1.31k, False: 140k] ------------------ 389| 1.31k| force=1; 390| 1.31k| break; 391| 1.31k| } 392| 10.3M| acc+=os->lacing_vals[vals]&0x0ff; 393| 10.3M| if((os->lacing_vals[vals]&0xff)<255){ ------------------ | Branch (393:10): [True: 10.1M, False: 170k] ------------------ 394| 10.1M| granule_pos=os->granule_vals[vals]; 395| 10.1M| packet_just_done=++packets_done; 396| 10.1M| }else 397| 170k| packet_just_done=0; 398| 10.3M| } 399| 141k| if(vals==255)force=1; ------------------ | Branch (399:8): [True: 501, False: 141k] ------------------ 400| 141k| } 401| | 402| 144k| if(!force) return(0); ------------------ | Branch (402:6): [True: 134k, False: 10.1k] ------------------ 403| | 404| | /* construct the header in temp storage */ 405| 10.1k| memcpy(os->header,"OggS",4); 406| | 407| | /* stream structure version */ 408| 10.1k| os->header[4]=0x00; 409| | 410| | /* continued packet flag? */ 411| 10.1k| os->header[5]=0x00; 412| 10.1k| if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01; ------------------ | Branch (412:6): [True: 338, False: 9.78k] ------------------ 413| | /* first page flag? */ 414| 10.1k| if(os->b_o_s==0)os->header[5]|=0x02; ------------------ | Branch (414:6): [True: 2.89k, False: 7.22k] ------------------ 415| | /* last page flag? */ 416| 10.1k| if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04; ------------------ | Branch (416:6): [True: 2.85k, False: 7.26k] | Branch (416:19): [True: 2.52k, False: 329] ------------------ 417| 10.1k| os->b_o_s=1; 418| | 419| | /* 64 bits of PCM position */ 420| 91.0k| for(i=6;i<14;i++){ ------------------ | Branch (420:11): [True: 80.9k, False: 10.1k] ------------------ 421| 80.9k| os->header[i]=(unsigned char)(granule_pos&0xff); 422| 80.9k| granule_pos>>=8; 423| 80.9k| } 424| | 425| | /* 32 bits of stream serial number */ 426| 10.1k| { 427| 10.1k| long serialno=os->serialno; 428| 50.6k| for(i=14;i<18;i++){ ------------------ | Branch (428:14): [True: 40.4k, False: 10.1k] ------------------ 429| 40.4k| os->header[i]=(unsigned char)(serialno&0xff); 430| 40.4k| serialno>>=8; 431| 40.4k| } 432| 10.1k| } 433| | 434| | /* 32 bits of page counter (we have both counter and page header 435| | because this val can roll over) */ 436| 10.1k| if(os->pageno==-1)os->pageno=0; /* because someone called ------------------ | Branch (436:6): [True: 0, False: 10.1k] ------------------ 437| | stream_reset; this would be a 438| | strange thing to do in an 439| | encode stream, but it has 440| | plausible uses */ 441| 10.1k| { 442| 10.1k| long pageno=os->pageno++; 443| 50.6k| for(i=18;i<22;i++){ ------------------ | Branch (443:14): [True: 40.4k, False: 10.1k] ------------------ 444| 40.4k| os->header[i]=(unsigned char)(pageno&0xff); 445| 40.4k| pageno>>=8; 446| 40.4k| } 447| 10.1k| } 448| | 449| | /* zero for computation; filled in later */ 450| 10.1k| os->header[22]=0; 451| 10.1k| os->header[23]=0; 452| 10.1k| os->header[24]=0; 453| 10.1k| os->header[25]=0; 454| | 455| | /* segment table */ 456| 10.1k| os->header[26]=(unsigned char)(vals&0xff); 457| 283k| for(i=0;iheader[i+27]=(unsigned char)(os->lacing_vals[i]&0xff); 459| | 460| | /* set pointers in the ogg_page struct */ 461| 10.1k| og->header=os->header; 462| 10.1k| og->header_len=os->header_fill=vals+27; 463| 10.1k| og->body=os->body_data+os->body_returned; 464| 10.1k| og->body_len=bytes; 465| | 466| | /* advance the lacing data and set the body_returned pointer */ 467| | 468| 10.1k| os->lacing_fill-=vals; 469| 10.1k| memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals)); 470| 10.1k| memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals)); 471| 10.1k| os->body_returned+=bytes; 472| | 473| | /* calculate the checksum */ 474| | 475| 10.1k| ogg_page_checksum_set(og); 476| | 477| | /* done */ 478| 10.1k| return(1); 479| 144k|}